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 |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
100 std::vector<rtc::Buffer*> sent_packets_; | 100 std::vector<rtc::Buffer*> sent_packets_; |
101 }; | 101 }; |
102 | 102 |
103 } // namespace | 103 } // namespace |
104 | 104 |
105 class MockRtpPacketSender : public RtpPacketSender { | 105 class MockRtpPacketSender : public RtpPacketSender { |
106 public: | 106 public: |
107 MockRtpPacketSender() {} | 107 MockRtpPacketSender() {} |
108 virtual ~MockRtpPacketSender() {} | 108 virtual ~MockRtpPacketSender() {} |
109 | 109 |
110 MOCK_METHOD6(SendPacket, | 110 MOCK_METHOD6(InsertPacket, |
111 bool(Priority priority, | 111 void(Priority priority, |
112 uint32_t ssrc, | 112 uint32_t ssrc, |
113 uint16_t sequence_number, | 113 uint16_t sequence_number, |
114 int64_t capture_time_ms, | 114 int64_t capture_time_ms, |
115 size_t bytes, | 115 size_t bytes, |
116 bool retransmission)); | 116 bool retransmission)); |
117 }; | 117 }; |
118 | 118 |
119 class RtpSenderTest : public ::testing::Test { | 119 class RtpSenderTest : public ::testing::Test { |
120 protected: | 120 protected: |
121 RtpSenderTest() | 121 RtpSenderTest() |
122 : fake_clock_(kStartTime), | 122 : fake_clock_(kStartTime), |
123 mock_paced_sender_(), | 123 mock_paced_sender_(), |
124 rtp_sender_(), | 124 rtp_sender_(), |
125 payload_(kPayload), | 125 payload_(kPayload), |
126 transport_(), | 126 transport_(), |
127 kMarkerBit(true) { | 127 kMarkerBit(true) { |
128 EXPECT_CALL(mock_paced_sender_, | 128 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)) |
129 SendPacket(_, _, _, _, _, _)).WillRepeatedly(testing::Return(true)); | 129 .WillRepeatedly(testing::Return()); |
130 } | 130 } |
131 | 131 |
132 void SetUp() override { | 132 void SetUp() override { SetUpRtpSender(true); } |
| 133 |
| 134 void SetUpRtpSender(bool pacer) { |
133 rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr, | 135 rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr, |
134 &mock_paced_sender_, nullptr, nullptr, | 136 pacer ? &mock_paced_sender_ : nullptr, |
135 nullptr, nullptr, nullptr)); | 137 nullptr, nullptr, nullptr, nullptr, |
| 138 nullptr)); |
136 rtp_sender_->SetSequenceNumber(kSeqNum); | 139 rtp_sender_->SetSequenceNumber(kSeqNum); |
137 } | 140 } |
138 | 141 |
139 SimulatedClock fake_clock_; | 142 SimulatedClock fake_clock_; |
140 MockRtpPacketSender mock_paced_sender_; | 143 MockRtpPacketSender mock_paced_sender_; |
141 rtc::scoped_ptr<RTPSender> rtp_sender_; | 144 rtc::scoped_ptr<RTPSender> rtp_sender_; |
142 int payload_; | 145 int payload_; |
143 LoopbackTransportTest transport_; | 146 LoopbackTransportTest transport_; |
144 const bool kMarkerBit; | 147 const bool kMarkerBit; |
145 uint8_t packet_[kMaxPacketLength]; | 148 uint8_t packet_[kMaxPacketLength]; |
(...skipping 21 matching lines...) Expand all Loading... |
167 capture_time_ms); | 170 capture_time_ms); |
168 ASSERT_GE(rtp_length, 0); | 171 ASSERT_GE(rtp_length, 0); |
169 | 172 |
170 // Packet should be stored in a send bucket. | 173 // Packet should be stored in a send bucket. |
171 EXPECT_EQ(0, rtp_sender_->SendToNetwork( | 174 EXPECT_EQ(0, rtp_sender_->SendToNetwork( |
172 packet_, payload_length, rtp_length, capture_time_ms, | 175 packet_, payload_length, rtp_length, capture_time_ms, |
173 kAllowRetransmission, RtpPacketSender::kNormalPriority)); | 176 kAllowRetransmission, RtpPacketSender::kNormalPriority)); |
174 } | 177 } |
175 }; | 178 }; |
176 | 179 |
| 180 // TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our |
| 181 // default code path. |
| 182 class RtpSenderTestWithoutPacer : public RtpSenderTest { |
| 183 public: |
| 184 void SetUp() override { SetUpRtpSender(false); } |
| 185 }; |
| 186 |
177 class RtpSenderVideoTest : public RtpSenderTest { | 187 class RtpSenderVideoTest : public RtpSenderTest { |
178 protected: | 188 protected: |
179 virtual void SetUp() override { | 189 virtual void SetUp() override { |
180 RtpSenderTest::SetUp(); | 190 // TODO(pbos): Set up to use pacer. |
| 191 SetUpRtpSender(false); |
181 rtp_sender_video_.reset( | 192 rtp_sender_video_.reset( |
182 new RTPSenderVideo(&fake_clock_, rtp_sender_.get())); | 193 new RTPSenderVideo(&fake_clock_, rtp_sender_.get())); |
183 } | 194 } |
184 rtc::scoped_ptr<RTPSenderVideo> rtp_sender_video_; | 195 rtc::scoped_ptr<RTPSenderVideo> rtp_sender_video_; |
185 | 196 |
186 void VerifyCVOPacket(uint8_t* data, | 197 void VerifyCVOPacket(uint8_t* data, |
187 size_t len, | 198 size_t len, |
188 bool expect_cvo, | 199 bool expect_cvo, |
189 RtpHeaderExtensionMap* map, | 200 RtpHeaderExtensionMap* map, |
190 uint16_t seq_num, | 201 uint16_t seq_num, |
(...skipping 15 matching lines...) Expand all Loading... |
206 EXPECT_EQ(seq_num, rtp_header.sequenceNumber); | 217 EXPECT_EQ(seq_num, rtp_header.sequenceNumber); |
207 EXPECT_EQ(kTimestamp, rtp_header.timestamp); | 218 EXPECT_EQ(kTimestamp, rtp_header.timestamp); |
208 EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc); | 219 EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc); |
209 EXPECT_EQ(0, rtp_header.numCSRCs); | 220 EXPECT_EQ(0, rtp_header.numCSRCs); |
210 EXPECT_EQ(0U, rtp_header.paddingLength); | 221 EXPECT_EQ(0U, rtp_header.paddingLength); |
211 EXPECT_EQ(ConvertVideoRotationToCVOByte(rotation), | 222 EXPECT_EQ(ConvertVideoRotationToCVOByte(rotation), |
212 rtp_header.extension.videoRotation); | 223 rtp_header.extension.videoRotation); |
213 } | 224 } |
214 }; | 225 }; |
215 | 226 |
216 TEST_F(RtpSenderTest, RegisterRtpTransmissionTimeOffsetHeaderExtension) { | 227 TEST_F(RtpSenderTestWithoutPacer, |
| 228 RegisterRtpTransmissionTimeOffsetHeaderExtension) { |
217 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 229 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
218 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 230 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
219 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); | 231 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); |
220 EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength, | 232 EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength, |
221 rtp_sender_->RtpHeaderExtensionTotalLength()); | 233 rtp_sender_->RtpHeaderExtensionTotalLength()); |
222 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension( | 234 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension( |
223 kRtpExtensionTransmissionTimeOffset)); | 235 kRtpExtensionTransmissionTimeOffset)); |
224 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 236 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
225 } | 237 } |
226 | 238 |
227 TEST_F(RtpSenderTest, RegisterRtpAbsoluteSendTimeHeaderExtension) { | 239 TEST_F(RtpSenderTestWithoutPacer, RegisterRtpAbsoluteSendTimeHeaderExtension) { |
228 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 240 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
229 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 241 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
230 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); | 242 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); |
231 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength + | 243 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength + |
232 kAbsoluteSendTimeLength), | 244 kAbsoluteSendTimeLength), |
233 rtp_sender_->RtpHeaderExtensionTotalLength()); | 245 rtp_sender_->RtpHeaderExtensionTotalLength()); |
234 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension( | 246 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension( |
235 kRtpExtensionAbsoluteSendTime)); | 247 kRtpExtensionAbsoluteSendTime)); |
236 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 248 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
237 } | 249 } |
238 | 250 |
239 TEST_F(RtpSenderTest, RegisterRtpAudioLevelHeaderExtension) { | 251 TEST_F(RtpSenderTestWithoutPacer, RegisterRtpAudioLevelHeaderExtension) { |
240 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 252 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
241 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 253 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
242 kRtpExtensionAudioLevel, kAudioLevelExtensionId)); | 254 kRtpExtensionAudioLevel, kAudioLevelExtensionId)); |
243 EXPECT_EQ( | 255 EXPECT_EQ( |
244 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kAudioLevelLength), | 256 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kAudioLevelLength), |
245 rtp_sender_->RtpHeaderExtensionTotalLength()); | 257 rtp_sender_->RtpHeaderExtensionTotalLength()); |
246 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension( | 258 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension( |
247 kRtpExtensionAudioLevel)); | 259 kRtpExtensionAudioLevel)); |
248 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 260 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
249 } | 261 } |
250 | 262 |
251 TEST_F(RtpSenderTest, RegisterRtpHeaderExtensions) { | 263 TEST_F(RtpSenderTestWithoutPacer, RegisterRtpHeaderExtensions) { |
252 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 264 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
253 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 265 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
254 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); | 266 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); |
255 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength + | 267 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength + |
256 kTransmissionTimeOffsetLength), | 268 kTransmissionTimeOffsetLength), |
257 rtp_sender_->RtpHeaderExtensionTotalLength()); | 269 rtp_sender_->RtpHeaderExtensionTotalLength()); |
258 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 270 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
259 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); | 271 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); |
260 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength + | 272 EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength + |
261 kTransmissionTimeOffsetLength + | 273 kTransmissionTimeOffsetLength + |
(...skipping 29 matching lines...) Expand all Loading... |
291 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension( | 303 EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension( |
292 kRtpExtensionAudioLevel)); | 304 kRtpExtensionAudioLevel)); |
293 EXPECT_EQ( | 305 EXPECT_EQ( |
294 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength), | 306 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength), |
295 rtp_sender_->RtpHeaderExtensionTotalLength()); | 307 rtp_sender_->RtpHeaderExtensionTotalLength()); |
296 EXPECT_EQ( | 308 EXPECT_EQ( |
297 0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation)); | 309 0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation)); |
298 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 310 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
299 } | 311 } |
300 | 312 |
301 TEST_F(RtpSenderTest, RegisterRtpVideoRotationHeaderExtension) { | 313 TEST_F(RtpSenderTestWithoutPacer, RegisterRtpVideoRotationHeaderExtension) { |
302 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 314 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
303 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 315 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
304 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); | 316 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); |
305 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 317 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
306 | 318 |
307 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); | 319 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); |
308 EXPECT_EQ( | 320 EXPECT_EQ( |
309 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength), | 321 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength), |
310 rtp_sender_->RtpHeaderExtensionTotalLength()); | 322 rtp_sender_->RtpHeaderExtensionTotalLength()); |
311 EXPECT_EQ( | 323 EXPECT_EQ( |
312 0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation)); | 324 0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation)); |
313 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); | 325 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength()); |
314 } | 326 } |
315 | 327 |
316 TEST_F(RtpSenderTest, BuildRTPPacket) { | 328 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) { |
317 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 329 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( |
318 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 330 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
319 ASSERT_EQ(kRtpHeaderSize, length); | 331 ASSERT_EQ(kRtpHeaderSize, length); |
320 | 332 |
321 // Verify | 333 // Verify |
322 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 334 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
323 webrtc::RTPHeader rtp_header; | 335 webrtc::RTPHeader rtp_header; |
324 | 336 |
325 const bool valid_rtp_header = rtp_parser.Parse(rtp_header, nullptr); | 337 const bool valid_rtp_header = rtp_parser.Parse(rtp_header, nullptr); |
326 | 338 |
327 ASSERT_TRUE(valid_rtp_header); | 339 ASSERT_TRUE(valid_rtp_header); |
328 ASSERT_FALSE(rtp_parser.RTCP()); | 340 ASSERT_FALSE(rtp_parser.RTCP()); |
329 VerifyRTPHeaderCommon(rtp_header); | 341 VerifyRTPHeaderCommon(rtp_header); |
330 EXPECT_EQ(length, rtp_header.headerLength); | 342 EXPECT_EQ(length, rtp_header.headerLength); |
331 EXPECT_FALSE(rtp_header.extension.hasTransmissionTimeOffset); | 343 EXPECT_FALSE(rtp_header.extension.hasTransmissionTimeOffset); |
332 EXPECT_FALSE(rtp_header.extension.hasAbsoluteSendTime); | 344 EXPECT_FALSE(rtp_header.extension.hasAbsoluteSendTime); |
333 EXPECT_FALSE(rtp_header.extension.hasAudioLevel); | 345 EXPECT_FALSE(rtp_header.extension.hasAudioLevel); |
334 EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset); | 346 EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset); |
335 EXPECT_EQ(0u, rtp_header.extension.absoluteSendTime); | 347 EXPECT_EQ(0u, rtp_header.extension.absoluteSendTime); |
336 EXPECT_FALSE(rtp_header.extension.voiceActivity); | 348 EXPECT_FALSE(rtp_header.extension.voiceActivity); |
337 EXPECT_EQ(0u, rtp_header.extension.audioLevel); | 349 EXPECT_EQ(0u, rtp_header.extension.audioLevel); |
338 EXPECT_EQ(0u, rtp_header.extension.videoRotation); | 350 EXPECT_EQ(0u, rtp_header.extension.videoRotation); |
339 } | 351 } |
340 | 352 |
341 TEST_F(RtpSenderTest, BuildRTPPacketWithTransmissionOffsetExtension) { | 353 TEST_F(RtpSenderTestWithoutPacer, |
| 354 BuildRTPPacketWithTransmissionOffsetExtension) { |
342 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset)); | 355 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset)); |
343 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 356 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
344 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); | 357 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); |
345 | 358 |
346 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 359 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( |
347 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 360 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
348 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(), | 361 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(), |
349 length); | 362 length); |
350 | 363 |
351 // Verify | 364 // Verify |
(...skipping 16 matching lines...) Expand all Loading... |
368 webrtc::RTPHeader rtp_header2; | 381 webrtc::RTPHeader rtp_header2; |
369 const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, nullptr); | 382 const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, nullptr); |
370 | 383 |
371 ASSERT_TRUE(valid_rtp_header2); | 384 ASSERT_TRUE(valid_rtp_header2); |
372 VerifyRTPHeaderCommon(rtp_header2); | 385 VerifyRTPHeaderCommon(rtp_header2); |
373 EXPECT_EQ(length, rtp_header2.headerLength); | 386 EXPECT_EQ(length, rtp_header2.headerLength); |
374 EXPECT_FALSE(rtp_header2.extension.hasTransmissionTimeOffset); | 387 EXPECT_FALSE(rtp_header2.extension.hasTransmissionTimeOffset); |
375 EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset); | 388 EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset); |
376 } | 389 } |
377 | 390 |
378 TEST_F(RtpSenderTest, BuildRTPPacketWithNegativeTransmissionOffsetExtension) { | 391 TEST_F(RtpSenderTestWithoutPacer, |
| 392 BuildRTPPacketWithNegativeTransmissionOffsetExtension) { |
379 const int kNegTimeOffset = -500; | 393 const int kNegTimeOffset = -500; |
380 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset)); | 394 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset)); |
381 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 395 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
382 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); | 396 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); |
383 | 397 |
384 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 398 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( |
385 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 399 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
386 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(), | 400 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(), |
387 length); | 401 length); |
388 | 402 |
389 // Verify | 403 // Verify |
390 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 404 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
391 webrtc::RTPHeader rtp_header; | 405 webrtc::RTPHeader rtp_header; |
392 | 406 |
393 RtpHeaderExtensionMap map; | 407 RtpHeaderExtensionMap map; |
394 map.Register(kRtpExtensionTransmissionTimeOffset, | 408 map.Register(kRtpExtensionTransmissionTimeOffset, |
395 kTransmissionTimeOffsetExtensionId); | 409 kTransmissionTimeOffsetExtensionId); |
396 const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map); | 410 const bool valid_rtp_header = rtp_parser.Parse(rtp_header, &map); |
397 | 411 |
398 ASSERT_TRUE(valid_rtp_header); | 412 ASSERT_TRUE(valid_rtp_header); |
399 ASSERT_FALSE(rtp_parser.RTCP()); | 413 ASSERT_FALSE(rtp_parser.RTCP()); |
400 VerifyRTPHeaderCommon(rtp_header); | 414 VerifyRTPHeaderCommon(rtp_header); |
401 EXPECT_EQ(length, rtp_header.headerLength); | 415 EXPECT_EQ(length, rtp_header.headerLength); |
402 EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset); | 416 EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset); |
403 EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset); | 417 EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset); |
404 } | 418 } |
405 | 419 |
406 TEST_F(RtpSenderTest, BuildRTPPacketWithAbsoluteSendTimeExtension) { | 420 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) { |
407 EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime)); | 421 EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime)); |
408 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 422 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
409 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); | 423 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); |
410 | 424 |
411 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 425 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( |
412 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 426 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
413 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(), | 427 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(), |
414 length); | 428 length); |
415 | 429 |
416 // Verify | 430 // Verify |
(...skipping 16 matching lines...) Expand all Loading... |
433 const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, nullptr); | 447 const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, nullptr); |
434 | 448 |
435 ASSERT_TRUE(valid_rtp_header2); | 449 ASSERT_TRUE(valid_rtp_header2); |
436 VerifyRTPHeaderCommon(rtp_header2); | 450 VerifyRTPHeaderCommon(rtp_header2); |
437 EXPECT_EQ(length, rtp_header2.headerLength); | 451 EXPECT_EQ(length, rtp_header2.headerLength); |
438 EXPECT_FALSE(rtp_header2.extension.hasAbsoluteSendTime); | 452 EXPECT_FALSE(rtp_header2.extension.hasAbsoluteSendTime); |
439 EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime); | 453 EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime); |
440 } | 454 } |
441 | 455 |
442 // Test CVO header extension is only set when marker bit is true. | 456 // Test CVO header extension is only set when marker bit is true. |
443 TEST_F(RtpSenderTest, BuildRTPPacketWithVideoRotation_MarkerBit) { | 457 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) { |
444 rtp_sender_->SetVideoRotation(kRotation); | 458 rtp_sender_->SetVideoRotation(kRotation); |
445 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 459 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
446 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); | 460 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); |
447 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); | 461 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); |
448 | 462 |
449 RtpHeaderExtensionMap map; | 463 RtpHeaderExtensionMap map; |
450 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId); | 464 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId); |
451 | 465 |
452 size_t length = static_cast<size_t>( | 466 size_t length = static_cast<size_t>( |
453 rtp_sender_->BuildRTPheader(packet_, kPayload, true, kTimestamp, 0)); | 467 rtp_sender_->BuildRTPheader(packet_, kPayload, true, kTimestamp, 0)); |
454 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(), | 468 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(), |
455 length); | 469 length); |
456 | 470 |
457 // Verify | 471 // Verify |
458 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 472 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
459 webrtc::RTPHeader rtp_header; | 473 webrtc::RTPHeader rtp_header; |
460 | 474 |
461 ASSERT_TRUE(rtp_parser.Parse(rtp_header, &map)); | 475 ASSERT_TRUE(rtp_parser.Parse(rtp_header, &map)); |
462 ASSERT_FALSE(rtp_parser.RTCP()); | 476 ASSERT_FALSE(rtp_parser.RTCP()); |
463 VerifyRTPHeaderCommon(rtp_header); | 477 VerifyRTPHeaderCommon(rtp_header); |
464 EXPECT_EQ(length, rtp_header.headerLength); | 478 EXPECT_EQ(length, rtp_header.headerLength); |
465 EXPECT_TRUE(rtp_header.extension.hasVideoRotation); | 479 EXPECT_TRUE(rtp_header.extension.hasVideoRotation); |
466 EXPECT_EQ(ConvertVideoRotationToCVOByte(kRotation), | 480 EXPECT_EQ(ConvertVideoRotationToCVOByte(kRotation), |
467 rtp_header.extension.videoRotation); | 481 rtp_header.extension.videoRotation); |
468 } | 482 } |
469 | 483 |
470 // Test CVO header extension is not set when marker bit is false. | 484 // Test CVO header extension is not set when marker bit is false. |
471 TEST_F(RtpSenderTest, DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) { | 485 TEST_F(RtpSenderTestWithoutPacer, |
| 486 DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) { |
472 rtp_sender_->SetVideoRotation(kRotation); | 487 rtp_sender_->SetVideoRotation(kRotation); |
473 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 488 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
474 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); | 489 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); |
475 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); | 490 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); |
476 | 491 |
477 RtpHeaderExtensionMap map; | 492 RtpHeaderExtensionMap map; |
478 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId); | 493 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId); |
479 | 494 |
480 size_t length = static_cast<size_t>( | 495 size_t length = static_cast<size_t>( |
481 rtp_sender_->BuildRTPheader(packet_, kPayload, false, kTimestamp, 0)); | 496 rtp_sender_->BuildRTPheader(packet_, kPayload, false, kTimestamp, 0)); |
482 ASSERT_EQ(kRtpHeaderSize, length); | 497 ASSERT_EQ(kRtpHeaderSize, length); |
483 | 498 |
484 // Verify | 499 // Verify |
485 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 500 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
486 webrtc::RTPHeader rtp_header; | 501 webrtc::RTPHeader rtp_header; |
487 | 502 |
488 ASSERT_TRUE(rtp_parser.Parse(rtp_header, &map)); | 503 ASSERT_TRUE(rtp_parser.Parse(rtp_header, &map)); |
489 ASSERT_FALSE(rtp_parser.RTCP()); | 504 ASSERT_FALSE(rtp_parser.RTCP()); |
490 VerifyRTPHeaderCommon(rtp_header, false); | 505 VerifyRTPHeaderCommon(rtp_header, false); |
491 EXPECT_EQ(length, rtp_header.headerLength); | 506 EXPECT_EQ(length, rtp_header.headerLength); |
492 EXPECT_FALSE(rtp_header.extension.hasVideoRotation); | 507 EXPECT_FALSE(rtp_header.extension.hasVideoRotation); |
493 } | 508 } |
494 | 509 |
495 TEST_F(RtpSenderTest, BuildRTPPacketWithAudioLevelExtension) { | 510 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) { |
496 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 511 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
497 kRtpExtensionAudioLevel, kAudioLevelExtensionId)); | 512 kRtpExtensionAudioLevel, kAudioLevelExtensionId)); |
498 | 513 |
499 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( | 514 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( |
500 packet_, kPayload, kMarkerBit, kTimestamp, 0)); | 515 packet_, kPayload, kMarkerBit, kTimestamp, 0)); |
501 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(), | 516 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionTotalLength(), |
502 length); | 517 length); |
503 | 518 |
504 // Verify | 519 // Verify |
505 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); | 520 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); |
(...skipping 20 matching lines...) Expand all Loading... |
526 const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, nullptr); | 541 const bool valid_rtp_header2 = rtp_parser.Parse(rtp_header2, nullptr); |
527 | 542 |
528 ASSERT_TRUE(valid_rtp_header2); | 543 ASSERT_TRUE(valid_rtp_header2); |
529 VerifyRTPHeaderCommon(rtp_header2); | 544 VerifyRTPHeaderCommon(rtp_header2); |
530 EXPECT_EQ(length, rtp_header2.headerLength); | 545 EXPECT_EQ(length, rtp_header2.headerLength); |
531 EXPECT_FALSE(rtp_header2.extension.hasAudioLevel); | 546 EXPECT_FALSE(rtp_header2.extension.hasAudioLevel); |
532 EXPECT_FALSE(rtp_header2.extension.voiceActivity); | 547 EXPECT_FALSE(rtp_header2.extension.voiceActivity); |
533 EXPECT_EQ(0u, rtp_header2.extension.audioLevel); | 548 EXPECT_EQ(0u, rtp_header2.extension.audioLevel); |
534 } | 549 } |
535 | 550 |
536 TEST_F(RtpSenderTest, BuildRTPPacketWithHeaderExtensions) { | 551 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) { |
537 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset)); | 552 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset)); |
538 EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime)); | 553 EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime)); |
539 EXPECT_EQ(0, | 554 EXPECT_EQ(0, |
540 rtp_sender_->SetTransportSequenceNumber(kTransportSequenceNumber)); | 555 rtp_sender_->SetTransportSequenceNumber(kTransportSequenceNumber)); |
541 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 556 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
542 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); | 557 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); |
543 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 558 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
544 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); | 559 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); |
545 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 560 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
546 kRtpExtensionAudioLevel, kAudioLevelExtensionId)); | 561 kRtpExtensionAudioLevel, kAudioLevelExtensionId)); |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
598 EXPECT_FALSE(rtp_header2.extension.hasTransportSequenceNumber); | 613 EXPECT_FALSE(rtp_header2.extension.hasTransportSequenceNumber); |
599 | 614 |
600 EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset); | 615 EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset); |
601 EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime); | 616 EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime); |
602 EXPECT_FALSE(rtp_header2.extension.voiceActivity); | 617 EXPECT_FALSE(rtp_header2.extension.voiceActivity); |
603 EXPECT_EQ(0u, rtp_header2.extension.audioLevel); | 618 EXPECT_EQ(0u, rtp_header2.extension.audioLevel); |
604 EXPECT_EQ(0u, rtp_header2.extension.transportSequenceNumber); | 619 EXPECT_EQ(0u, rtp_header2.extension.transportSequenceNumber); |
605 } | 620 } |
606 | 621 |
607 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) { | 622 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) { |
608 EXPECT_CALL(mock_paced_sender_, | 623 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, |
609 SendPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _)) | 624 _, kSeqNum, _, _, _)) |
610 .WillOnce(testing::Return(false)); | 625 .WillRepeatedly(testing::Return()); |
611 | 626 |
612 rtp_sender_->SetStorePacketsStatus(true, 10); | 627 rtp_sender_->SetStorePacketsStatus(true, 10); |
613 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 628 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
614 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); | 629 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); |
615 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 630 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
616 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); | 631 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); |
617 rtp_sender_->SetTargetBitrate(300000); | 632 rtp_sender_->SetTargetBitrate(300000); |
618 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); | 633 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); |
619 int rtp_length_int = rtp_sender_->BuildRTPheader( | 634 int rtp_length_int = rtp_sender_->BuildRTPheader( |
620 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms); | 635 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms); |
(...skipping 27 matching lines...) Expand all Loading... |
648 ASSERT_TRUE(valid_rtp_header); | 663 ASSERT_TRUE(valid_rtp_header); |
649 | 664 |
650 // Verify transmission time offset. | 665 // Verify transmission time offset. |
651 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); | 666 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); |
652 uint64_t expected_send_time = | 667 uint64_t expected_send_time = |
653 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); | 668 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); |
654 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); | 669 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); |
655 } | 670 } |
656 | 671 |
657 TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) { | 672 TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) { |
658 EXPECT_CALL(mock_paced_sender_, | 673 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, |
659 SendPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _)) | 674 _, kSeqNum, _, _, _)) |
660 .WillOnce(testing::Return(false)); | 675 .WillRepeatedly(testing::Return()); |
661 | 676 |
662 rtp_sender_->SetStorePacketsStatus(true, 10); | 677 rtp_sender_->SetStorePacketsStatus(true, 10); |
663 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 678 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
664 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); | 679 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); |
665 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 680 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
666 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); | 681 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); |
667 rtp_sender_->SetTargetBitrate(300000); | 682 rtp_sender_->SetTargetBitrate(300000); |
668 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); | 683 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); |
669 int rtp_length_int = rtp_sender_->BuildRTPheader( | 684 int rtp_length_int = rtp_sender_->BuildRTPheader( |
670 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms); | 685 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms); |
671 ASSERT_NE(-1, rtp_length_int); | 686 ASSERT_NE(-1, rtp_length_int); |
672 size_t rtp_length = static_cast<size_t>(rtp_length_int); | 687 size_t rtp_length = static_cast<size_t>(rtp_length_int); |
673 | 688 |
674 // Packet should be stored in a send bucket. | 689 // Packet should be stored in a send bucket. |
675 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, | 690 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, |
676 capture_time_ms, kAllowRetransmission, | 691 capture_time_ms, kAllowRetransmission, |
677 RtpPacketSender::kNormalPriority)); | 692 RtpPacketSender::kNormalPriority)); |
678 | 693 |
679 EXPECT_EQ(0, transport_.packets_sent_); | 694 EXPECT_EQ(0, transport_.packets_sent_); |
680 | 695 |
681 EXPECT_CALL(mock_paced_sender_, | 696 EXPECT_CALL(mock_paced_sender_, |
682 SendPacket(RtpPacketSender::kHighPriority, _, kSeqNum, _, _, _)) | 697 InsertPacket(RtpPacketSender::kHighPriority, _, kSeqNum, _, _, _)) |
683 .WillOnce(testing::Return(false)); | 698 .WillRepeatedly(testing::Return()); |
684 | 699 |
685 const int kStoredTimeInMs = 100; | 700 const int kStoredTimeInMs = 100; |
686 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); | 701 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); |
687 | 702 |
688 EXPECT_EQ(rtp_length_int, rtp_sender_->ReSendPacket(kSeqNum)); | 703 EXPECT_EQ(rtp_length_int, rtp_sender_->ReSendPacket(kSeqNum)); |
689 EXPECT_EQ(0, transport_.packets_sent_); | 704 EXPECT_EQ(0, transport_.packets_sent_); |
690 | 705 |
691 rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false); | 706 rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false); |
692 | 707 |
693 // Process send bucket. Packet should now be sent. | 708 // Process send bucket. Packet should now be sent. |
(...skipping 16 matching lines...) Expand all Loading... |
710 uint64_t expected_send_time = | 725 uint64_t expected_send_time = |
711 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); | 726 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); |
712 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); | 727 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); |
713 } | 728 } |
714 | 729 |
715 // This test sends 1 regular video packet, then 4 padding packets, and then | 730 // This test sends 1 regular video packet, then 4 padding packets, and then |
716 // 1 more regular packet. | 731 // 1 more regular packet. |
717 TEST_F(RtpSenderTest, SendPadding) { | 732 TEST_F(RtpSenderTest, SendPadding) { |
718 // Make all (non-padding) packets go to send queue. | 733 // Make all (non-padding) packets go to send queue. |
719 EXPECT_CALL(mock_paced_sender_, | 734 EXPECT_CALL(mock_paced_sender_, |
720 SendPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)) | 735 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)) |
721 .WillRepeatedly(testing::Return(false)); | 736 .WillRepeatedly(testing::Return()); |
722 | 737 |
723 uint16_t seq_num = kSeqNum; | 738 uint16_t seq_num = kSeqNum; |
724 uint32_t timestamp = kTimestamp; | 739 uint32_t timestamp = kTimestamp; |
725 rtp_sender_->SetStorePacketsStatus(true, 10); | 740 rtp_sender_->SetStorePacketsStatus(true, 10); |
726 size_t rtp_header_len = kRtpHeaderSize; | 741 size_t rtp_header_len = kRtpHeaderSize; |
727 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 742 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
728 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); | 743 kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId)); |
729 rtp_header_len += 4; // 4 bytes extension. | 744 rtp_header_len += 4; // 4 bytes extension. |
730 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 745 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
731 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); | 746 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
830 | 845 |
831 TEST_F(RtpSenderTest, SendRedundantPayloads) { | 846 TEST_F(RtpSenderTest, SendRedundantPayloads) { |
832 MockTransport transport; | 847 MockTransport transport; |
833 rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport, nullptr, | 848 rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport, nullptr, |
834 &mock_paced_sender_, nullptr, nullptr, | 849 &mock_paced_sender_, nullptr, nullptr, |
835 nullptr, nullptr, nullptr)); | 850 nullptr, nullptr, nullptr)); |
836 rtp_sender_->SetSequenceNumber(kSeqNum); | 851 rtp_sender_->SetSequenceNumber(kSeqNum); |
837 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload); | 852 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload); |
838 // Make all packets go through the pacer. | 853 // Make all packets go through the pacer. |
839 EXPECT_CALL(mock_paced_sender_, | 854 EXPECT_CALL(mock_paced_sender_, |
840 SendPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)) | 855 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)) |
841 .WillRepeatedly(testing::Return(false)); | 856 .WillRepeatedly(testing::Return()); |
842 | 857 |
843 uint16_t seq_num = kSeqNum; | 858 uint16_t seq_num = kSeqNum; |
844 rtp_sender_->SetStorePacketsStatus(true, 10); | 859 rtp_sender_->SetStorePacketsStatus(true, 10); |
845 int32_t rtp_header_len = kRtpHeaderSize; | 860 int32_t rtp_header_len = kRtpHeaderSize; |
846 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 861 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
847 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); | 862 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId)); |
848 rtp_header_len += 4; // 4 bytes extension. | 863 rtp_header_len += 4; // 4 bytes extension. |
849 rtp_header_len += 4; // 4 extra bytes common to all extension headers. | 864 rtp_header_len += 4; // 4 extra bytes common to all extension headers. |
850 | 865 |
851 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); | 866 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
884 EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[kNumPayloadSizes - 1] + | 899 EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[kNumPayloadSizes - 1] + |
885 rtp_header_len + kRtxHeaderSize, | 900 rtp_header_len + kRtxHeaderSize, |
886 _)) | 901 _)) |
887 .WillOnce(testing::Return(true)); | 902 .WillOnce(testing::Return(true)); |
888 EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _)) | 903 EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _)) |
889 .WillOnce(testing::Return(true)); | 904 .WillOnce(testing::Return(true)); |
890 EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize, | 905 EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize, |
891 rtp_sender_->TimeToSendPadding(999)); | 906 rtp_sender_->TimeToSendPadding(999)); |
892 } | 907 } |
893 | 908 |
894 TEST_F(RtpSenderTest, SendGenericVideo) { | 909 TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) { |
895 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; | 910 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; |
896 const uint8_t payload_type = 127; | 911 const uint8_t payload_type = 127; |
897 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, | 912 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, |
898 0, 1500)); | 913 0, 1500)); |
899 uint8_t payload[] = {47, 11, 32, 93, 89}; | 914 uint8_t payload[] = {47, 11, 32, 93, 89}; |
900 | 915 |
901 // Send keyframe | 916 // Send keyframe |
902 ASSERT_EQ( | 917 ASSERT_EQ( |
903 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321, | 918 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321, |
904 payload, sizeof(payload), nullptr)); | 919 payload, sizeof(payload), nullptr)); |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1010 total_stats_ = total_stats; | 1025 total_stats_ = total_stats; |
1011 retransmit_stats_ = retransmit_stats; | 1026 retransmit_stats_ = retransmit_stats; |
1012 } | 1027 } |
1013 | 1028 |
1014 uint32_t num_calls_; | 1029 uint32_t num_calls_; |
1015 uint32_t ssrc_; | 1030 uint32_t ssrc_; |
1016 BitrateStatistics total_stats_; | 1031 BitrateStatistics total_stats_; |
1017 BitrateStatistics retransmit_stats_; | 1032 BitrateStatistics retransmit_stats_; |
1018 } callback; | 1033 } callback; |
1019 rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr, | 1034 rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr, |
1020 &mock_paced_sender_, nullptr, nullptr, | 1035 nullptr, nullptr, nullptr, &callback, nullptr, |
1021 &callback, nullptr, nullptr)); | 1036 nullptr)); |
1022 | 1037 |
1023 // Simulate kNumPackets sent with kPacketInterval ms intervals. | 1038 // Simulate kNumPackets sent with kPacketInterval ms intervals. |
1024 const uint32_t kNumPackets = 15; | 1039 const uint32_t kNumPackets = 15; |
1025 const uint32_t kPacketInterval = 20; | 1040 const uint32_t kPacketInterval = 20; |
1026 // Overhead = 12 bytes RTP header + 1 byte generic header. | 1041 // Overhead = 12 bytes RTP header + 1 byte generic header. |
1027 const uint32_t kPacketOverhead = 13; | 1042 const uint32_t kPacketOverhead = 13; |
1028 | 1043 |
1029 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; | 1044 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; |
1030 const uint8_t payload_type = 127; | 1045 const uint8_t payload_type = 127; |
1031 ASSERT_EQ( | 1046 ASSERT_EQ( |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1069 rtp_sender_.reset(); | 1084 rtp_sender_.reset(); |
1070 } | 1085 } |
1071 | 1086 |
1072 class RtpSenderAudioTest : public RtpSenderTest { | 1087 class RtpSenderAudioTest : public RtpSenderTest { |
1073 protected: | 1088 protected: |
1074 RtpSenderAudioTest() {} | 1089 RtpSenderAudioTest() {} |
1075 | 1090 |
1076 void SetUp() override { | 1091 void SetUp() override { |
1077 payload_ = kAudioPayload; | 1092 payload_ = kAudioPayload; |
1078 rtp_sender_.reset(new RTPSender(true, &fake_clock_, &transport_, nullptr, | 1093 rtp_sender_.reset(new RTPSender(true, &fake_clock_, &transport_, nullptr, |
1079 &mock_paced_sender_, nullptr, nullptr, | 1094 nullptr, nullptr, nullptr, nullptr, nullptr, |
1080 nullptr, nullptr, nullptr)); | 1095 nullptr)); |
1081 rtp_sender_->SetSequenceNumber(kSeqNum); | 1096 rtp_sender_->SetSequenceNumber(kSeqNum); |
1082 } | 1097 } |
1083 }; | 1098 }; |
1084 | 1099 |
1085 TEST_F(RtpSenderTest, StreamDataCountersCallbacks) { | 1100 TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) { |
1086 class TestCallback : public StreamDataCountersCallback { | 1101 class TestCallback : public StreamDataCountersCallback { |
1087 public: | 1102 public: |
1088 TestCallback() | 1103 TestCallback() |
1089 : StreamDataCountersCallback(), ssrc_(0), counters_() {} | 1104 : StreamDataCountersCallback(), ssrc_(0), counters_() {} |
1090 virtual ~TestCallback() {} | 1105 virtual ~TestCallback() {} |
1091 | 1106 |
1092 void DataCountersUpdated(const StreamDataCounters& counters, | 1107 void DataCountersUpdated(const StreamDataCounters& counters, |
1093 uint32_t ssrc) override { | 1108 uint32_t ssrc) override { |
1094 ssrc_ = ssrc; | 1109 ssrc_ = ssrc; |
1095 counters_ = counters; | 1110 counters_ = counters; |
(...skipping 195 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1291 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kFrameEmpty, payload_type, | 1306 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kFrameEmpty, payload_type, |
1292 capture_time_ms + 4000, 0, nullptr, | 1307 capture_time_ms + 4000, 0, nullptr, |
1293 0, nullptr)); | 1308 0, nullptr)); |
1294 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, | 1309 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, |
1295 transport_.last_sent_packet_len_, | 1310 transport_.last_sent_packet_len_, |
1296 &rtp_header)); | 1311 &rtp_header)); |
1297 // Marker Bit should be set to 0 for rest of the packets. | 1312 // Marker Bit should be set to 0 for rest of the packets. |
1298 EXPECT_FALSE(rtp_header.markerBit); | 1313 EXPECT_FALSE(rtp_header.markerBit); |
1299 } | 1314 } |
1300 | 1315 |
1301 TEST_F(RtpSenderTest, BytesReportedCorrectly) { | 1316 TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) { |
1302 const char* kPayloadName = "GENERIC"; | 1317 const char* kPayloadName = "GENERIC"; |
1303 const uint8_t kPayloadType = 127; | 1318 const uint8_t kPayloadType = 127; |
1304 rtp_sender_->SetSSRC(1234); | 1319 rtp_sender_->SetSSRC(1234); |
1305 rtp_sender_->SetRtxSsrc(4321); | 1320 rtp_sender_->SetRtxSsrc(4321); |
1306 rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType); | 1321 rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType); |
1307 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); | 1322 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); |
1308 | 1323 |
1309 ASSERT_EQ( | 1324 ASSERT_EQ( |
1310 0, | 1325 0, |
1311 rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000, 0, 1500)); | 1326 rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000, 0, 1500)); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1344 EXPECT_EQ(rtx_stats.transmitted.TotalBytes(), | 1359 EXPECT_EQ(rtx_stats.transmitted.TotalBytes(), |
1345 rtx_stats.transmitted.payload_bytes + | 1360 rtx_stats.transmitted.payload_bytes + |
1346 rtx_stats.transmitted.header_bytes + | 1361 rtx_stats.transmitted.header_bytes + |
1347 rtx_stats.transmitted.padding_bytes); | 1362 rtx_stats.transmitted.padding_bytes); |
1348 | 1363 |
1349 EXPECT_EQ(transport_.total_bytes_sent_, | 1364 EXPECT_EQ(transport_.total_bytes_sent_, |
1350 rtp_stats.transmitted.TotalBytes() + | 1365 rtp_stats.transmitted.TotalBytes() + |
1351 rtx_stats.transmitted.TotalBytes()); | 1366 rtx_stats.transmitted.TotalBytes()); |
1352 } | 1367 } |
1353 | 1368 |
1354 TEST_F(RtpSenderTest, RespectsNackBitrateLimit) { | 1369 TEST_F(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) { |
1355 const int32_t kPacketSize = 1400; | 1370 const int32_t kPacketSize = 1400; |
1356 const int32_t kNumPackets = 30; | 1371 const int32_t kNumPackets = 30; |
1357 | 1372 |
1358 rtp_sender_->SetStorePacketsStatus(true, kNumPackets); | 1373 rtp_sender_->SetStorePacketsStatus(true, kNumPackets); |
1359 // Set bitrate (in kbps) to fit kNumPackets á kPacketSize bytes in one second. | 1374 // Set bitrate (in kbps) to fit kNumPackets á kPacketSize bytes in one second. |
1360 rtp_sender_->SetTargetBitrate(kNumPackets * kPacketSize * 8); | 1375 rtp_sender_->SetTargetBitrate(kNumPackets * kPacketSize * 8); |
1361 const uint16_t kStartSequenceNumber = rtp_sender_->SequenceNumber(); | 1376 const uint16_t kStartSequenceNumber = rtp_sender_->SequenceNumber(); |
1362 std::list<uint16_t> sequence_numbers; | 1377 std::list<uint16_t> sequence_numbers; |
1363 for (int32_t i = 0; i < kNumPackets; ++i) { | 1378 for (int32_t i = 0; i < kNumPackets; ++i) { |
1364 sequence_numbers.push_back(kStartSequenceNumber + i); | 1379 sequence_numbers.push_back(kStartSequenceNumber + i); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1405 reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()), | 1420 reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()), |
1406 transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation); | 1421 transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation); |
1407 | 1422 |
1408 // Verify that this packet does have CVO byte. | 1423 // Verify that this packet does have CVO byte. |
1409 VerifyCVOPacket( | 1424 VerifyCVOPacket( |
1410 reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()), | 1425 reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()), |
1411 transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1, | 1426 transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1, |
1412 hdr.rotation); | 1427 hdr.rotation); |
1413 } | 1428 } |
1414 } // namespace webrtc | 1429 } // namespace webrtc |
OLD | NEW |