Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(18)

Side by Side Diff: webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

Issue 2067673004: Style cleanups in RtpSender. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: fix compilation Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 164 matching lines...) Expand 10 before | Expand all | Expand 10 after
175 EXPECT_EQ(payload_, rtp_header.payloadType); 175 EXPECT_EQ(payload_, rtp_header.payloadType);
176 EXPECT_EQ(kSeqNum, rtp_header.sequenceNumber); 176 EXPECT_EQ(kSeqNum, rtp_header.sequenceNumber);
177 EXPECT_EQ(kTimestamp, rtp_header.timestamp); 177 EXPECT_EQ(kTimestamp, rtp_header.timestamp);
178 EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc); 178 EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc);
179 EXPECT_EQ(number_of_csrcs, rtp_header.numCSRCs); 179 EXPECT_EQ(number_of_csrcs, rtp_header.numCSRCs);
180 EXPECT_EQ(0U, rtp_header.paddingLength); 180 EXPECT_EQ(0U, rtp_header.paddingLength);
181 } 181 }
182 182
183 void SendPacket(int64_t capture_time_ms, int payload_length) { 183 void SendPacket(int64_t capture_time_ms, int payload_length) {
184 uint32_t timestamp = capture_time_ms * 90; 184 uint32_t timestamp = capture_time_ms * 90;
185 int32_t rtp_length = rtp_sender_->BuildRTPheader( 185 int32_t rtp_length = rtp_sender_->BuildRtpHeader(
186 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms); 186 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);
187 ASSERT_GE(rtp_length, 0); 187 ASSERT_GE(rtp_length, 0);
188 188
189 // Packet should be stored in a send bucket. 189 // Packet should be stored in a send bucket.
190 EXPECT_EQ(0, rtp_sender_->SendToNetwork( 190 EXPECT_EQ(0, rtp_sender_->SendToNetwork(
191 packet_, payload_length, rtp_length, capture_time_ms, 191 packet_, payload_length, rtp_length, capture_time_ms,
192 kAllowRetransmission, RtpPacketSender::kNormalPriority)); 192 kAllowRetransmission, RtpPacketSender::kNormalPriority));
193 } 193 }
194 194
195 void SendGenericPayload() { 195 void SendGenericPayload() {
196 const uint8_t kPayload[] = {47, 11, 32, 93, 89}; 196 const uint8_t kPayload[] = {47, 11, 32, 93, 89};
197 const uint32_t kTimestamp = 1234; 197 const uint32_t kTimestamp = 1234;
198 const uint8_t kPayloadType = 127; 198 const uint8_t kPayloadType = 127;
199 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds(); 199 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds();
200 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; 200 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
201 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000, 201 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000,
202 0, 1500)); 202 0, 1500));
203 203
204 EXPECT_EQ(0, rtp_sender_->SendOutgoingData( 204 EXPECT_EQ(0, rtp_sender_->SendOutgoingData(
205 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, 205 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs,
206 kPayload, sizeof(kPayload), nullptr)); 206 kPayload, sizeof(kPayload), nullptr, nullptr));
207 } 207 }
208 }; 208 };
209 209
210 // TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our 210 // TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our
211 // default code path. 211 // default code path.
212 class RtpSenderTestWithoutPacer : public RtpSenderTest { 212 class RtpSenderTestWithoutPacer : public RtpSenderTest {
213 public: 213 public:
214 void SetUp() override { SetUpRtpSender(false); } 214 void SetUp() override { SetUpRtpSender(false); }
215 }; 215 };
216 216
217 class RtpSenderVideoTest : public RtpSenderTest { 217 class RtpSenderVideoTest : public RtpSenderTest {
218 protected: 218 protected:
219 void SetUp() override { 219 void SetUp() override {
220 // TODO(pbos): Set up to use pacer. 220 // TODO(pbos): Set up to use pacer.
221 SetUpRtpSender(false); 221 SetUpRtpSender(false);
222 rtp_sender_video_.reset( 222 rtp_sender_video_.reset(
223 new RTPSenderVideo(&fake_clock_, rtp_sender_.get())); 223 new RTPSenderVideo(&fake_clock_, rtp_sender_.get()));
224 } 224 }
225 std::unique_ptr<RTPSenderVideo> rtp_sender_video_; 225 std::unique_ptr<RTPSenderVideo> rtp_sender_video_;
226 226
227 void VerifyCVOPacket(uint8_t* data, 227 void VerifyCVOPacket(uint8_t* data,
228 size_t len, 228 size_t len,
229 bool expect_cvo, 229 bool expect_cvo,
230 RtpHeaderExtensionMap* map, 230 RtpHeaderExtensionMap* map,
231 uint16_t seq_num, 231 uint16_t seq_num,
232 VideoRotation rotation) { 232 VideoRotation rotation) {
233 webrtc::RtpUtility::RtpHeaderParser rtp_parser(data, len); 233 webrtc::RtpUtility::RtpHeaderParser rtp_parser(data, len);
234 234
235 webrtc::RTPHeader rtp_header; 235 webrtc::RTPHeader rtp_header;
236 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( 236 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
237 packet_, kPayload, expect_cvo /* marker_bit */, kTimestamp, 0)); 237 packet_, kPayload, expect_cvo /* marker_bit */, kTimestamp, 0));
238 if (expect_cvo) { 238 if (expect_cvo) {
239 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), 239 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(),
240 length); 240 length);
241 } else { 241 } else {
242 ASSERT_EQ(kRtpHeaderSize, length); 242 ASSERT_EQ(kRtpHeaderSize, length);
243 } 243 }
244 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, map)); 244 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, map));
245 ASSERT_FALSE(rtp_parser.RTCP()); 245 ASSERT_FALSE(rtp_parser.RTCP());
246 EXPECT_EQ(payload_, rtp_header.payloadType); 246 EXPECT_EQ(payload_, rtp_header.payloadType);
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after
353 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); 353 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
354 EXPECT_EQ( 354 EXPECT_EQ(
355 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength), 355 RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength),
356 rtp_sender_->RtpHeaderExtensionLength()); 356 rtp_sender_->RtpHeaderExtensionLength());
357 EXPECT_EQ( 357 EXPECT_EQ(
358 0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation)); 358 0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation));
359 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength()); 359 EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength());
360 } 360 }
361 361
362 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) { 362 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {
363 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( 363 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
364 packet_, kPayload, kMarkerBit, kTimestamp, 0)); 364 packet_, kPayload, kMarkerBit, kTimestamp, 0));
365 ASSERT_EQ(kRtpHeaderSize, length); 365 ASSERT_EQ(kRtpHeaderSize, length);
366 366
367 // Verify 367 // Verify
368 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); 368 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
369 webrtc::RTPHeader rtp_header; 369 webrtc::RTPHeader rtp_header;
370 370
371 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, nullptr); 371 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, nullptr);
372 372
373 ASSERT_TRUE(valid_rtp_header); 373 ASSERT_TRUE(valid_rtp_header);
(...skipping 10 matching lines...) Expand all
384 EXPECT_EQ(0u, rtp_header.extension.videoRotation); 384 EXPECT_EQ(0u, rtp_header.extension.videoRotation);
385 } 385 }
386 386
387 TEST_F(RtpSenderTestWithoutPacer, 387 TEST_F(RtpSenderTestWithoutPacer,
388 BuildRTPPacketWithTransmissionOffsetExtension) { 388 BuildRTPPacketWithTransmissionOffsetExtension) {
389 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset)); 389 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
390 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 390 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
391 kRtpExtensionTransmissionTimeOffset, 391 kRtpExtensionTransmissionTimeOffset,
392 kTransmissionTimeOffsetExtensionId)); 392 kTransmissionTimeOffsetExtensionId));
393 393
394 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( 394 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
395 packet_, kPayload, kMarkerBit, kTimestamp, 0)); 395 packet_, kPayload, kMarkerBit, kTimestamp, 0));
396 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); 396 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
397 397
398 // Verify 398 // Verify
399 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); 399 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
400 webrtc::RTPHeader rtp_header; 400 webrtc::RTPHeader rtp_header;
401 401
402 RtpHeaderExtensionMap map; 402 RtpHeaderExtensionMap map;
403 map.Register(kRtpExtensionTransmissionTimeOffset, 403 map.Register(kRtpExtensionTransmissionTimeOffset,
404 kTransmissionTimeOffsetExtensionId); 404 kTransmissionTimeOffsetExtensionId);
(...skipping 18 matching lines...) Expand all
423 } 423 }
424 424
425 TEST_F(RtpSenderTestWithoutPacer, 425 TEST_F(RtpSenderTestWithoutPacer,
426 BuildRTPPacketWithNegativeTransmissionOffsetExtension) { 426 BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
427 const int kNegTimeOffset = -500; 427 const int kNegTimeOffset = -500;
428 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset)); 428 EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset));
429 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 429 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
430 kRtpExtensionTransmissionTimeOffset, 430 kRtpExtensionTransmissionTimeOffset,
431 kTransmissionTimeOffsetExtensionId)); 431 kTransmissionTimeOffsetExtensionId));
432 432
433 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( 433 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
434 packet_, kPayload, kMarkerBit, kTimestamp, 0)); 434 packet_, kPayload, kMarkerBit, kTimestamp, 0));
435 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); 435 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
436 436
437 // Verify 437 // Verify
438 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); 438 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
439 webrtc::RTPHeader rtp_header; 439 webrtc::RTPHeader rtp_header;
440 440
441 RtpHeaderExtensionMap map; 441 RtpHeaderExtensionMap map;
442 map.Register(kRtpExtensionTransmissionTimeOffset, 442 map.Register(kRtpExtensionTransmissionTimeOffset,
443 kTransmissionTimeOffsetExtensionId); 443 kTransmissionTimeOffsetExtensionId);
444 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map); 444 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
445 445
446 ASSERT_TRUE(valid_rtp_header); 446 ASSERT_TRUE(valid_rtp_header);
447 ASSERT_FALSE(rtp_parser.RTCP()); 447 ASSERT_FALSE(rtp_parser.RTCP());
448 VerifyRTPHeaderCommon(rtp_header); 448 VerifyRTPHeaderCommon(rtp_header);
449 EXPECT_EQ(length, rtp_header.headerLength); 449 EXPECT_EQ(length, rtp_header.headerLength);
450 EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset); 450 EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset);
451 EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset); 451 EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset);
452 } 452 }
453 453
454 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) { 454 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) {
455 EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime)); 455 EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
456 EXPECT_EQ( 456 EXPECT_EQ(
457 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, 457 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
458 kAbsoluteSendTimeExtensionId)); 458 kAbsoluteSendTimeExtensionId));
459 459
460 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( 460 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
461 packet_, kPayload, kMarkerBit, kTimestamp, 0)); 461 packet_, kPayload, kMarkerBit, kTimestamp, 0));
462 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); 462 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
463 463
464 // Verify 464 // Verify
465 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); 465 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
466 webrtc::RTPHeader rtp_header; 466 webrtc::RTPHeader rtp_header;
467 467
468 RtpHeaderExtensionMap map; 468 RtpHeaderExtensionMap map;
469 map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId); 469 map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
470 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map); 470 const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after
535 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) { 535 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) {
536 rtp_sender_->SetVideoRotation(kRotation); 536 rtp_sender_->SetVideoRotation(kRotation);
537 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 537 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
538 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); 538 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
539 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); 539 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
540 540
541 RtpHeaderExtensionMap map; 541 RtpHeaderExtensionMap map;
542 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId); 542 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
543 543
544 size_t length = static_cast<size_t>( 544 size_t length = static_cast<size_t>(
545 rtp_sender_->BuildRTPheader(packet_, kPayload, true, kTimestamp, 0)); 545 rtp_sender_->BuildRtpHeader(packet_, kPayload, true, kTimestamp, 0));
546 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); 546 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
547 547
548 // Verify 548 // Verify
549 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); 549 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
550 webrtc::RTPHeader rtp_header; 550 webrtc::RTPHeader rtp_header;
551 551
552 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map)); 552 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map));
553 ASSERT_FALSE(rtp_parser.RTCP()); 553 ASSERT_FALSE(rtp_parser.RTCP());
554 VerifyRTPHeaderCommon(rtp_header); 554 VerifyRTPHeaderCommon(rtp_header);
555 EXPECT_EQ(length, rtp_header.headerLength); 555 EXPECT_EQ(length, rtp_header.headerLength);
556 EXPECT_TRUE(rtp_header.extension.hasVideoRotation); 556 EXPECT_TRUE(rtp_header.extension.hasVideoRotation);
557 EXPECT_EQ(ConvertVideoRotationToCVOByte(kRotation), 557 EXPECT_EQ(ConvertVideoRotationToCVOByte(kRotation),
558 rtp_header.extension.videoRotation); 558 rtp_header.extension.videoRotation);
559 } 559 }
560 560
561 // Test CVO header extension is not set when marker bit is false. 561 // Test CVO header extension is not set when marker bit is false.
562 TEST_F(RtpSenderTestWithoutPacer, 562 TEST_F(RtpSenderTestWithoutPacer,
563 DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) { 563 DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) {
564 rtp_sender_->SetVideoRotation(kRotation); 564 rtp_sender_->SetVideoRotation(kRotation);
565 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 565 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
566 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); 566 kRtpExtensionVideoRotation, kVideoRotationExtensionId));
567 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension()); 567 EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
568 568
569 RtpHeaderExtensionMap map; 569 RtpHeaderExtensionMap map;
570 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId); 570 map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
571 571
572 size_t length = static_cast<size_t>( 572 size_t length = static_cast<size_t>(
573 rtp_sender_->BuildRTPheader(packet_, kPayload, false, kTimestamp, 0)); 573 rtp_sender_->BuildRtpHeader(packet_, kPayload, false, kTimestamp, 0));
574 ASSERT_EQ(kRtpHeaderSize, length); 574 ASSERT_EQ(kRtpHeaderSize, length);
575 575
576 // Verify 576 // Verify
577 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); 577 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
578 webrtc::RTPHeader rtp_header; 578 webrtc::RTPHeader rtp_header;
579 579
580 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map)); 580 ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map));
581 ASSERT_FALSE(rtp_parser.RTCP()); 581 ASSERT_FALSE(rtp_parser.RTCP());
582 VerifyRTPHeaderCommon(rtp_header, false); 582 VerifyRTPHeaderCommon(rtp_header, false);
583 EXPECT_EQ(length, rtp_header.headerLength); 583 EXPECT_EQ(length, rtp_header.headerLength);
584 EXPECT_FALSE(rtp_header.extension.hasVideoRotation); 584 EXPECT_FALSE(rtp_header.extension.hasVideoRotation);
585 } 585 }
586 586
587 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) { 587 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) {
588 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, 588 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
589 kAudioLevelExtensionId)); 589 kAudioLevelExtensionId));
590 590
591 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( 591 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
592 packet_, kPayload, kMarkerBit, kTimestamp, 0)); 592 packet_, kPayload, kMarkerBit, kTimestamp, 0));
593 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); 593 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
594 594
595 // Verify 595 // Verify
596 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); 596 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
597 webrtc::RTPHeader rtp_header; 597 webrtc::RTPHeader rtp_header;
598 598
599 // Updating audio level is done in RTPSenderAudio, so simulate it here. 599 // Updating audio level is done in RTPSenderAudio, so simulate it here.
600 rtp_parser.Parse(&rtp_header); 600 rtp_parser.Parse(&rtp_header);
601 rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel); 601 rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel);
(...skipping 22 matching lines...) Expand all
624 EXPECT_EQ(0u, rtp_header2.extension.audioLevel); 624 EXPECT_EQ(0u, rtp_header2.extension.audioLevel);
625 } 625 }
626 626
627 TEST_F(RtpSenderTestWithoutPacer, 627 TEST_F(RtpSenderTestWithoutPacer,
628 BuildRTPPacketWithCSRCAndAudioLevelExtension) { 628 BuildRTPPacketWithCSRCAndAudioLevelExtension) {
629 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, 629 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
630 kAudioLevelExtensionId)); 630 kAudioLevelExtensionId));
631 std::vector<uint32_t> csrcs; 631 std::vector<uint32_t> csrcs;
632 csrcs.push_back(0x23456789); 632 csrcs.push_back(0x23456789);
633 rtp_sender_->SetCsrcs(csrcs); 633 rtp_sender_->SetCsrcs(csrcs);
634 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( 634 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
635 packet_, kPayload, kMarkerBit, kTimestamp, 0)); 635 packet_, kPayload, kMarkerBit, kTimestamp, 0));
636 636
637 // Verify 637 // Verify
638 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); 638 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
639 webrtc::RTPHeader rtp_header; 639 webrtc::RTPHeader rtp_header;
640 640
641 // Updating audio level is done in RTPSenderAudio, so simulate it here. 641 // Updating audio level is done in RTPSenderAudio, so simulate it here.
642 rtp_parser.Parse(&rtp_header); 642 rtp_parser.Parse(&rtp_header);
643 EXPECT_TRUE(rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, 643 EXPECT_TRUE(rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true,
644 kAudioLevel)); 644 kAudioLevel));
(...skipping 23 matching lines...) Expand all
668 kTransmissionTimeOffsetExtensionId)); 668 kTransmissionTimeOffsetExtensionId));
669 EXPECT_EQ( 669 EXPECT_EQ(
670 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, 670 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
671 kAbsoluteSendTimeExtensionId)); 671 kAbsoluteSendTimeExtensionId));
672 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, 672 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
673 kAudioLevelExtensionId)); 673 kAudioLevelExtensionId));
674 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 674 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
675 kRtpExtensionTransportSequenceNumber, 675 kRtpExtensionTransportSequenceNumber,
676 kTransportSequenceNumberExtensionId)); 676 kTransportSequenceNumberExtensionId));
677 677
678 size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader( 678 size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
679 packet_, kPayload, kMarkerBit, kTimestamp, 0)); 679 packet_, kPayload, kMarkerBit, kTimestamp, 0));
680 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length); 680 ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
681 681
682 // Verify 682 // Verify
683 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length); 683 webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
684 webrtc::RTPHeader rtp_header; 684 webrtc::RTPHeader rtp_header;
685 685
686 // Updating audio level is done in RTPSenderAudio, so simulate it here. 686 // Updating audio level is done in RTPSenderAudio, so simulate it here.
687 rtp_parser.Parse(&rtp_header); 687 rtp_parser.Parse(&rtp_header);
688 rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel); 688 rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel);
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
738 738
739 rtp_sender_->SetStorePacketsStatus(true, 10); 739 rtp_sender_->SetStorePacketsStatus(true, 10);
740 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 740 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
741 kRtpExtensionTransmissionTimeOffset, 741 kRtpExtensionTransmissionTimeOffset,
742 kTransmissionTimeOffsetExtensionId)); 742 kTransmissionTimeOffsetExtensionId));
743 EXPECT_EQ( 743 EXPECT_EQ(
744 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, 744 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
745 kAbsoluteSendTimeExtensionId)); 745 kAbsoluteSendTimeExtensionId));
746 rtp_sender_->SetTargetBitrate(300000); 746 rtp_sender_->SetTargetBitrate(300000);
747 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); 747 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
748 int rtp_length_int = rtp_sender_->BuildRTPheader( 748 int rtp_length_int = rtp_sender_->BuildRtpHeader(
749 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms); 749 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms);
750 ASSERT_NE(-1, rtp_length_int); 750 ASSERT_NE(-1, rtp_length_int);
751 size_t rtp_length = static_cast<size_t>(rtp_length_int); 751 size_t rtp_length = static_cast<size_t>(rtp_length_int);
752 752
753 // Packet should be stored in a send bucket. 753 // Packet should be stored in a send bucket.
754 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, 754 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
755 capture_time_ms, kAllowRetransmission, 755 capture_time_ms, kAllowRetransmission,
756 RtpPacketSender::kNormalPriority)); 756 RtpPacketSender::kNormalPriority));
757 757
758 EXPECT_EQ(0, transport_.packets_sent_); 758 EXPECT_EQ(0, transport_.packets_sent_);
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
792 792
793 rtp_sender_->SetStorePacketsStatus(true, 10); 793 rtp_sender_->SetStorePacketsStatus(true, 10);
794 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( 794 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
795 kRtpExtensionTransmissionTimeOffset, 795 kRtpExtensionTransmissionTimeOffset,
796 kTransmissionTimeOffsetExtensionId)); 796 kTransmissionTimeOffsetExtensionId));
797 EXPECT_EQ( 797 EXPECT_EQ(
798 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, 798 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
799 kAbsoluteSendTimeExtensionId)); 799 kAbsoluteSendTimeExtensionId));
800 rtp_sender_->SetTargetBitrate(300000); 800 rtp_sender_->SetTargetBitrate(300000);
801 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); 801 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
802 int rtp_length_int = rtp_sender_->BuildRTPheader( 802 int rtp_length_int = rtp_sender_->BuildRtpHeader(
803 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms); 803 packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms);
804 ASSERT_NE(-1, rtp_length_int); 804 ASSERT_NE(-1, rtp_length_int);
805 size_t rtp_length = static_cast<size_t>(rtp_length_int); 805 size_t rtp_length = static_cast<size_t>(rtp_length_int);
806 806
807 // Packet should be stored in a send bucket. 807 // Packet should be stored in a send bucket.
808 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, 808 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
809 capture_time_ms, kAllowRetransmission, 809 capture_time_ms, kAllowRetransmission,
810 RtpPacketSender::kNormalPriority)); 810 RtpPacketSender::kNormalPriority));
811 811
812 EXPECT_EQ(0, transport_.packets_sent_); 812 EXPECT_EQ(0, transport_.packets_sent_);
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after
874 webrtc::RtpHeaderParser::Create()); 874 webrtc::RtpHeaderParser::Create());
875 ASSERT_TRUE(rtp_parser.get() != nullptr); 875 ASSERT_TRUE(rtp_parser.get() != nullptr);
876 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset, 876 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
877 kTransmissionTimeOffsetExtensionId); 877 kTransmissionTimeOffsetExtensionId);
878 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, 878 rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
879 kAbsoluteSendTimeExtensionId); 879 kAbsoluteSendTimeExtensionId);
880 webrtc::RTPHeader rtp_header; 880 webrtc::RTPHeader rtp_header;
881 881
882 rtp_sender_->SetTargetBitrate(300000); 882 rtp_sender_->SetTargetBitrate(300000);
883 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); 883 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
884 int rtp_length_int = rtp_sender_->BuildRTPheader( 884 int rtp_length_int = rtp_sender_->BuildRtpHeader(
885 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms); 885 packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);
886 const uint32_t media_packet_timestamp = timestamp; 886 const uint32_t media_packet_timestamp = timestamp;
887 ASSERT_NE(-1, rtp_length_int); 887 ASSERT_NE(-1, rtp_length_int);
888 size_t rtp_length = static_cast<size_t>(rtp_length_int); 888 size_t rtp_length = static_cast<size_t>(rtp_length_int);
889 889
890 // Packet should be stored in a send bucket. 890 // Packet should be stored in a send bucket.
891 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, 891 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
892 capture_time_ms, kAllowRetransmission, 892 capture_time_ms, kAllowRetransmission,
893 RtpPacketSender::kNormalPriority)); 893 RtpPacketSender::kNormalPriority));
894 894
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
932 EXPECT_EQ(offset, rtp_header.extension.transmissionTimeOffset); 932 EXPECT_EQ(offset, rtp_header.extension.transmissionTimeOffset);
933 uint64_t expected_send_time = 933 uint64_t expected_send_time =
934 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); 934 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
935 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); 935 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
936 fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs); 936 fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs);
937 timestamp += 90 * kPaddingPeriodMs; 937 timestamp += 90 * kPaddingPeriodMs;
938 } 938 }
939 939
940 // Send a regular video packet again. 940 // Send a regular video packet again.
941 capture_time_ms = fake_clock_.TimeInMilliseconds(); 941 capture_time_ms = fake_clock_.TimeInMilliseconds();
942 rtp_length_int = rtp_sender_->BuildRTPheader(packet_, kPayload, kMarkerBit, 942 rtp_length_int = rtp_sender_->BuildRtpHeader(packet_, kPayload, kMarkerBit,
943 timestamp, capture_time_ms); 943 timestamp, capture_time_ms);
944 ASSERT_NE(-1, rtp_length_int); 944 ASSERT_NE(-1, rtp_length_int);
945 rtp_length = static_cast<size_t>(rtp_length_int); 945 rtp_length = static_cast<size_t>(rtp_length_int);
946 946
947 EXPECT_CALL(mock_paced_sender_, 947 EXPECT_CALL(mock_paced_sender_,
948 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)); 948 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _));
949 949
950 // Packet should be stored in a send bucket. 950 // Packet should be stored in a send bucket.
951 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length, 951 EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
952 capture_time_ms, kAllowRetransmission, 952 capture_time_ms, kAllowRetransmission,
(...skipping 150 matching lines...) Expand 10 before | Expand all | Expand 10 after
1103 } 1103 }
1104 1104
1105 TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) { 1105 TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
1106 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; 1106 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
1107 const uint8_t payload_type = 127; 1107 const uint8_t payload_type = 127;
1108 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, 1108 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
1109 0, 1500)); 1109 0, 1500));
1110 uint8_t payload[] = {47, 11, 32, 93, 89}; 1110 uint8_t payload[] = {47, 11, 32, 93, 89};
1111 1111
1112 // Send keyframe 1112 // Send keyframe
1113 ASSERT_EQ( 1113 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234,
1114 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321, 1114 4321, payload, sizeof(payload),
1115 payload, sizeof(payload), nullptr)); 1115 nullptr, nullptr));
1116 1116
1117 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, 1117 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
1118 transport_.last_sent_packet_len_); 1118 transport_.last_sent_packet_len_);
1119 webrtc::RTPHeader rtp_header; 1119 webrtc::RTPHeader rtp_header;
1120 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); 1120 ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
1121 1121
1122 const uint8_t* payload_data = 1122 const uint8_t* payload_data =
1123 GetPayloadData(rtp_header, transport_.last_sent_packet_); 1123 GetPayloadData(rtp_header, transport_.last_sent_packet_);
1124 uint8_t generic_header = *payload_data++; 1124 uint8_t generic_header = *payload_data++;
1125 1125
1126 ASSERT_EQ(sizeof(payload) + sizeof(generic_header), 1126 ASSERT_EQ(sizeof(payload) + sizeof(generic_header),
1127 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_)); 1127 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
1128 1128
1129 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); 1129 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
1130 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); 1130 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
1131 1131
1132 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload))); 1132 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
1133 1133
1134 // Send delta frame 1134 // Send delta frame
1135 payload[0] = 13; 1135 payload[0] = 13;
1136 payload[1] = 42; 1136 payload[1] = 42;
1137 payload[4] = 13; 1137 payload[4] = 13;
1138 1138
1139 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type, 1139 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(
1140 1234, 4321, payload, 1140 kVideoFrameDelta, payload_type, 1234, 4321, payload,
1141 sizeof(payload), nullptr)); 1141 sizeof(payload), nullptr, nullptr));
1142 1142
1143 RtpUtility::RtpHeaderParser rtp_parser2(transport_.last_sent_packet_, 1143 RtpUtility::RtpHeaderParser rtp_parser2(transport_.last_sent_packet_,
1144 transport_.last_sent_packet_len_); 1144 transport_.last_sent_packet_len_);
1145 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); 1145 ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
1146 1146
1147 payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_); 1147 payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_);
1148 generic_header = *payload_data++; 1148 generic_header = *payload_data++;
1149 1149
1150 EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); 1150 EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
1151 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); 1151 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
(...skipping 30 matching lines...) Expand all
1182 const uint8_t payload_type = 127; 1182 const uint8_t payload_type = 127;
1183 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, 1183 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
1184 0, 1500)); 1184 0, 1500));
1185 uint8_t payload[] = {47, 11, 32, 93, 89}; 1185 uint8_t payload[] = {47, 11, 32, 93, 89};
1186 rtp_sender_->SetStorePacketsStatus(true, 1); 1186 rtp_sender_->SetStorePacketsStatus(true, 1);
1187 uint32_t ssrc = rtp_sender_->SSRC(); 1187 uint32_t ssrc = rtp_sender_->SSRC();
1188 1188
1189 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)) 1189 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
1190 .Times(::testing::AtLeast(2)); 1190 .Times(::testing::AtLeast(2));
1191 1191
1192 ASSERT_EQ( 1192 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234,
1193 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321, 1193 4321, payload, sizeof(payload),
1194 payload, sizeof(payload), nullptr)); 1194 nullptr, nullptr));
1195 1195
1196 EXPECT_EQ(1U, callback.num_calls_); 1196 EXPECT_EQ(1U, callback.num_calls_);
1197 EXPECT_EQ(ssrc, callback.ssrc_); 1197 EXPECT_EQ(ssrc, callback.ssrc_);
1198 EXPECT_EQ(1, callback.frame_counts_.key_frames); 1198 EXPECT_EQ(1, callback.frame_counts_.key_frames);
1199 EXPECT_EQ(0, callback.frame_counts_.delta_frames); 1199 EXPECT_EQ(0, callback.frame_counts_.delta_frames);
1200 1200
1201 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type, 1201 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(
1202 1234, 4321, payload, 1202 kVideoFrameDelta, payload_type, 1234, 4321, payload,
1203 sizeof(payload), nullptr)); 1203 sizeof(payload), nullptr, nullptr));
1204 1204
1205 EXPECT_EQ(2U, callback.num_calls_); 1205 EXPECT_EQ(2U, callback.num_calls_);
1206 EXPECT_EQ(ssrc, callback.ssrc_); 1206 EXPECT_EQ(ssrc, callback.ssrc_);
1207 EXPECT_EQ(1, callback.frame_counts_.key_frames); 1207 EXPECT_EQ(1, callback.frame_counts_.key_frames);
1208 EXPECT_EQ(1, callback.frame_counts_.delta_frames); 1208 EXPECT_EQ(1, callback.frame_counts_.delta_frames);
1209 1209
1210 rtp_sender_.reset(); 1210 rtp_sender_.reset();
1211 } 1211 }
1212 1212
1213 TEST_F(RtpSenderTest, BitrateCallbacks) { 1213 TEST_F(RtpSenderTest, BitrateCallbacks) {
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
1247 uint8_t payload[] = {47, 11, 32, 93, 89}; 1247 uint8_t payload[] = {47, 11, 32, 93, 89};
1248 rtp_sender_->SetStorePacketsStatus(true, 1); 1248 rtp_sender_->SetStorePacketsStatus(true, 1);
1249 uint32_t ssrc = rtp_sender_->SSRC(); 1249 uint32_t ssrc = rtp_sender_->SSRC();
1250 1250
1251 // Initial process call so we get a new time window. 1251 // Initial process call so we get a new time window.
1252 rtp_sender_->ProcessBitrate(); 1252 rtp_sender_->ProcessBitrate();
1253 uint64_t start_time = fake_clock_.CurrentNtpInMilliseconds(); 1253 uint64_t start_time = fake_clock_.CurrentNtpInMilliseconds();
1254 1254
1255 // Send a few frames. 1255 // Send a few frames.
1256 for (uint32_t i = 0; i < kNumPackets; ++i) { 1256 for (uint32_t i = 0; i < kNumPackets; ++i) {
1257 ASSERT_EQ(0, 1257 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(
1258 rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 1258 kVideoFrameKey, payload_type, 1234, 4321, payload,
1259 4321, payload, sizeof(payload), 0)); 1259 sizeof(payload), nullptr, nullptr));
1260 fake_clock_.AdvanceTimeMilliseconds(kPacketInterval); 1260 fake_clock_.AdvanceTimeMilliseconds(kPacketInterval);
1261 } 1261 }
1262 1262
1263 rtp_sender_->ProcessBitrate(); 1263 rtp_sender_->ProcessBitrate();
1264 1264
1265 const uint32_t expected_packet_rate = 1000 / kPacketInterval; 1265 const uint32_t expected_packet_rate = 1000 / kPacketInterval;
1266 1266
1267 // We get one call for every stats updated, thus two calls since both the 1267 // We get one call for every stats updated, thus two calls since both the
1268 // stream stats and the retransmit stats are updated once. 1268 // stream stats and the retransmit stats are updated once.
1269 EXPECT_EQ(2u, callback.num_calls_); 1269 EXPECT_EQ(2u, callback.num_calls_);
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
1327 const uint8_t payload_type = 127; 1327 const uint8_t payload_type = 127;
1328 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, 1328 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
1329 0, 1500)); 1329 0, 1500));
1330 uint8_t payload[] = {47, 11, 32, 93, 89}; 1330 uint8_t payload[] = {47, 11, 32, 93, 89};
1331 rtp_sender_->SetStorePacketsStatus(true, 1); 1331 rtp_sender_->SetStorePacketsStatus(true, 1);
1332 uint32_t ssrc = rtp_sender_->SSRC(); 1332 uint32_t ssrc = rtp_sender_->SSRC();
1333 1333
1334 rtp_sender_->RegisterRtpStatisticsCallback(&callback); 1334 rtp_sender_->RegisterRtpStatisticsCallback(&callback);
1335 1335
1336 // Send a frame. 1336 // Send a frame.
1337 ASSERT_EQ( 1337 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234,
1338 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, 4321, 1338 4321, payload, sizeof(payload),
1339 payload, sizeof(payload), nullptr)); 1339 nullptr, nullptr));
1340 StreamDataCounters expected; 1340 StreamDataCounters expected;
1341 expected.transmitted.payload_bytes = 6; 1341 expected.transmitted.payload_bytes = 6;
1342 expected.transmitted.header_bytes = 12; 1342 expected.transmitted.header_bytes = 12;
1343 expected.transmitted.padding_bytes = 0; 1343 expected.transmitted.padding_bytes = 0;
1344 expected.transmitted.packets = 1; 1344 expected.transmitted.packets = 1;
1345 expected.retransmitted.payload_bytes = 0; 1345 expected.retransmitted.payload_bytes = 0;
1346 expected.retransmitted.header_bytes = 0; 1346 expected.retransmitted.header_bytes = 0;
1347 expected.retransmitted.padding_bytes = 0; 1347 expected.retransmitted.padding_bytes = 0;
1348 expected.retransmitted.packets = 0; 1348 expected.retransmitted.packets = 0;
1349 expected.fec.packets = 0; 1349 expected.fec.packets = 0;
(...skipping 19 matching lines...) Expand all
1369 expected.transmitted.packets = 3; 1369 expected.transmitted.packets = 3;
1370 callback.Matches(ssrc, expected); 1370 callback.Matches(ssrc, expected);
1371 1371
1372 // Send FEC. 1372 // Send FEC.
1373 rtp_sender_->SetGenericFECStatus(true, kRedPayloadType, kUlpfecPayloadType); 1373 rtp_sender_->SetGenericFECStatus(true, kRedPayloadType, kUlpfecPayloadType);
1374 FecProtectionParams fec_params; 1374 FecProtectionParams fec_params;
1375 fec_params.fec_mask_type = kFecMaskRandom; 1375 fec_params.fec_mask_type = kFecMaskRandom;
1376 fec_params.fec_rate = 1; 1376 fec_params.fec_rate = 1;
1377 fec_params.max_fec_frames = 1; 1377 fec_params.max_fec_frames = 1;
1378 rtp_sender_->SetFecParameters(&fec_params, &fec_params); 1378 rtp_sender_->SetFecParameters(&fec_params, &fec_params);
1379 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameDelta, payload_type, 1379 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(
1380 1234, 4321, payload, 1380 kVideoFrameDelta, payload_type, 1234, 4321, payload,
1381 sizeof(payload), nullptr)); 1381 sizeof(payload), nullptr, nullptr));
1382 expected.transmitted.payload_bytes = 40; 1382 expected.transmitted.payload_bytes = 40;
1383 expected.transmitted.header_bytes = 60; 1383 expected.transmitted.header_bytes = 60;
1384 expected.transmitted.packets = 5; 1384 expected.transmitted.packets = 5;
1385 expected.fec.packets = 1; 1385 expected.fec.packets = 1;
1386 callback.Matches(ssrc, expected); 1386 callback.Matches(ssrc, expected);
1387 1387
1388 rtp_sender_->RegisterRtpStatisticsCallback(nullptr); 1388 rtp_sender_->RegisterRtpStatisticsCallback(nullptr);
1389 } 1389 }
1390 1390
1391 TEST_F(RtpSenderAudioTest, SendAudio) { 1391 TEST_F(RtpSenderAudioTest, SendAudio) {
1392 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; 1392 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
1393 const uint8_t payload_type = 127; 1393 const uint8_t payload_type = 127;
1394 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, 1394 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
1395 0, 1500)); 1395 0, 1500));
1396 uint8_t payload[] = {47, 11, 32, 93, 89}; 1396 uint8_t payload[] = {47, 11, 32, 93, 89};
1397 1397
1398 ASSERT_EQ( 1398 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234,
1399 0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234, 4321, 1399 4321, payload, sizeof(payload),
1400 payload, sizeof(payload), nullptr)); 1400 nullptr, nullptr));
1401 1401
1402 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, 1402 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
1403 transport_.last_sent_packet_len_); 1403 transport_.last_sent_packet_len_);
1404 webrtc::RTPHeader rtp_header; 1404 webrtc::RTPHeader rtp_header;
1405 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); 1405 ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
1406 1406
1407 const uint8_t* payload_data = 1407 const uint8_t* payload_data =
1408 GetPayloadData(rtp_header, transport_.last_sent_packet_); 1408 GetPayloadData(rtp_header, transport_.last_sent_packet_);
1409 1409
1410 ASSERT_EQ(sizeof(payload), 1410 ASSERT_EQ(sizeof(payload),
1411 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_)); 1411 GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
1412 1412
1413 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload))); 1413 EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
1414 } 1414 }
1415 1415
1416 TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) { 1416 TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
1417 EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel)); 1417 EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel));
1418 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, 1418 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
1419 kAudioLevelExtensionId)); 1419 kAudioLevelExtensionId));
1420 1420
1421 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; 1421 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
1422 const uint8_t payload_type = 127; 1422 const uint8_t payload_type = 127;
1423 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, 1423 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
1424 0, 1500)); 1424 0, 1500));
1425 uint8_t payload[] = {47, 11, 32, 93, 89}; 1425 uint8_t payload[] = {47, 11, 32, 93, 89};
1426 1426
1427 ASSERT_EQ( 1427 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234,
1428 0, rtp_sender_->SendOutgoingData(kAudioFrameCN, payload_type, 1234, 4321, 1428 4321, payload, sizeof(payload),
1429 payload, sizeof(payload), nullptr)); 1429 nullptr, nullptr));
1430 1430
1431 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_, 1431 RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
1432 transport_.last_sent_packet_len_); 1432 transport_.last_sent_packet_len_);
1433 webrtc::RTPHeader rtp_header; 1433 webrtc::RTPHeader rtp_header;
1434 ASSERT_TRUE(rtp_parser.Parse(&rtp_header)); 1434 ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
1435 1435
1436 const uint8_t* payload_data = 1436 const uint8_t* payload_data =
1437 GetPayloadData(rtp_header, transport_.last_sent_packet_); 1437 GetPayloadData(rtp_header, transport_.last_sent_packet_);
1438 1438
1439 ASSERT_EQ(sizeof(payload), 1439 ASSERT_EQ(sizeof(payload),
(...skipping 30 matching lines...) Expand all
1470 ASSERT_EQ( 1470 ASSERT_EQ(
1471 0, rtp_sender_->RegisterPayload(kPayloadName, payload_type, 8000, 1, 0)); 1471 0, rtp_sender_->RegisterPayload(kPayloadName, payload_type, 8000, 1, 0));
1472 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); 1472 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
1473 // DTMF event key=9, duration=500 and attenuationdB=10 1473 // DTMF event key=9, duration=500 and attenuationdB=10
1474 rtp_sender_->SendTelephoneEvent(9, 500, 10); 1474 rtp_sender_->SendTelephoneEvent(9, 500, 10);
1475 // During start, it takes the starting timestamp as last sent timestamp. 1475 // During start, it takes the starting timestamp as last sent timestamp.
1476 // The duration is calculated as the difference of current and last sent 1476 // The duration is calculated as the difference of current and last sent
1477 // timestamp. So for first call it will skip since the duration is zero. 1477 // timestamp. So for first call it will skip since the duration is zero.
1478 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type, 1478 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type,
1479 capture_time_ms, 0, nullptr, 0, 1479 capture_time_ms, 0, nullptr, 0,
1480 nullptr)); 1480 nullptr, nullptr));
1481 // DTMF Sample Length is (Frequency/1000) * Duration. 1481 // DTMF Sample Length is (Frequency/1000) * Duration.
1482 // So in this case, it is (8000/1000) * 500 = 4000. 1482 // So in this case, it is (8000/1000) * 500 = 4000.
1483 // Sending it as two packets. 1483 // Sending it as two packets.
1484 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type, 1484 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type,
1485 capture_time_ms + 2000, 0, nullptr, 1485 capture_time_ms + 2000, 0, nullptr,
1486 0, nullptr)); 1486 0, nullptr, nullptr));
1487 std::unique_ptr<webrtc::RtpHeaderParser> rtp_parser( 1487 std::unique_ptr<webrtc::RtpHeaderParser> rtp_parser(
1488 webrtc::RtpHeaderParser::Create()); 1488 webrtc::RtpHeaderParser::Create());
1489 ASSERT_TRUE(rtp_parser.get() != nullptr); 1489 ASSERT_TRUE(rtp_parser.get() != nullptr);
1490 webrtc::RTPHeader rtp_header; 1490 webrtc::RTPHeader rtp_header;
1491 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, 1491 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_,
1492 transport_.last_sent_packet_len_, &rtp_header)); 1492 transport_.last_sent_packet_len_, &rtp_header));
1493 // Marker Bit should be set to 1 for first packet. 1493 // Marker Bit should be set to 1 for first packet.
1494 EXPECT_TRUE(rtp_header.markerBit); 1494 EXPECT_TRUE(rtp_header.markerBit);
1495 1495
1496 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type, 1496 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type,
1497 capture_time_ms + 4000, 0, nullptr, 1497 capture_time_ms + 4000, 0, nullptr,
1498 0, nullptr)); 1498 0, nullptr, nullptr));
1499 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, 1499 ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_,
1500 transport_.last_sent_packet_len_, &rtp_header)); 1500 transport_.last_sent_packet_len_, &rtp_header));
1501 // Marker Bit should be set to 0 for rest of the packets. 1501 // Marker Bit should be set to 0 for rest of the packets.
1502 EXPECT_FALSE(rtp_header.markerBit); 1502 EXPECT_FALSE(rtp_header.markerBit);
1503 } 1503 }
1504 1504
1505 TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) { 1505 TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
1506 const char* kPayloadName = "GENERIC"; 1506 const char* kPayloadName = "GENERIC";
1507 const uint8_t kPayloadType = 127; 1507 const uint8_t kPayloadType = 127;
1508 rtp_sender_->SetSSRC(1234); 1508 rtp_sender_->SetSSRC(1234);
1509 rtp_sender_->SetRtxSsrc(4321); 1509 rtp_sender_->SetRtxSsrc(4321);
1510 rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType); 1510 rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType);
1511 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); 1511 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
1512 1512
1513 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000, 1513 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000,
1514 0, 1500)); 1514 0, 1500));
1515 uint8_t payload[] = {47, 11, 32, 93, 89}; 1515 uint8_t payload[] = {47, 11, 32, 93, 89};
1516 1516
1517 ASSERT_EQ( 1517 ASSERT_EQ(0, rtp_sender_->SendOutgoingData(kVideoFrameKey, kPayloadType, 1234,
1518 0, rtp_sender_->SendOutgoingData(kVideoFrameKey, kPayloadType, 1234, 4321, 1518 4321, payload, sizeof(payload),
1519 payload, sizeof(payload), 0)); 1519 nullptr, nullptr));
1520 1520
1521 // Will send 2 full-size padding packets. 1521 // Will send 2 full-size padding packets.
1522 rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe); 1522 rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe);
1523 rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe); 1523 rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe);
1524 1524
1525 StreamDataCounters rtp_stats; 1525 StreamDataCounters rtp_stats;
1526 StreamDataCounters rtx_stats; 1526 StreamDataCounters rtx_stats;
1527 rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats); 1527 rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
1528 1528
1529 // Payload + 1-byte generic header. 1529 // Payload + 1-byte generic header.
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after
1603 reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()), 1603 reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()),
1604 transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation); 1604 transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation);
1605 1605
1606 // Verify that this packet does have CVO byte. 1606 // Verify that this packet does have CVO byte.
1607 VerifyCVOPacket( 1607 VerifyCVOPacket(
1608 reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()), 1608 reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()),
1609 transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1, 1609 transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1,
1610 hdr.rotation); 1610 hdr.rotation);
1611 } 1611 }
1612 } // namespace webrtc 1612 } // namespace webrtc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698