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 24 matching lines...) Expand all Loading... |
35 namespace webrtc { | 35 namespace webrtc { |
36 | 36 |
37 namespace { | 37 namespace { |
38 const int kTransmissionTimeOffsetExtensionId = 1; | 38 const int kTransmissionTimeOffsetExtensionId = 1; |
39 const int kAbsoluteSendTimeExtensionId = 14; | 39 const int kAbsoluteSendTimeExtensionId = 14; |
40 const int kTransportSequenceNumberExtensionId = 13; | 40 const int kTransportSequenceNumberExtensionId = 13; |
41 const int kPayload = 100; | 41 const int kPayload = 100; |
42 const int kRtxPayload = 98; | 42 const int kRtxPayload = 98; |
43 const uint32_t kTimestamp = 10; | 43 const uint32_t kTimestamp = 10; |
44 const uint16_t kSeqNum = 33; | 44 const uint16_t kSeqNum = 33; |
| 45 const uint32_t kSsrc = 725242; |
45 const int kMaxPacketLength = 1500; | 46 const int kMaxPacketLength = 1500; |
46 const uint8_t kAudioLevel = 0x5a; | 47 const uint8_t kAudioLevel = 0x5a; |
47 const uint16_t kTransportSequenceNumber = 0xaabbu; | 48 const uint16_t kTransportSequenceNumber = 0xaabbu; |
48 const uint8_t kAudioLevelExtensionId = 9; | 49 const uint8_t kAudioLevelExtensionId = 9; |
49 const int kAudioPayload = 103; | 50 const int kAudioPayload = 103; |
50 const uint64_t kStartTime = 123456789; | 51 const uint64_t kStartTime = 123456789; |
51 const size_t kMaxPaddingSize = 224u; | 52 const size_t kMaxPaddingSize = 224u; |
52 const int kVideoRotationExtensionId = 5; | 53 const int kVideoRotationExtensionId = 5; |
53 const size_t kGenericHeaderLength = 1; | 54 const size_t kGenericHeaderLength = 1; |
54 const uint8_t kPayloadData[] = {47, 11, 32, 93, 89}; | 55 const uint8_t kPayloadData[] = {47, 11, 32, 93, 89}; |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
143 kMarkerBit(true) {} | 144 kMarkerBit(true) {} |
144 | 145 |
145 void SetUp() override { SetUpRtpSender(true); } | 146 void SetUp() override { SetUpRtpSender(true); } |
146 | 147 |
147 void SetUpRtpSender(bool pacer) { | 148 void SetUpRtpSender(bool pacer) { |
148 rtp_sender_.reset(new RTPSender( | 149 rtp_sender_.reset(new RTPSender( |
149 false, &fake_clock_, &transport_, pacer ? &mock_paced_sender_ : nullptr, | 150 false, &fake_clock_, &transport_, pacer ? &mock_paced_sender_ : nullptr, |
150 nullptr, &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr, | 151 nullptr, &seq_num_allocator_, nullptr, nullptr, nullptr, nullptr, |
151 &mock_rtc_event_log_, &send_packet_observer_, | 152 &mock_rtc_event_log_, &send_packet_observer_, |
152 &retransmission_rate_limiter_)); | 153 &retransmission_rate_limiter_)); |
| 154 rtp_sender_->SetSendPayloadType(kPayload); |
153 rtp_sender_->SetSequenceNumber(kSeqNum); | 155 rtp_sender_->SetSequenceNumber(kSeqNum); |
154 rtp_sender_->SetSendPayloadType(kPayload); | |
155 rtp_sender_->SetTimestampOffset(0); | 156 rtp_sender_->SetTimestampOffset(0); |
| 157 rtp_sender_->SetSSRC(kSsrc); |
156 } | 158 } |
157 | 159 |
158 SimulatedClock fake_clock_; | 160 SimulatedClock fake_clock_; |
159 testing::NiceMock<MockRtcEventLog> mock_rtc_event_log_; | 161 testing::NiceMock<MockRtcEventLog> mock_rtc_event_log_; |
160 MockRtpPacketSender mock_paced_sender_; | 162 MockRtpPacketSender mock_paced_sender_; |
161 testing::StrictMock<MockTransportSequenceNumberAllocator> seq_num_allocator_; | 163 testing::StrictMock<MockTransportSequenceNumberAllocator> seq_num_allocator_; |
162 testing::StrictMock<MockSendPacketObserver> send_packet_observer_; | 164 testing::StrictMock<MockSendPacketObserver> send_packet_observer_; |
163 testing::StrictMock<MockTransportFeedbackObserver> feedback_observer_; | 165 testing::StrictMock<MockTransportFeedbackObserver> feedback_observer_; |
164 RateLimiter retransmission_rate_limiter_; | 166 RateLimiter retransmission_rate_limiter_; |
165 std::unique_ptr<RTPSender> rtp_sender_; | 167 std::unique_ptr<RTPSender> rtp_sender_; |
(...skipping 317 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
483 | 485 |
484 SendGenericPayload(); | 486 SendGenericPayload(); |
485 } | 487 } |
486 | 488 |
487 TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) { | 489 TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) { |
488 rtp_sender_.reset( | 490 rtp_sender_.reset( |
489 new RTPSender(false, &fake_clock_, &transport_, &mock_paced_sender_, | 491 new RTPSender(false, &fake_clock_, &transport_, &mock_paced_sender_, |
490 nullptr, &seq_num_allocator_, &feedback_observer_, nullptr, | 492 nullptr, &seq_num_allocator_, &feedback_observer_, nullptr, |
491 nullptr, nullptr, &mock_rtc_event_log_, | 493 nullptr, nullptr, &mock_rtc_event_log_, |
492 &send_packet_observer_, &retransmission_rate_limiter_)); | 494 &send_packet_observer_, &retransmission_rate_limiter_)); |
| 495 rtp_sender_->SetSequenceNumber(kSeqNum); |
| 496 rtp_sender_->SetSSRC(kSsrc); |
493 rtp_sender_->SetStorePacketsStatus(true, 10); | 497 rtp_sender_->SetStorePacketsStatus(true, 10); |
494 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 498 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
495 kRtpExtensionTransportSequenceNumber, | 499 kRtpExtensionTransportSequenceNumber, |
496 kTransportSequenceNumberExtensionId)); | 500 kTransportSequenceNumberExtensionId)); |
497 | 501 |
498 uint16_t seq_num = 0; | 502 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _)); |
499 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)) | |
500 .Times(1).WillRepeatedly(testing::SaveArg<2>(&seq_num)); | |
501 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber()) | 503 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber()) |
502 .WillOnce(testing::Return(kTransportSequenceNumber)); | 504 .WillOnce(testing::Return(kTransportSequenceNumber)); |
503 EXPECT_CALL(send_packet_observer_, | 505 EXPECT_CALL(send_packet_observer_, |
504 OnSendPacket(kTransportSequenceNumber, _, _)) | 506 OnSendPacket(kTransportSequenceNumber, _, _)) |
505 .Times(1); | 507 .Times(1); |
506 const int kProbeClusterId = 1; | 508 const int kProbeClusterId = 1; |
507 EXPECT_CALL( | 509 EXPECT_CALL( |
508 feedback_observer_, | 510 feedback_observer_, |
509 AddPacket(kTransportSequenceNumber, | 511 AddPacket(kTransportSequenceNumber, |
510 sizeof(kPayloadData) + kGenericHeaderLength, kProbeClusterId)) | 512 sizeof(kPayloadData) + kGenericHeaderLength, kProbeClusterId)) |
511 .Times(1); | 513 .Times(1); |
512 | 514 |
513 SendGenericPayload(); | 515 SendGenericPayload(); |
514 rtp_sender_->TimeToSendPacket(seq_num, fake_clock_.TimeInMilliseconds(), | 516 rtp_sender_->TimeToSendPacket( |
515 false, kProbeClusterId); | 517 kSsrc, kSeqNum, fake_clock_.TimeInMilliseconds(), false, kProbeClusterId); |
516 | 518 |
517 const auto& packet = transport_.last_sent_packet(); | 519 const auto& packet = transport_.last_sent_packet(); |
518 uint16_t transport_seq_no; | 520 uint16_t transport_seq_no; |
519 EXPECT_TRUE(packet.GetExtension<TransportSequenceNumber>(&transport_seq_no)); | 521 EXPECT_TRUE(packet.GetExtension<TransportSequenceNumber>(&transport_seq_no)); |
520 EXPECT_EQ(kTransportSequenceNumber, transport_seq_no); | 522 EXPECT_EQ(kTransportSequenceNumber, transport_seq_no); |
521 EXPECT_EQ(transport_.last_packet_id_, transport_seq_no); | 523 EXPECT_EQ(transport_.last_packet_id_, transport_seq_no); |
522 } | 524 } |
523 | 525 |
524 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) { | 526 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) { |
525 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, | 527 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, |
526 _, kSeqNum, _, _, _)); | 528 kSsrc, kSeqNum, _, _, _)); |
527 EXPECT_CALL(mock_rtc_event_log_, | 529 EXPECT_CALL(mock_rtc_event_log_, |
528 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)); | 530 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)); |
529 | 531 |
530 rtp_sender_->SetStorePacketsStatus(true, 10); | 532 rtp_sender_->SetStorePacketsStatus(true, 10); |
531 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 533 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
532 kRtpExtensionTransmissionTimeOffset, | 534 kRtpExtensionTransmissionTimeOffset, |
533 kTransmissionTimeOffsetExtensionId)); | 535 kTransmissionTimeOffsetExtensionId)); |
534 EXPECT_EQ( | 536 EXPECT_EQ( |
535 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, | 537 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, |
536 kAbsoluteSendTimeExtensionId)); | 538 kAbsoluteSendTimeExtensionId)); |
537 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); | 539 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); |
538 auto packet = | 540 auto packet = |
539 BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms); | 541 BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms); |
540 size_t packet_size = packet->size(); | 542 size_t packet_size = packet->size(); |
541 | 543 |
542 // Packet should be stored in a send bucket. | 544 // Packet should be stored in a send bucket. |
543 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), | 545 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), |
544 kAllowRetransmission, | 546 kAllowRetransmission, |
545 RtpPacketSender::kNormalPriority)); | 547 RtpPacketSender::kNormalPriority)); |
546 | 548 |
547 EXPECT_EQ(0, transport_.packets_sent()); | 549 EXPECT_EQ(0, transport_.packets_sent()); |
548 | 550 |
549 const int kStoredTimeInMs = 100; | 551 const int kStoredTimeInMs = 100; |
550 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); | 552 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); |
551 | 553 |
552 rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false, | 554 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false, |
553 PacketInfo::kNotAProbe); | 555 PacketInfo::kNotAProbe); |
554 | 556 |
555 // Process send bucket. Packet should now be sent. | 557 // Process send bucket. Packet should now be sent. |
556 EXPECT_EQ(1, transport_.packets_sent()); | 558 EXPECT_EQ(1, transport_.packets_sent()); |
557 EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); | 559 EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); |
558 | 560 |
559 webrtc::RTPHeader rtp_header; | 561 webrtc::RTPHeader rtp_header; |
560 transport_.last_sent_packet().GetHeader(&rtp_header); | 562 transport_.last_sent_packet().GetHeader(&rtp_header); |
561 | 563 |
562 // Verify transmission time offset. | 564 // Verify transmission time offset. |
563 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); | 565 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); |
564 uint64_t expected_send_time = | 566 uint64_t expected_send_time = |
565 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); | 567 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); |
566 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); | 568 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); |
567 } | 569 } |
568 | 570 |
569 TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) { | 571 TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) { |
570 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, | 572 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, |
571 _, kSeqNum, _, _, _)); | 573 kSsrc, kSeqNum, _, _, _)); |
572 EXPECT_CALL(mock_rtc_event_log_, | 574 EXPECT_CALL(mock_rtc_event_log_, |
573 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)); | 575 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)); |
574 | 576 |
575 rtp_sender_->SetStorePacketsStatus(true, 10); | 577 rtp_sender_->SetStorePacketsStatus(true, 10); |
576 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 578 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
577 kRtpExtensionTransmissionTimeOffset, | 579 kRtpExtensionTransmissionTimeOffset, |
578 kTransmissionTimeOffsetExtensionId)); | 580 kTransmissionTimeOffsetExtensionId)); |
579 EXPECT_EQ( | 581 EXPECT_EQ( |
580 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, | 582 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, |
581 kAbsoluteSendTimeExtensionId)); | 583 kAbsoluteSendTimeExtensionId)); |
582 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); | 584 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); |
583 auto packet = | 585 auto packet = |
584 BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms); | 586 BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms); |
585 size_t packet_size = packet->size(); | 587 size_t packet_size = packet->size(); |
586 | 588 |
587 // Packet should be stored in a send bucket. | 589 // Packet should be stored in a send bucket. |
588 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), | 590 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), |
589 kAllowRetransmission, | 591 kAllowRetransmission, |
590 RtpPacketSender::kNormalPriority)); | 592 RtpPacketSender::kNormalPriority)); |
591 | 593 |
592 EXPECT_EQ(0, transport_.packets_sent()); | 594 EXPECT_EQ(0, transport_.packets_sent()); |
593 | 595 |
594 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, | 596 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, |
595 _, kSeqNum, _, _, _)); | 597 kSsrc, kSeqNum, _, _, _)); |
596 | 598 |
597 const int kStoredTimeInMs = 100; | 599 const int kStoredTimeInMs = 100; |
598 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); | 600 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); |
599 | 601 |
600 EXPECT_EQ(static_cast<int>(packet_size), rtp_sender_->ReSendPacket(kSeqNum)); | 602 EXPECT_EQ(static_cast<int>(packet_size), rtp_sender_->ReSendPacket(kSeqNum)); |
601 EXPECT_EQ(0, transport_.packets_sent()); | 603 EXPECT_EQ(0, transport_.packets_sent()); |
602 | 604 |
603 rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false, | 605 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, capture_time_ms, false, |
604 PacketInfo::kNotAProbe); | 606 PacketInfo::kNotAProbe); |
605 | 607 |
606 // Process send bucket. Packet should now be sent. | 608 // Process send bucket. Packet should now be sent. |
607 EXPECT_EQ(1, transport_.packets_sent()); | 609 EXPECT_EQ(1, transport_.packets_sent()); |
608 EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); | 610 EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); |
609 | 611 |
610 webrtc::RTPHeader rtp_header; | 612 webrtc::RTPHeader rtp_header; |
611 transport_.last_sent_packet().GetHeader(&rtp_header); | 613 transport_.last_sent_packet().GetHeader(&rtp_header); |
612 | 614 |
613 // Verify transmission time offset. | 615 // Verify transmission time offset. |
614 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); | 616 EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset); |
615 uint64_t expected_send_time = | 617 uint64_t expected_send_time = |
616 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); | 618 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); |
617 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); | 619 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); |
618 } | 620 } |
619 | 621 |
620 // This test sends 1 regular video packet, then 4 padding packets, and then | 622 // This test sends 1 regular video packet, then 4 padding packets, and then |
621 // 1 more regular packet. | 623 // 1 more regular packet. |
622 TEST_F(RtpSenderTest, SendPadding) { | 624 TEST_F(RtpSenderTest, SendPadding) { |
623 // Make all (non-padding) packets go to send queue. | 625 // Make all (non-padding) packets go to send queue. |
624 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, | 626 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, |
625 _, kSeqNum, _, _, _)); | 627 kSsrc, kSeqNum, _, _, _)); |
626 EXPECT_CALL(mock_rtc_event_log_, | 628 EXPECT_CALL(mock_rtc_event_log_, |
627 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) | 629 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) |
628 .Times(1 + 4 + 1); | 630 .Times(1 + 4 + 1); |
629 | 631 |
630 uint16_t seq_num = kSeqNum; | 632 uint16_t seq_num = kSeqNum; |
631 uint32_t timestamp = kTimestamp; | 633 uint32_t timestamp = kTimestamp; |
632 rtp_sender_->SetStorePacketsStatus(true, 10); | 634 rtp_sender_->SetStorePacketsStatus(true, 10); |
633 size_t rtp_header_len = kRtpHeaderSize; | 635 size_t rtp_header_len = kRtpHeaderSize; |
634 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 636 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
635 kRtpExtensionTransmissionTimeOffset, | 637 kRtpExtensionTransmissionTimeOffset, |
(...skipping 16 matching lines...) Expand all Loading... |
652 // Packet should be stored in a send bucket. | 654 // Packet should be stored in a send bucket. |
653 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), | 655 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), |
654 kAllowRetransmission, | 656 kAllowRetransmission, |
655 RtpPacketSender::kNormalPriority)); | 657 RtpPacketSender::kNormalPriority)); |
656 | 658 |
657 int total_packets_sent = 0; | 659 int total_packets_sent = 0; |
658 EXPECT_EQ(total_packets_sent, transport_.packets_sent()); | 660 EXPECT_EQ(total_packets_sent, transport_.packets_sent()); |
659 | 661 |
660 const int kStoredTimeInMs = 100; | 662 const int kStoredTimeInMs = 100; |
661 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); | 663 fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); |
662 rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false, | 664 rtp_sender_->TimeToSendPacket(kSsrc, seq_num++, capture_time_ms, false, |
663 PacketInfo::kNotAProbe); | 665 PacketInfo::kNotAProbe); |
664 // Packet should now be sent. This test doesn't verify the regular video | 666 // Packet should now be sent. This test doesn't verify the regular video |
665 // packet, since it is tested in another test. | 667 // packet, since it is tested in another test. |
666 EXPECT_EQ(++total_packets_sent, transport_.packets_sent()); | 668 EXPECT_EQ(++total_packets_sent, transport_.packets_sent()); |
667 timestamp += 90 * kStoredTimeInMs; | 669 timestamp += 90 * kStoredTimeInMs; |
668 | 670 |
669 // Send padding 4 times, waiting 50 ms between each. | 671 // Send padding 4 times, waiting 50 ms between each. |
670 for (int i = 0; i < 4; ++i) { | 672 for (int i = 0; i < 4; ++i) { |
671 const int kPaddingPeriodMs = 50; | 673 const int kPaddingPeriodMs = 50; |
672 const size_t kPaddingBytes = 100; | 674 const size_t kPaddingBytes = 100; |
(...skipping 22 matching lines...) Expand all Loading... |
695 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); | 697 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); |
696 fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs); | 698 fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs); |
697 timestamp += 90 * kPaddingPeriodMs; | 699 timestamp += 90 * kPaddingPeriodMs; |
698 } | 700 } |
699 | 701 |
700 // Send a regular video packet again. | 702 // Send a regular video packet again. |
701 capture_time_ms = fake_clock_.TimeInMilliseconds(); | 703 capture_time_ms = fake_clock_.TimeInMilliseconds(); |
702 packet = BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms); | 704 packet = BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms); |
703 packet_size = packet->size(); | 705 packet_size = packet->size(); |
704 | 706 |
705 EXPECT_CALL(mock_paced_sender_, | 707 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, |
706 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)); | 708 kSsrc, seq_num, _, _, _)); |
707 | 709 |
708 // Packet should be stored in a send bucket. | 710 // Packet should be stored in a send bucket. |
709 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), | 711 EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet), |
710 kAllowRetransmission, | 712 kAllowRetransmission, |
711 RtpPacketSender::kNormalPriority)); | 713 RtpPacketSender::kNormalPriority)); |
712 | 714 |
713 rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false, | 715 rtp_sender_->TimeToSendPacket(kSsrc, seq_num, capture_time_ms, false, |
714 PacketInfo::kNotAProbe); | 716 PacketInfo::kNotAProbe); |
715 // Process send bucket. | 717 // Process send bucket. |
716 EXPECT_EQ(++total_packets_sent, transport_.packets_sent()); | 718 EXPECT_EQ(++total_packets_sent, transport_.packets_sent()); |
717 EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); | 719 EXPECT_EQ(packet_size, transport_.last_sent_packet().size()); |
718 transport_.last_sent_packet().GetHeader(&rtp_header); | 720 transport_.last_sent_packet().GetHeader(&rtp_header); |
719 | 721 |
720 // Verify sequence number and timestamp. | 722 // Verify sequence number and timestamp. |
721 EXPECT_EQ(seq_num, rtp_header.sequenceNumber); | 723 EXPECT_EQ(seq_num, rtp_header.sequenceNumber); |
722 EXPECT_EQ(timestamp, rtp_header.timestamp); | 724 EXPECT_EQ(timestamp, rtp_header.timestamp); |
723 // Verify transmission time offset. This packet is sent without delay. | 725 // Verify transmission time offset. This packet is sent without delay. |
724 EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset); | 726 EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset); |
725 uint64_t expected_send_time = | 727 uint64_t expected_send_time = |
726 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); | 728 ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds()); |
727 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); | 729 EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); |
728 } | 730 } |
729 | 731 |
730 TEST_F(RtpSenderTest, OnSendPacketUpdated) { | 732 TEST_F(RtpSenderTest, OnSendPacketUpdated) { |
731 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 733 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
732 kRtpExtensionTransportSequenceNumber, | 734 kRtpExtensionTransportSequenceNumber, |
733 kTransportSequenceNumberExtensionId)); | 735 kTransportSequenceNumberExtensionId)); |
734 rtp_sender_->SetStorePacketsStatus(true, 10); | 736 rtp_sender_->SetStorePacketsStatus(true, 10); |
735 | 737 |
736 EXPECT_CALL(send_packet_observer_, | 738 EXPECT_CALL(send_packet_observer_, |
737 OnSendPacket(kTransportSequenceNumber, _, _)) | 739 OnSendPacket(kTransportSequenceNumber, _, _)) |
738 .Times(1); | 740 .Times(1); |
739 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber()) | 741 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber()) |
740 .WillOnce(testing::Return(kTransportSequenceNumber)); | 742 .WillOnce(testing::Return(kTransportSequenceNumber)); |
741 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)).Times(1); | 743 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _)) |
| 744 .Times(1); |
742 | 745 |
743 SendGenericPayload(); // Packet passed to pacer. | 746 SendGenericPayload(); // Packet passed to pacer. |
744 const bool kIsRetransmit = false; | 747 const bool kIsRetransmit = false; |
745 rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), | 748 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, |
746 kIsRetransmit, PacketInfo::kNotAProbe); | 749 fake_clock_.TimeInMilliseconds(), kIsRetransmit, |
| 750 PacketInfo::kNotAProbe); |
747 EXPECT_EQ(1, transport_.packets_sent()); | 751 EXPECT_EQ(1, transport_.packets_sent()); |
748 } | 752 } |
749 | 753 |
750 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) { | 754 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) { |
751 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 755 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
752 kRtpExtensionTransportSequenceNumber, | 756 kRtpExtensionTransportSequenceNumber, |
753 kTransportSequenceNumberExtensionId)); | 757 kTransportSequenceNumberExtensionId)); |
754 rtp_sender_->SetStorePacketsStatus(true, 10); | 758 rtp_sender_->SetStorePacketsStatus(true, 10); |
755 | 759 |
756 EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0); | 760 EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0); |
757 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber()) | 761 EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber()) |
758 .WillOnce(testing::Return(kTransportSequenceNumber)); | 762 .WillOnce(testing::Return(kTransportSequenceNumber)); |
759 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)).Times(1); | 763 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _)) |
| 764 .Times(1); |
760 | 765 |
761 SendGenericPayload(); // Packet passed to pacer. | 766 SendGenericPayload(); // Packet passed to pacer. |
762 const bool kIsRetransmit = true; | 767 const bool kIsRetransmit = true; |
763 rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), | 768 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, |
764 kIsRetransmit, PacketInfo::kNotAProbe); | 769 fake_clock_.TimeInMilliseconds(), kIsRetransmit, |
| 770 PacketInfo::kNotAProbe); |
765 EXPECT_EQ(1, transport_.packets_sent()); | 771 EXPECT_EQ(1, transport_.packets_sent()); |
766 } | 772 } |
767 | 773 |
768 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) { | 774 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) { |
769 rtp_sender_.reset(new RTPSender( | 775 rtp_sender_.reset(new RTPSender( |
770 false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr, | 776 false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr, |
771 nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr, | 777 nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr, |
772 nullptr, nullptr, &send_packet_observer_, &retransmission_rate_limiter_)); | 778 nullptr, nullptr, &send_packet_observer_, &retransmission_rate_limiter_)); |
| 779 rtp_sender_->SetSequenceNumber(kSeqNum); |
| 780 rtp_sender_->SetSSRC(kSsrc); |
773 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 781 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
774 kRtpExtensionTransportSequenceNumber, | 782 kRtpExtensionTransportSequenceNumber, |
775 kTransportSequenceNumberExtensionId)); | 783 kTransportSequenceNumberExtensionId)); |
776 rtp_sender_->SetSequenceNumber(kSeqNum); | 784 rtp_sender_->SetSequenceNumber(kSeqNum); |
777 rtp_sender_->SetStorePacketsStatus(true, 10); | 785 rtp_sender_->SetStorePacketsStatus(true, 10); |
778 | 786 |
779 EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0); | 787 EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0); |
780 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)).Times(1); | 788 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, kSsrc, kSeqNum, _, _, _)) |
| 789 .Times(1); |
781 | 790 |
782 SendGenericPayload(); // Packet passed to pacer. | 791 SendGenericPayload(); // Packet passed to pacer. |
783 const bool kIsRetransmit = false; | 792 const bool kIsRetransmit = false; |
784 rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), | 793 rtp_sender_->TimeToSendPacket(kSsrc, kSeqNum, |
785 kIsRetransmit, PacketInfo::kNotAProbe); | 794 fake_clock_.TimeInMilliseconds(), kIsRetransmit, |
| 795 PacketInfo::kNotAProbe); |
786 EXPECT_EQ(1, transport_.packets_sent()); | 796 EXPECT_EQ(1, transport_.packets_sent()); |
787 } | 797 } |
788 | 798 |
789 TEST_F(RtpSenderTest, SendRedundantPayloads) { | 799 TEST_F(RtpSenderTest, SendRedundantPayloads) { |
790 MockTransport transport; | 800 MockTransport transport; |
791 rtp_sender_.reset(new RTPSender( | 801 rtp_sender_.reset(new RTPSender( |
792 false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr, | 802 false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr, |
793 nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr, | 803 nullptr, nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr, |
794 &retransmission_rate_limiter_)); | 804 &retransmission_rate_limiter_)); |
795 | |
796 rtp_sender_->SetSequenceNumber(kSeqNum); | 805 rtp_sender_->SetSequenceNumber(kSeqNum); |
| 806 rtp_sender_->SetSSRC(kSsrc); |
797 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload); | 807 rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload); |
798 | 808 |
799 uint16_t seq_num = kSeqNum; | 809 uint16_t seq_num = kSeqNum; |
800 rtp_sender_->SetStorePacketsStatus(true, 10); | 810 rtp_sender_->SetStorePacketsStatus(true, 10); |
801 int32_t rtp_header_len = kRtpHeaderSize; | 811 int32_t rtp_header_len = kRtpHeaderSize; |
802 EXPECT_EQ( | 812 EXPECT_EQ( |
803 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, | 813 0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, |
804 kAbsoluteSendTimeExtensionId)); | 814 kAbsoluteSendTimeExtensionId)); |
805 rtp_header_len += 4; // 4 bytes extension. | 815 rtp_header_len += 4; // 4 bytes extension. |
806 rtp_header_len += 4; // 4 extra bytes common to all extension headers. | 816 rtp_header_len += 4; // 4 extra bytes common to all extension headers. |
807 | 817 |
808 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); | 818 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); |
809 rtp_sender_->SetRtxSsrc(1234); | 819 rtp_sender_->SetRtxSsrc(1234); |
810 | 820 |
811 const size_t kNumPayloadSizes = 10; | 821 const size_t kNumPayloadSizes = 10; |
812 const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700, | 822 const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700, |
813 750, 800, 850, 900, 950}; | 823 750, 800, 850, 900, 950}; |
814 // Expect all packets go through the pacer. | 824 // Expect all packets go through the pacer. |
815 EXPECT_CALL(mock_paced_sender_, | 825 EXPECT_CALL(mock_paced_sender_, |
816 InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _)) | 826 InsertPacket(RtpPacketSender::kNormalPriority, kSsrc, _, _, _, _)) |
817 .Times(kNumPayloadSizes); | 827 .Times(kNumPayloadSizes); |
818 EXPECT_CALL(mock_rtc_event_log_, | 828 EXPECT_CALL(mock_rtc_event_log_, |
819 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) | 829 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) |
820 .Times(kNumPayloadSizes); | 830 .Times(kNumPayloadSizes); |
821 | 831 |
822 // Send 10 packets of increasing size. | 832 // Send 10 packets of increasing size. |
823 for (size_t i = 0; i < kNumPayloadSizes; ++i) { | 833 for (size_t i = 0; i < kNumPayloadSizes; ++i) { |
824 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); | 834 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); |
825 EXPECT_CALL(transport, SendRtp(_, _, _)).WillOnce(testing::Return(true)); | 835 EXPECT_CALL(transport, SendRtp(_, _, _)).WillOnce(testing::Return(true)); |
826 SendPacket(capture_time_ms, kPayloadSizes[i]); | 836 SendPacket(capture_time_ms, kPayloadSizes[i]); |
827 rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false, | 837 rtp_sender_->TimeToSendPacket(kSsrc, seq_num++, capture_time_ms, false, |
828 PacketInfo::kNotAProbe); | 838 PacketInfo::kNotAProbe); |
829 fake_clock_.AdvanceTimeMilliseconds(33); | 839 fake_clock_.AdvanceTimeMilliseconds(33); |
830 } | 840 } |
831 | 841 |
832 EXPECT_CALL(mock_rtc_event_log_, | 842 EXPECT_CALL(mock_rtc_event_log_, |
833 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) | 843 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) |
834 .Times(::testing::AtLeast(4)); | 844 .Times(::testing::AtLeast(4)); |
835 | 845 |
836 // The amount of padding to send it too small to send a payload packet. | 846 // The amount of padding to send it too small to send a payload packet. |
837 EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _)) | 847 EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _)) |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
919 rtp_sender_->SetSendPayloadType(kMediaPayloadType); | 929 rtp_sender_->SetSendPayloadType(kMediaPayloadType); |
920 rtp_sender_->SetStorePacketsStatus(true, 10); | 930 rtp_sender_->SetStorePacketsStatus(true, 10); |
921 | 931 |
922 // Parameters selected to generate a single FEC packet per media packet. | 932 // Parameters selected to generate a single FEC packet per media packet. |
923 FecProtectionParams params; | 933 FecProtectionParams params; |
924 params.fec_rate = 15; | 934 params.fec_rate = 15; |
925 params.max_fec_frames = 1; | 935 params.max_fec_frames = 1; |
926 params.fec_mask_type = kFecMaskRandom; | 936 params.fec_mask_type = kFecMaskRandom; |
927 rtp_sender_->SetFecParameters(params, params); | 937 rtp_sender_->SetFecParameters(params, params); |
928 | 938 |
929 uint16_t media_seq_num; | 939 EXPECT_CALL(mock_paced_sender_, |
| 940 InsertPacket(RtpPacketSender::kLowPriority, kMediaSsrc, kSeqNum, |
| 941 _, _, false)); |
| 942 uint16_t flexfec_seq_num; |
930 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority, | 943 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority, |
931 kMediaSsrc, _, _, _, false)) | 944 kFlexfecSsrc, _, _, _, false)) |
932 .WillOnce(testing::SaveArg<2>(&media_seq_num)); | 945 .WillOnce(testing::SaveArg<2>(&flexfec_seq_num)); |
933 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority, | |
934 kFlexfecSsrc, _, _, _, false)); | |
935 SendGenericPayload(); | 946 SendGenericPayload(); |
936 // TODO(brandtr): Make these tests stricter when the FlexFEC packets are no | |
937 // longer lost between PacedSender and RTPSender. | |
938 EXPECT_CALL(mock_rtc_event_log_, | 947 EXPECT_CALL(mock_rtc_event_log_, |
939 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) | 948 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) |
940 .Times(testing::AtLeast(1)); | 949 .Times(2); |
941 EXPECT_TRUE(rtp_sender_->TimeToSendPacket( | 950 EXPECT_TRUE(rtp_sender_->TimeToSendPacket( |
942 media_seq_num, fake_clock_.TimeInMilliseconds(), false, 0)); | 951 kMediaSsrc, kSeqNum, fake_clock_.TimeInMilliseconds(), false, 0)); |
943 EXPECT_LE(1, transport_.packets_sent()); | 952 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kFlexfecSsrc, flexfec_seq_num, |
| 953 fake_clock_.TimeInMilliseconds(), |
| 954 false, 0)); |
| 955 ASSERT_EQ(2, transport_.packets_sent()); |
944 const RtpPacketReceived& media_packet = transport_.sent_packets_[0]; | 956 const RtpPacketReceived& media_packet = transport_.sent_packets_[0]; |
945 EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType()); | 957 EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType()); |
946 EXPECT_EQ(media_seq_num, media_packet.SequenceNumber()); | 958 EXPECT_EQ(kSeqNum, media_packet.SequenceNumber()); |
947 EXPECT_EQ(kMediaSsrc, media_packet.Ssrc()); | 959 EXPECT_EQ(kMediaSsrc, media_packet.Ssrc()); |
| 960 const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[1]; |
| 961 EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType()); |
| 962 EXPECT_EQ(flexfec_seq_num, flexfec_packet.SequenceNumber()); |
| 963 EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc()); |
948 } | 964 } |
949 | 965 |
950 TEST_F(RtpSenderTestWithoutPacer, SendFlexfecPackets) { | 966 TEST_F(RtpSenderTestWithoutPacer, SendFlexfecPackets) { |
951 constexpr int kMediaPayloadType = 127; | 967 constexpr int kMediaPayloadType = 127; |
952 constexpr int kFlexfecPayloadType = 118; | 968 constexpr int kFlexfecPayloadType = 118; |
953 constexpr uint32_t kMediaSsrc = 1234; | 969 constexpr uint32_t kMediaSsrc = 1234; |
954 constexpr uint32_t kFlexfecSsrc = 5678; | 970 constexpr uint32_t kFlexfecSsrc = 5678; |
955 const std::vector<RtpExtension> kNoRtpExtensions; | 971 const std::vector<RtpExtension> kNoRtpExtensions; |
956 FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, | 972 FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
957 kNoRtpExtensions, &fake_clock_); | 973 kNoRtpExtensions, &fake_clock_); |
(...skipping 514 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1472 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0)); | 1488 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0)); |
1473 EXPECT_EQ(kVideoRotation_90, | 1489 EXPECT_EQ(kVideoRotation_90, |
1474 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1)); | 1490 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1)); |
1475 EXPECT_EQ(kVideoRotation_180, | 1491 EXPECT_EQ(kVideoRotation_180, |
1476 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2)); | 1492 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2)); |
1477 EXPECT_EQ(kVideoRotation_270, | 1493 EXPECT_EQ(kVideoRotation_270, |
1478 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3)); | 1494 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3)); |
1479 } | 1495 } |
1480 | 1496 |
1481 } // namespace webrtc | 1497 } // namespace webrtc |
OLD | NEW |