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 |
11 #include <memory> | 11 #include <memory> |
12 #include <vector> | 12 #include <vector> |
13 | 13 |
14 #include "webrtc/api/video/video_timing.h" | 14 #include "webrtc/api/video/video_timing.h" |
15 #include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h" | 15 #include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h" |
16 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h" | 16 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h" |
17 #include "webrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h" | 17 #include "webrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h" |
18 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" | 18 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" |
19 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" | 19 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
20 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" | 20 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
21 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h" | 21 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h" |
22 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" | 22 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" |
23 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h" | 23 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h" |
24 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h" | 24 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h" |
25 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h" | 25 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h" |
26 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h" | 26 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h" |
27 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" | 27 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" |
| 28 #include "webrtc/rtc_base/arraysize.h" |
28 #include "webrtc/rtc_base/buffer.h" | 29 #include "webrtc/rtc_base/buffer.h" |
| 30 #include "webrtc/rtc_base/ptr_util.h" |
29 #include "webrtc/rtc_base/rate_limiter.h" | 31 #include "webrtc/rtc_base/rate_limiter.h" |
30 #include "webrtc/test/field_trial.h" | 32 #include "webrtc/test/field_trial.h" |
31 #include "webrtc/test/gmock.h" | 33 #include "webrtc/test/gmock.h" |
32 #include "webrtc/test/gtest.h" | 34 #include "webrtc/test/gtest.h" |
33 #include "webrtc/test/mock_transport.h" | 35 #include "webrtc/test/mock_transport.h" |
34 #include "webrtc/typedefs.h" | 36 #include "webrtc/typedefs.h" |
35 | 37 |
36 namespace webrtc { | 38 namespace webrtc { |
37 | 39 |
38 namespace { | 40 namespace { |
39 const int kTransmissionTimeOffsetExtensionId = 1; | 41 const int kTransmissionTimeOffsetExtensionId = 1; |
40 const int kAbsoluteSendTimeExtensionId = 14; | 42 const int kAbsoluteSendTimeExtensionId = 14; |
41 const int kTransportSequenceNumberExtensionId = 13; | 43 const int kTransportSequenceNumberExtensionId = 13; |
42 const int kVideoTimingExtensionId = 12; | 44 const int kVideoTimingExtensionId = 12; |
43 const int kPayload = 100; | 45 const int kPayload = 100; |
44 const int kRtxPayload = 98; | 46 const int kRtxPayload = 98; |
45 const uint32_t kTimestamp = 10; | 47 const uint32_t kTimestamp = 10; |
46 const uint16_t kSeqNum = 33; | 48 const uint16_t kSeqNum = 33; |
47 const uint32_t kSsrc = 725242; | 49 const uint32_t kSsrc = 725242; |
48 const int kMaxPacketLength = 1500; | 50 const int kMaxPacketLength = 1500; |
49 const uint8_t kAudioLevel = 0x5a; | 51 const uint8_t kAudioLevel = 0x5a; |
50 const uint16_t kTransportSequenceNumber = 0xaabbu; | 52 const uint16_t kTransportSequenceNumber = 0xaabbu; |
51 const uint8_t kAudioLevelExtensionId = 9; | 53 const uint8_t kAudioLevelExtensionId = 9; |
52 const int kAudioPayload = 103; | 54 const int kAudioPayload = 103; |
53 const uint64_t kStartTime = 123456789; | 55 const uint64_t kStartTime = 123456789; |
54 const size_t kMaxPaddingSize = 224u; | 56 const size_t kMaxPaddingSize = 224u; |
55 const int kVideoRotationExtensionId = 5; | 57 const int kVideoRotationExtensionId = 5; |
56 const size_t kGenericHeaderLength = 1; | 58 const size_t kGenericHeaderLength = 1; |
57 const uint8_t kPayloadData[] = {47, 11, 32, 93, 89}; | 59 const uint8_t kPayloadData[] = {47, 11, 32, 93, 89}; |
| 60 const int64_t kDefaultExpectedRetransmissionTimeMs = 125; |
58 | 61 |
59 using ::testing::_; | 62 using ::testing::_; |
60 using ::testing::ElementsAreArray; | 63 using ::testing::ElementsAreArray; |
61 using ::testing::Invoke; | 64 using ::testing::Invoke; |
62 | 65 |
63 uint64_t ConvertMsToAbsSendTime(int64_t time_ms) { | 66 uint64_t ConvertMsToAbsSendTime(int64_t time_ms) { |
64 return (((time_ms << 18) + 500) / 1000) & 0x00ffffff; | 67 return (((time_ms << 18) + 500) / 1000) & 0x00ffffff; |
65 } | 68 } |
66 | 69 |
67 class LoopbackTransportTest : public webrtc::Transport { | 70 class LoopbackTransportTest : public webrtc::Transport { |
(...skipping 163 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
231 void SendGenericPayload() { | 234 void SendGenericPayload() { |
232 const uint32_t kTimestamp = 1234; | 235 const uint32_t kTimestamp = 1234; |
233 const uint8_t kPayloadType = 127; | 236 const uint8_t kPayloadType = 127; |
234 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds(); | 237 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds(); |
235 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; | 238 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; |
236 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000, | 239 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000, |
237 0, 1500)); | 240 0, 1500)); |
238 | 241 |
239 EXPECT_TRUE(rtp_sender_->SendOutgoingData( | 242 EXPECT_TRUE(rtp_sender_->SendOutgoingData( |
240 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayloadData, | 243 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayloadData, |
241 sizeof(kPayloadData), nullptr, nullptr, nullptr)); | 244 sizeof(kPayloadData), nullptr, nullptr, nullptr, |
| 245 kDefaultExpectedRetransmissionTimeMs)); |
242 } | 246 } |
243 }; | 247 }; |
244 | 248 |
245 // TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our | 249 // TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our |
246 // default code path. | 250 // default code path. |
247 class RtpSenderTestWithoutPacer : public RtpSenderTest { | 251 class RtpSenderTestWithoutPacer : public RtpSenderTest { |
248 public: | 252 public: |
249 void SetUp() override { SetUpRtpSender(false); } | 253 void SetUp() override { SetUpRtpSender(false); } |
250 }; | 254 }; |
251 | 255 |
| 256 class TestRtpSenderVideo : public RTPSenderVideo { |
| 257 public: |
| 258 TestRtpSenderVideo(Clock* clock, |
| 259 RTPSender* rtp_sender, |
| 260 FlexfecSender* flexfec_sender) |
| 261 : RTPSenderVideo(clock, rtp_sender, flexfec_sender) {} |
| 262 ~TestRtpSenderVideo() override {} |
| 263 |
| 264 StorageType GetStorageType(const RTPVideoHeader& header, |
| 265 int32_t retransmission_settings, |
| 266 int64_t expected_retransmission_time_ms) { |
| 267 return RTPSenderVideo::GetStorageType(GetTemporalId(header), |
| 268 retransmission_settings, |
| 269 expected_retransmission_time_ms); |
| 270 } |
| 271 }; |
| 272 |
252 class RtpSenderVideoTest : public RtpSenderTest { | 273 class RtpSenderVideoTest : public RtpSenderTest { |
253 protected: | 274 protected: |
254 void SetUp() override { | 275 void SetUp() override { |
255 // TODO(pbos): Set up to use pacer. | 276 // TODO(pbos): Set up to use pacer. |
256 SetUpRtpSender(false); | 277 SetUpRtpSender(false); |
257 rtp_sender_video_.reset( | 278 rtp_sender_video_.reset( |
258 new RTPSenderVideo(&fake_clock_, rtp_sender_.get(), nullptr)); | 279 new TestRtpSenderVideo(&fake_clock_, rtp_sender_.get(), nullptr)); |
259 } | 280 } |
260 std::unique_ptr<RTPSenderVideo> rtp_sender_video_; | 281 std::unique_ptr<TestRtpSenderVideo> rtp_sender_video_; |
261 }; | 282 }; |
262 | 283 |
263 TEST_P(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) { | 284 TEST_P(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) { |
264 // Configure rtp_sender with csrc. | 285 // Configure rtp_sender with csrc. |
265 std::vector<uint32_t> csrcs; | 286 std::vector<uint32_t> csrcs; |
266 csrcs.push_back(0x23456789); | 287 csrcs.push_back(0x23456789); |
267 rtp_sender_->SetCsrcs(csrcs); | 288 rtp_sender_->SetCsrcs(csrcs); |
268 | 289 |
269 auto packet = rtp_sender_->AllocatePacket(); | 290 auto packet = rtp_sender_->AllocatePacket(); |
270 | 291 |
(...skipping 583 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
854 } | 875 } |
855 | 876 |
856 TEST_P(RtpSenderTestWithoutPacer, SendGenericVideo) { | 877 TEST_P(RtpSenderTestWithoutPacer, SendGenericVideo) { |
857 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; | 878 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; |
858 const uint8_t payload_type = 127; | 879 const uint8_t payload_type = 127; |
859 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, | 880 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, |
860 0, 1500)); | 881 0, 1500)); |
861 uint8_t payload[] = {47, 11, 32, 93, 89}; | 882 uint8_t payload[] = {47, 11, 32, 93, 89}; |
862 | 883 |
863 // Send keyframe | 884 // Send keyframe |
864 ASSERT_TRUE(rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, | 885 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
865 4321, payload, sizeof(payload), | 886 kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload), |
866 nullptr, nullptr, nullptr)); | 887 nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
867 | 888 |
868 auto sent_payload = transport_.last_sent_packet().payload(); | 889 auto sent_payload = transport_.last_sent_packet().payload(); |
869 uint8_t generic_header = sent_payload[0]; | 890 uint8_t generic_header = sent_payload[0]; |
870 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); | 891 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); |
871 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); | 892 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); |
872 EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(payload)); | 893 EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(payload)); |
873 | 894 |
874 // Send delta frame | 895 // Send delta frame |
875 payload[0] = 13; | 896 payload[0] = 13; |
876 payload[1] = 42; | 897 payload[1] = 42; |
877 payload[4] = 13; | 898 payload[4] = 13; |
878 | 899 |
879 ASSERT_TRUE(rtp_sender_->SendOutgoingData( | 900 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
880 kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload), | 901 kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload), |
881 nullptr, nullptr, nullptr)); | 902 nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
882 | 903 |
883 sent_payload = transport_.last_sent_packet().payload(); | 904 sent_payload = transport_.last_sent_packet().payload(); |
884 generic_header = sent_payload[0]; | 905 generic_header = sent_payload[0]; |
885 EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); | 906 EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); |
886 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); | 907 EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); |
887 EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(payload)); | 908 EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(payload)); |
888 } | 909 } |
889 | 910 |
890 TEST_P(RtpSenderTest, SendFlexfecPackets) { | 911 TEST_P(RtpSenderTest, SendFlexfecPackets) { |
891 constexpr int kMediaPayloadType = 127; | 912 constexpr int kMediaPayloadType = 127; |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
991 const uint8_t kPayloadType = 127; | 1012 const uint8_t kPayloadType = 127; |
992 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds(); | 1013 const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds(); |
993 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; | 1014 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; |
994 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000, | 1015 EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000, |
995 0, 1500)); | 1016 0, 1500)); |
996 RTPVideoHeader video_header; | 1017 RTPVideoHeader video_header; |
997 memset(&video_header, 0, sizeof(RTPVideoHeader)); | 1018 memset(&video_header, 0, sizeof(RTPVideoHeader)); |
998 video_header.video_timing.flags = TimingFrameFlags::kTriggeredByTimer; | 1019 video_header.video_timing.flags = TimingFrameFlags::kTriggeredByTimer; |
999 EXPECT_TRUE(rtp_sender_->SendOutgoingData( | 1020 EXPECT_TRUE(rtp_sender_->SendOutgoingData( |
1000 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayloadData, | 1021 kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayloadData, |
1001 sizeof(kPayloadData), nullptr, &video_header, nullptr)); | 1022 sizeof(kPayloadData), nullptr, &video_header, nullptr, |
| 1023 kDefaultExpectedRetransmissionTimeMs)); |
1002 | 1024 |
1003 EXPECT_CALL(mock_rtc_event_log_, | 1025 EXPECT_CALL(mock_rtc_event_log_, |
1004 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) | 1026 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) |
1005 .Times(1); | 1027 .Times(1); |
1006 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kMediaSsrc, kSeqNum, | 1028 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kMediaSsrc, kSeqNum, |
1007 fake_clock_.TimeInMilliseconds(), | 1029 fake_clock_.TimeInMilliseconds(), |
1008 false, PacedPacketInfo())); | 1030 false, PacedPacketInfo())); |
1009 ASSERT_EQ(1, transport_.packets_sent()); | 1031 ASSERT_EQ(1, transport_.packets_sent()); |
1010 const RtpPacketReceived& media_packet = transport_.sent_packets_[0]; | 1032 const RtpPacketReceived& media_packet = transport_.sent_packets_[0]; |
1011 EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType()); | 1033 EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType()); |
1012 EXPECT_EQ(kSeqNum, media_packet.SequenceNumber()); | 1034 EXPECT_EQ(kSeqNum, media_packet.SequenceNumber()); |
1013 EXPECT_EQ(kMediaSsrc, media_packet.Ssrc()); | 1035 EXPECT_EQ(kMediaSsrc, media_packet.Ssrc()); |
1014 | 1036 |
1015 // Now try to send not a timing frame. | 1037 // Now try to send not a timing frame. |
1016 uint16_t flexfec_seq_num; | 1038 uint16_t flexfec_seq_num; |
1017 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority, | 1039 EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kLowPriority, |
1018 kFlexfecSsrc, _, _, _, false)) | 1040 kFlexfecSsrc, _, _, _, false)) |
1019 .WillOnce(testing::SaveArg<2>(&flexfec_seq_num)); | 1041 .WillOnce(testing::SaveArg<2>(&flexfec_seq_num)); |
1020 EXPECT_CALL(mock_paced_sender_, | 1042 EXPECT_CALL(mock_paced_sender_, |
1021 InsertPacket(RtpPacketSender::kLowPriority, kMediaSsrc, | 1043 InsertPacket(RtpPacketSender::kLowPriority, kMediaSsrc, |
1022 kSeqNum + 1, _, _, false)); | 1044 kSeqNum + 1, _, _, false)); |
1023 video_header.video_timing.flags = TimingFrameFlags::kInvalid; | 1045 video_header.video_timing.flags = TimingFrameFlags::kInvalid; |
1024 EXPECT_TRUE(rtp_sender_->SendOutgoingData( | 1046 EXPECT_TRUE(rtp_sender_->SendOutgoingData( |
1025 kVideoFrameKey, kPayloadType, kTimestamp + 1, kCaptureTimeMs + 1, | 1047 kVideoFrameKey, kPayloadType, kTimestamp + 1, kCaptureTimeMs + 1, |
1026 kPayloadData, sizeof(kPayloadData), nullptr, &video_header, nullptr)); | 1048 kPayloadData, sizeof(kPayloadData), nullptr, &video_header, nullptr, |
| 1049 kDefaultExpectedRetransmissionTimeMs)); |
1027 | 1050 |
1028 EXPECT_CALL(mock_rtc_event_log_, | 1051 EXPECT_CALL(mock_rtc_event_log_, |
1029 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) | 1052 LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _)) |
1030 .Times(2); | 1053 .Times(2); |
1031 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kMediaSsrc, kSeqNum + 1, | 1054 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kMediaSsrc, kSeqNum + 1, |
1032 fake_clock_.TimeInMilliseconds(), | 1055 fake_clock_.TimeInMilliseconds(), |
1033 false, PacedPacketInfo())); | 1056 false, PacedPacketInfo())); |
1034 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kFlexfecSsrc, flexfec_seq_num, | 1057 EXPECT_TRUE(rtp_sender_->TimeToSendPacket(kFlexfecSsrc, flexfec_seq_num, |
1035 fake_clock_.TimeInMilliseconds(), | 1058 fake_clock_.TimeInMilliseconds(), |
1036 false, PacedPacketInfo())); | 1059 false, PacedPacketInfo())); |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1161 const uint8_t payload_type = 127; | 1184 const uint8_t payload_type = 127; |
1162 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, | 1185 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, |
1163 0, 1500)); | 1186 0, 1500)); |
1164 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1187 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1165 rtp_sender_->SetStorePacketsStatus(true, 1); | 1188 rtp_sender_->SetStorePacketsStatus(true, 1); |
1166 uint32_t ssrc = rtp_sender_->SSRC(); | 1189 uint32_t ssrc = rtp_sender_->SSRC(); |
1167 | 1190 |
1168 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)) | 1191 EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)) |
1169 .Times(::testing::AtLeast(2)); | 1192 .Times(::testing::AtLeast(2)); |
1170 | 1193 |
1171 ASSERT_TRUE(rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234, | 1194 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1172 4321, payload, sizeof(payload), | 1195 kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload), |
1173 nullptr, nullptr, nullptr)); | 1196 nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1174 | 1197 |
1175 EXPECT_EQ(1U, callback.num_calls_); | 1198 EXPECT_EQ(1U, callback.num_calls_); |
1176 EXPECT_EQ(ssrc, callback.ssrc_); | 1199 EXPECT_EQ(ssrc, callback.ssrc_); |
1177 EXPECT_EQ(1, callback.frame_counts_.key_frames); | 1200 EXPECT_EQ(1, callback.frame_counts_.key_frames); |
1178 EXPECT_EQ(0, callback.frame_counts_.delta_frames); | 1201 EXPECT_EQ(0, callback.frame_counts_.delta_frames); |
1179 | 1202 |
1180 ASSERT_TRUE(rtp_sender_->SendOutgoingData( | 1203 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1181 kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload), | 1204 kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload), |
1182 nullptr, nullptr, nullptr)); | 1205 nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1183 | 1206 |
1184 EXPECT_EQ(2U, callback.num_calls_); | 1207 EXPECT_EQ(2U, callback.num_calls_); |
1185 EXPECT_EQ(ssrc, callback.ssrc_); | 1208 EXPECT_EQ(ssrc, callback.ssrc_); |
1186 EXPECT_EQ(1, callback.frame_counts_.key_frames); | 1209 EXPECT_EQ(1, callback.frame_counts_.key_frames); |
1187 EXPECT_EQ(1, callback.frame_counts_.delta_frames); | 1210 EXPECT_EQ(1, callback.frame_counts_.delta_frames); |
1188 | 1211 |
1189 rtp_sender_.reset(); | 1212 rtp_sender_.reset(); |
1190 } | 1213 } |
1191 | 1214 |
1192 TEST_P(RtpSenderTest, BitrateCallbacks) { | 1215 TEST_P(RtpSenderTest, BitrateCallbacks) { |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1238 rtp_sender_->SetStorePacketsStatus(true, 1); | 1261 rtp_sender_->SetStorePacketsStatus(true, 1); |
1239 uint32_t ssrc = rtp_sender_->SSRC(); | 1262 uint32_t ssrc = rtp_sender_->SSRC(); |
1240 | 1263 |
1241 // Initial process call so we get a new time window. | 1264 // Initial process call so we get a new time window. |
1242 rtp_sender_->ProcessBitrate(); | 1265 rtp_sender_->ProcessBitrate(); |
1243 | 1266 |
1244 // Send a few frames. | 1267 // Send a few frames. |
1245 for (uint32_t i = 0; i < kNumPackets; ++i) { | 1268 for (uint32_t i = 0; i < kNumPackets; ++i) { |
1246 ASSERT_TRUE(rtp_sender_->SendOutgoingData( | 1269 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1247 kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload), | 1270 kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload), |
1248 nullptr, nullptr, nullptr)); | 1271 nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1249 fake_clock_.AdvanceTimeMilliseconds(kPacketInterval); | 1272 fake_clock_.AdvanceTimeMilliseconds(kPacketInterval); |
1250 } | 1273 } |
1251 | 1274 |
1252 rtp_sender_->ProcessBitrate(); | 1275 rtp_sender_->ProcessBitrate(); |
1253 | 1276 |
1254 // We get one call for every stats updated, thus two calls since both the | 1277 // We get one call for every stats updated, thus two calls since both the |
1255 // stream stats and the retransmit stats are updated once. | 1278 // stream stats and the retransmit stats are updated once. |
1256 EXPECT_EQ(2u, callback.num_calls_); | 1279 EXPECT_EQ(2u, callback.num_calls_); |
1257 EXPECT_EQ(ssrc, callback.ssrc_); | 1280 EXPECT_EQ(ssrc, callback.ssrc_); |
1258 const uint32_t kTotalPacketSize = kPacketOverhead + sizeof(payload); | 1281 const uint32_t kTotalPacketSize = kPacketOverhead + sizeof(payload); |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1320 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, | 1343 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, |
1321 0, 1500)); | 1344 0, 1500)); |
1322 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1345 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1323 rtp_sender_->SetStorePacketsStatus(true, 1); | 1346 rtp_sender_->SetStorePacketsStatus(true, 1); |
1324 uint32_t ssrc = rtp_sender_->SSRC(); | 1347 uint32_t ssrc = rtp_sender_->SSRC(); |
1325 | 1348 |
1326 rtp_sender_->RegisterRtpStatisticsCallback(&callback); | 1349 rtp_sender_->RegisterRtpStatisticsCallback(&callback); |
1327 | 1350 |
1328 // Send a frame. | 1351 // Send a frame. |
1329 ASSERT_TRUE(rtp_sender_->SendOutgoingData( | 1352 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1330 kVideoFrameKey, payload_type, 1234, 4321, payload, | 1353 kVideoFrameKey, payload_type, 1234, 4321, payload, sizeof(payload), |
1331 sizeof(payload), nullptr, nullptr, nullptr)); | 1354 nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1332 StreamDataCounters expected; | 1355 StreamDataCounters expected; |
1333 expected.transmitted.payload_bytes = 6; | 1356 expected.transmitted.payload_bytes = 6; |
1334 expected.transmitted.header_bytes = 12; | 1357 expected.transmitted.header_bytes = 12; |
1335 expected.transmitted.padding_bytes = 0; | 1358 expected.transmitted.padding_bytes = 0; |
1336 expected.transmitted.packets = 1; | 1359 expected.transmitted.packets = 1; |
1337 expected.retransmitted.payload_bytes = 0; | 1360 expected.retransmitted.payload_bytes = 0; |
1338 expected.retransmitted.header_bytes = 0; | 1361 expected.retransmitted.header_bytes = 0; |
1339 expected.retransmitted.padding_bytes = 0; | 1362 expected.retransmitted.padding_bytes = 0; |
1340 expected.retransmitted.packets = 0; | 1363 expected.retransmitted.packets = 0; |
1341 expected.fec.packets = 0; | 1364 expected.fec.packets = 0; |
(...skipping 20 matching lines...) Expand all Loading... |
1362 callback.Matches(ssrc, expected); | 1385 callback.Matches(ssrc, expected); |
1363 | 1386 |
1364 // Send ULPFEC. | 1387 // Send ULPFEC. |
1365 rtp_sender_->SetUlpfecConfig(kRedPayloadType, kUlpfecPayloadType); | 1388 rtp_sender_->SetUlpfecConfig(kRedPayloadType, kUlpfecPayloadType); |
1366 FecProtectionParams fec_params; | 1389 FecProtectionParams fec_params; |
1367 fec_params.fec_mask_type = kFecMaskRandom; | 1390 fec_params.fec_mask_type = kFecMaskRandom; |
1368 fec_params.fec_rate = 1; | 1391 fec_params.fec_rate = 1; |
1369 fec_params.max_fec_frames = 1; | 1392 fec_params.max_fec_frames = 1; |
1370 rtp_sender_->SetFecParameters(fec_params, fec_params); | 1393 rtp_sender_->SetFecParameters(fec_params, fec_params); |
1371 ASSERT_TRUE(rtp_sender_->SendOutgoingData( | 1394 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1372 kVideoFrameDelta, payload_type, 1234, 4321, payload, | 1395 kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload), |
1373 sizeof(payload), nullptr, nullptr, nullptr)); | 1396 nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1374 expected.transmitted.payload_bytes = 40; | 1397 expected.transmitted.payload_bytes = 40; |
1375 expected.transmitted.header_bytes = 60; | 1398 expected.transmitted.header_bytes = 60; |
1376 expected.transmitted.packets = 5; | 1399 expected.transmitted.packets = 5; |
1377 expected.fec.packets = 1; | 1400 expected.fec.packets = 1; |
1378 callback.Matches(ssrc, expected); | 1401 callback.Matches(ssrc, expected); |
1379 | 1402 |
1380 rtp_sender_->RegisterRtpStatisticsCallback(nullptr); | 1403 rtp_sender_->RegisterRtpStatisticsCallback(nullptr); |
1381 } | 1404 } |
1382 | 1405 |
1383 TEST_P(RtpSenderAudioTest, SendAudio) { | 1406 TEST_P(RtpSenderAudioTest, SendAudio) { |
1384 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; | 1407 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; |
1385 const uint8_t payload_type = 127; | 1408 const uint8_t payload_type = 127; |
1386 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, | 1409 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, |
1387 0, 1500)); | 1410 0, 1500)); |
1388 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1411 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1389 | 1412 |
1390 ASSERT_TRUE(rtp_sender_->SendOutgoingData( | 1413 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1391 kAudioFrameCN, payload_type, 1234, 4321, payload, | 1414 kAudioFrameCN, payload_type, 1234, 4321, payload, sizeof(payload), |
1392 sizeof(payload), nullptr, nullptr, nullptr)); | 1415 nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1393 | 1416 |
1394 auto sent_payload = transport_.last_sent_packet().payload(); | 1417 auto sent_payload = transport_.last_sent_packet().payload(); |
1395 EXPECT_THAT(sent_payload, ElementsAreArray(payload)); | 1418 EXPECT_THAT(sent_payload, ElementsAreArray(payload)); |
1396 } | 1419 } |
1397 | 1420 |
1398 TEST_P(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) { | 1421 TEST_P(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) { |
1399 EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel)); | 1422 EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel)); |
1400 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, | 1423 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, |
1401 kAudioLevelExtensionId)); | 1424 kAudioLevelExtensionId)); |
1402 | 1425 |
1403 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; | 1426 char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; |
1404 const uint8_t payload_type = 127; | 1427 const uint8_t payload_type = 127; |
1405 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, | 1428 ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, |
1406 0, 1500)); | 1429 0, 1500)); |
1407 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1430 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1408 | 1431 |
1409 ASSERT_TRUE(rtp_sender_->SendOutgoingData( | 1432 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1410 kAudioFrameCN, payload_type, 1234, 4321, payload, | 1433 kAudioFrameCN, payload_type, 1234, 4321, payload, sizeof(payload), |
1411 sizeof(payload), nullptr, nullptr, nullptr)); | 1434 nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1412 | 1435 |
1413 auto sent_payload = transport_.last_sent_packet().payload(); | 1436 auto sent_payload = transport_.last_sent_packet().payload(); |
1414 EXPECT_THAT(sent_payload, ElementsAreArray(payload)); | 1437 EXPECT_THAT(sent_payload, ElementsAreArray(payload)); |
1415 // Verify AudioLevel extension. | 1438 // Verify AudioLevel extension. |
1416 bool voice_activity; | 1439 bool voice_activity; |
1417 uint8_t audio_level; | 1440 uint8_t audio_level; |
1418 EXPECT_TRUE(transport_.last_sent_packet().GetExtension<AudioLevel>( | 1441 EXPECT_TRUE(transport_.last_sent_packet().GetExtension<AudioLevel>( |
1419 &voice_activity, &audio_level)); | 1442 &voice_activity, &audio_level)); |
1420 EXPECT_EQ(kAudioLevel, audio_level); | 1443 EXPECT_EQ(kAudioLevel, audio_level); |
1421 EXPECT_FALSE(voice_activity); | 1444 EXPECT_FALSE(voice_activity); |
(...skipping 16 matching lines...) Expand all Loading... |
1438 // Registering the payload again for audio stream with different payload name. | 1461 // Registering the payload again for audio stream with different payload name. |
1439 const char* kPayloadName = "payload_name"; | 1462 const char* kPayloadName = "payload_name"; |
1440 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, | 1463 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, |
1441 kPayloadFrequency, 1, 0)); | 1464 kPayloadFrequency, 1, 0)); |
1442 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); | 1465 int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); |
1443 // DTMF event key=9, duration=500 and attenuationdB=10 | 1466 // DTMF event key=9, duration=500 and attenuationdB=10 |
1444 rtp_sender_->SendTelephoneEvent(9, 500, 10); | 1467 rtp_sender_->SendTelephoneEvent(9, 500, 10); |
1445 // During start, it takes the starting timestamp as last sent timestamp. | 1468 // During start, it takes the starting timestamp as last sent timestamp. |
1446 // The duration is calculated as the difference of current and last sent | 1469 // The duration is calculated as the difference of current and last sent |
1447 // timestamp. So for first call it will skip since the duration is zero. | 1470 // timestamp. So for first call it will skip since the duration is zero. |
1448 ASSERT_TRUE(rtp_sender_->SendOutgoingData(kEmptyFrame, kPayloadType, | 1471 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1449 capture_time_ms, 0, nullptr, 0, | 1472 kEmptyFrame, kPayloadType, capture_time_ms, 0, nullptr, 0, nullptr, |
1450 nullptr, nullptr, nullptr)); | 1473 nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1451 // DTMF Sample Length is (Frequency/1000) * Duration. | 1474 // DTMF Sample Length is (Frequency/1000) * Duration. |
1452 // So in this case, it is (8000/1000) * 500 = 4000. | 1475 // So in this case, it is (8000/1000) * 500 = 4000. |
1453 // Sending it as two packets. | 1476 // Sending it as two packets. |
1454 ASSERT_TRUE(rtp_sender_->SendOutgoingData( | 1477 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1455 kEmptyFrame, kPayloadType, capture_time_ms + 2000, 0, | 1478 kEmptyFrame, kPayloadType, capture_time_ms + 2000, 0, nullptr, 0, nullptr, |
1456 nullptr, 0, nullptr, nullptr, nullptr)); | 1479 nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1457 | 1480 |
1458 // Marker Bit should be set to 1 for first packet. | 1481 // Marker Bit should be set to 1 for first packet. |
1459 EXPECT_TRUE(transport_.last_sent_packet().Marker()); | 1482 EXPECT_TRUE(transport_.last_sent_packet().Marker()); |
1460 | 1483 |
1461 ASSERT_TRUE(rtp_sender_->SendOutgoingData( | 1484 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1462 kEmptyFrame, kPayloadType, capture_time_ms + 4000, 0, | 1485 kEmptyFrame, kPayloadType, capture_time_ms + 4000, 0, nullptr, 0, nullptr, |
1463 nullptr, 0, nullptr, nullptr, nullptr)); | 1486 nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1464 // Marker Bit should be set to 0 for rest of the packets. | 1487 // Marker Bit should be set to 0 for rest of the packets. |
1465 EXPECT_FALSE(transport_.last_sent_packet().Marker()); | 1488 EXPECT_FALSE(transport_.last_sent_packet().Marker()); |
1466 } | 1489 } |
1467 | 1490 |
1468 TEST_P(RtpSenderTestWithoutPacer, BytesReportedCorrectly) { | 1491 TEST_P(RtpSenderTestWithoutPacer, BytesReportedCorrectly) { |
1469 const char* kPayloadName = "GENERIC"; | 1492 const char* kPayloadName = "GENERIC"; |
1470 const uint8_t kPayloadType = 127; | 1493 const uint8_t kPayloadType = 127; |
1471 rtp_sender_->SetSSRC(1234); | 1494 rtp_sender_->SetSSRC(1234); |
1472 rtp_sender_->SetRtxSsrc(4321); | 1495 rtp_sender_->SetRtxSsrc(4321); |
1473 rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType); | 1496 rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType); |
1474 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); | 1497 rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads); |
1475 | 1498 |
1476 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000, | 1499 ASSERT_EQ(0, rtp_sender_->RegisterPayload(kPayloadName, kPayloadType, 90000, |
1477 0, 1500)); | 1500 0, 1500)); |
1478 uint8_t payload[] = {47, 11, 32, 93, 89}; | 1501 uint8_t payload[] = {47, 11, 32, 93, 89}; |
1479 | 1502 |
1480 ASSERT_TRUE(rtp_sender_->SendOutgoingData( | 1503 ASSERT_TRUE(rtp_sender_->SendOutgoingData( |
1481 kVideoFrameKey, kPayloadType, 1234, 4321, payload, | 1504 kVideoFrameKey, kPayloadType, 1234, 4321, payload, sizeof(payload), |
1482 sizeof(payload), nullptr, nullptr, nullptr)); | 1505 nullptr, nullptr, nullptr, kDefaultExpectedRetransmissionTimeMs)); |
1483 | 1506 |
1484 // Will send 2 full-size padding packets. | 1507 // Will send 2 full-size padding packets. |
1485 rtp_sender_->TimeToSendPadding(1, PacedPacketInfo()); | 1508 rtp_sender_->TimeToSendPadding(1, PacedPacketInfo()); |
1486 rtp_sender_->TimeToSendPadding(1, PacedPacketInfo()); | 1509 rtp_sender_->TimeToSendPadding(1, PacedPacketInfo()); |
1487 | 1510 |
1488 StreamDataCounters rtp_stats; | 1511 StreamDataCounters rtp_stats; |
1489 StreamDataCounters rtx_stats; | 1512 StreamDataCounters rtx_stats; |
1490 rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats); | 1513 rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats); |
1491 | 1514 |
1492 // Payload + 1-byte generic header. | 1515 // Payload + 1-byte generic header. |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1546 | 1569 |
1547 TEST_P(RtpSenderVideoTest, KeyFrameHasCVO) { | 1570 TEST_P(RtpSenderVideoTest, KeyFrameHasCVO) { |
1548 uint8_t kFrame[kMaxPacketLength]; | 1571 uint8_t kFrame[kMaxPacketLength]; |
1549 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 1572 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
1550 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); | 1573 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); |
1551 | 1574 |
1552 RTPVideoHeader hdr = {0}; | 1575 RTPVideoHeader hdr = {0}; |
1553 hdr.rotation = kVideoRotation_0; | 1576 hdr.rotation = kVideoRotation_0; |
1554 rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, kPayload, | 1577 rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, kPayload, |
1555 kTimestamp, 0, kFrame, sizeof(kFrame), nullptr, | 1578 kTimestamp, 0, kFrame, sizeof(kFrame), nullptr, |
1556 &hdr); | 1579 &hdr, kDefaultExpectedRetransmissionTimeMs); |
1557 | 1580 |
1558 VideoRotation rotation; | 1581 VideoRotation rotation; |
1559 EXPECT_TRUE( | 1582 EXPECT_TRUE( |
1560 transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation)); | 1583 transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation)); |
1561 EXPECT_EQ(kVideoRotation_0, rotation); | 1584 EXPECT_EQ(kVideoRotation_0, rotation); |
1562 } | 1585 } |
1563 | 1586 |
1564 TEST_P(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) { | 1587 TEST_P(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) { |
1565 uint8_t kFrame[kMaxPacketLength]; | 1588 uint8_t kFrame[kMaxPacketLength]; |
1566 const int64_t kPacketizationTimeMs = 100; | 1589 const int64_t kPacketizationTimeMs = 100; |
1567 const int64_t kEncodeStartDeltaMs = 10; | 1590 const int64_t kEncodeStartDeltaMs = 10; |
1568 const int64_t kEncodeFinishDeltaMs = 50; | 1591 const int64_t kEncodeFinishDeltaMs = 50; |
1569 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 1592 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
1570 kRtpExtensionVideoTiming, kVideoTimingExtensionId)); | 1593 kRtpExtensionVideoTiming, kVideoTimingExtensionId)); |
1571 | 1594 |
1572 const int64_t kCaptureTimestamp = fake_clock_.TimeInMilliseconds(); | 1595 const int64_t kCaptureTimestamp = fake_clock_.TimeInMilliseconds(); |
1573 | 1596 |
1574 RTPVideoHeader hdr = {0}; | 1597 RTPVideoHeader hdr = {0}; |
1575 hdr.video_timing.flags = TimingFrameFlags::kTriggeredByTimer; | 1598 hdr.video_timing.flags = TimingFrameFlags::kTriggeredByTimer; |
1576 hdr.video_timing.encode_start_delta_ms = kEncodeStartDeltaMs; | 1599 hdr.video_timing.encode_start_delta_ms = kEncodeStartDeltaMs; |
1577 hdr.video_timing.encode_finish_delta_ms = kEncodeFinishDeltaMs; | 1600 hdr.video_timing.encode_finish_delta_ms = kEncodeFinishDeltaMs; |
1578 | 1601 |
1579 fake_clock_.AdvanceTimeMilliseconds(kPacketizationTimeMs); | 1602 fake_clock_.AdvanceTimeMilliseconds(kPacketizationTimeMs); |
1580 rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, kPayload, | 1603 rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, kPayload, |
1581 kTimestamp, kCaptureTimestamp, kFrame, | 1604 kTimestamp, kCaptureTimestamp, kFrame, |
1582 sizeof(kFrame), nullptr, &hdr); | 1605 sizeof(kFrame), nullptr, &hdr, |
| 1606 kDefaultExpectedRetransmissionTimeMs); |
1583 VideoSendTiming timing; | 1607 VideoSendTiming timing; |
1584 EXPECT_TRUE(transport_.last_sent_packet().GetExtension<VideoTimingExtension>( | 1608 EXPECT_TRUE(transport_.last_sent_packet().GetExtension<VideoTimingExtension>( |
1585 &timing)); | 1609 &timing)); |
1586 EXPECT_EQ(kPacketizationTimeMs, timing.packetization_finish_delta_ms); | 1610 EXPECT_EQ(kPacketizationTimeMs, timing.packetization_finish_delta_ms); |
1587 EXPECT_EQ(kEncodeStartDeltaMs, timing.encode_start_delta_ms); | 1611 EXPECT_EQ(kEncodeStartDeltaMs, timing.encode_start_delta_ms); |
1588 EXPECT_EQ(kEncodeFinishDeltaMs, timing.encode_finish_delta_ms); | 1612 EXPECT_EQ(kEncodeFinishDeltaMs, timing.encode_finish_delta_ms); |
1589 } | 1613 } |
1590 | 1614 |
1591 TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) { | 1615 TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) { |
1592 uint8_t kFrame[kMaxPacketLength]; | 1616 uint8_t kFrame[kMaxPacketLength]; |
1593 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 1617 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
1594 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); | 1618 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); |
1595 | 1619 |
1596 RTPVideoHeader hdr = {0}; | 1620 RTPVideoHeader hdr = {0}; |
1597 hdr.rotation = kVideoRotation_90; | 1621 hdr.rotation = kVideoRotation_90; |
1598 EXPECT_TRUE(rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, | 1622 EXPECT_TRUE(rtp_sender_video_->SendVideo( |
1599 kPayload, kTimestamp, 0, kFrame, | 1623 kRtpVideoGeneric, kVideoFrameKey, kPayload, kTimestamp, 0, kFrame, |
1600 sizeof(kFrame), nullptr, &hdr)); | 1624 sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); |
1601 | 1625 |
1602 hdr.rotation = kVideoRotation_0; | 1626 hdr.rotation = kVideoRotation_0; |
1603 EXPECT_TRUE(rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameDelta, | 1627 EXPECT_TRUE(rtp_sender_video_->SendVideo( |
1604 kPayload, kTimestamp + 1, 0, kFrame, | 1628 kRtpVideoGeneric, kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame, |
1605 sizeof(kFrame), nullptr, &hdr)); | 1629 sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); |
1606 | 1630 |
1607 VideoRotation rotation; | 1631 VideoRotation rotation; |
1608 EXPECT_TRUE( | 1632 EXPECT_TRUE( |
1609 transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation)); | 1633 transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation)); |
1610 EXPECT_EQ(kVideoRotation_0, rotation); | 1634 EXPECT_EQ(kVideoRotation_0, rotation); |
1611 } | 1635 } |
1612 | 1636 |
1613 TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) { | 1637 TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) { |
1614 uint8_t kFrame[kMaxPacketLength]; | 1638 uint8_t kFrame[kMaxPacketLength]; |
1615 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( | 1639 EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( |
1616 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); | 1640 kRtpExtensionVideoRotation, kVideoRotationExtensionId)); |
1617 | 1641 |
1618 RTPVideoHeader hdr = {0}; | 1642 RTPVideoHeader hdr = {0}; |
1619 hdr.rotation = kVideoRotation_90; | 1643 hdr.rotation = kVideoRotation_90; |
1620 EXPECT_TRUE(rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, | 1644 EXPECT_TRUE(rtp_sender_video_->SendVideo( |
1621 kPayload, kTimestamp, 0, kFrame, | 1645 kRtpVideoGeneric, kVideoFrameKey, kPayload, kTimestamp, 0, kFrame, |
1622 sizeof(kFrame), nullptr, &hdr)); | 1646 sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); |
1623 | 1647 |
1624 EXPECT_TRUE(rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameDelta, | 1648 EXPECT_TRUE(rtp_sender_video_->SendVideo( |
1625 kPayload, kTimestamp + 1, 0, kFrame, | 1649 kRtpVideoGeneric, kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame, |
1626 sizeof(kFrame), nullptr, &hdr)); | 1650 sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); |
1627 | 1651 |
1628 VideoRotation rotation; | 1652 VideoRotation rotation; |
1629 EXPECT_TRUE( | 1653 EXPECT_TRUE( |
1630 transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation)); | 1654 transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation)); |
1631 EXPECT_EQ(kVideoRotation_90, rotation); | 1655 EXPECT_EQ(kVideoRotation_90, rotation); |
1632 } | 1656 } |
1633 | 1657 |
1634 // Make sure rotation is parsed correctly when the Camera (C) and Flip (F) bits | 1658 // Make sure rotation is parsed correctly when the Camera (C) and Flip (F) bits |
1635 // are set in the CVO byte. | 1659 // are set in the CVO byte. |
1636 TEST_P(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) { | 1660 TEST_P(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) { |
1637 // Test extracting rotation when Camera (C) and Flip (F) bits are zero. | 1661 // Test extracting rotation when Camera (C) and Flip (F) bits are zero. |
1638 EXPECT_EQ(kVideoRotation_0, ConvertCVOByteToVideoRotation(0)); | 1662 EXPECT_EQ(kVideoRotation_0, ConvertCVOByteToVideoRotation(0)); |
1639 EXPECT_EQ(kVideoRotation_90, ConvertCVOByteToVideoRotation(1)); | 1663 EXPECT_EQ(kVideoRotation_90, ConvertCVOByteToVideoRotation(1)); |
1640 EXPECT_EQ(kVideoRotation_180, ConvertCVOByteToVideoRotation(2)); | 1664 EXPECT_EQ(kVideoRotation_180, ConvertCVOByteToVideoRotation(2)); |
1641 EXPECT_EQ(kVideoRotation_270, ConvertCVOByteToVideoRotation(3)); | 1665 EXPECT_EQ(kVideoRotation_270, ConvertCVOByteToVideoRotation(3)); |
1642 // Test extracting rotation when Camera (C) and Flip (F) bits are set. | 1666 // Test extracting rotation when Camera (C) and Flip (F) bits are set. |
1643 const int flip_bit = 1 << 2; | 1667 const int flip_bit = 1 << 2; |
1644 const int camera_bit = 1 << 3; | 1668 const int camera_bit = 1 << 3; |
1645 EXPECT_EQ(kVideoRotation_0, | 1669 EXPECT_EQ(kVideoRotation_0, |
1646 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0)); | 1670 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0)); |
1647 EXPECT_EQ(kVideoRotation_90, | 1671 EXPECT_EQ(kVideoRotation_90, |
1648 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1)); | 1672 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1)); |
1649 EXPECT_EQ(kVideoRotation_180, | 1673 EXPECT_EQ(kVideoRotation_180, |
1650 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2)); | 1674 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2)); |
1651 EXPECT_EQ(kVideoRotation_270, | 1675 EXPECT_EQ(kVideoRotation_270, |
1652 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3)); | 1676 ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3)); |
1653 } | 1677 } |
1654 | 1678 |
| 1679 TEST_P(RtpSenderVideoTest, RetransmissionTypesGeneric) { |
| 1680 RTPVideoHeader header; |
| 1681 header.codec = kRtpVideoGeneric; |
| 1682 |
| 1683 EXPECT_EQ(kDontRetransmit, |
| 1684 rtp_sender_video_->GetStorageType( |
| 1685 header, kRetransmitOff, kDefaultExpectedRetransmissionTimeMs)); |
| 1686 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1687 header, kRetransmitBaseLayer, |
| 1688 kDefaultExpectedRetransmissionTimeMs)); |
| 1689 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1690 header, kRetransmitHigherLayers, |
| 1691 kDefaultExpectedRetransmissionTimeMs)); |
| 1692 EXPECT_EQ(kAllowRetransmission, |
| 1693 rtp_sender_video_->GetStorageType( |
| 1694 header, kConditionallyRetransmitHigherLayers, |
| 1695 kDefaultExpectedRetransmissionTimeMs)); |
| 1696 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1697 header, kRetransmitAllPackets, |
| 1698 kDefaultExpectedRetransmissionTimeMs)); |
| 1699 } |
| 1700 |
| 1701 TEST_P(RtpSenderVideoTest, RetransmissionTypesH264) { |
| 1702 RTPVideoHeader header; |
| 1703 header.codec = kRtpVideoH264; |
| 1704 header.codecHeader.H264.packetization_mode = |
| 1705 H264PacketizationMode::NonInterleaved; |
| 1706 |
| 1707 EXPECT_EQ(kDontRetransmit, |
| 1708 rtp_sender_video_->GetStorageType( |
| 1709 header, kRetransmitOff, kDefaultExpectedRetransmissionTimeMs)); |
| 1710 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1711 header, kRetransmitBaseLayer, |
| 1712 kDefaultExpectedRetransmissionTimeMs)); |
| 1713 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1714 header, kRetransmitHigherLayers, |
| 1715 kDefaultExpectedRetransmissionTimeMs)); |
| 1716 EXPECT_EQ(kAllowRetransmission, |
| 1717 rtp_sender_video_->GetStorageType( |
| 1718 header, kConditionallyRetransmitHigherLayers, |
| 1719 kDefaultExpectedRetransmissionTimeMs)); |
| 1720 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1721 header, kRetransmitAllPackets, |
| 1722 kDefaultExpectedRetransmissionTimeMs)); |
| 1723 } |
| 1724 |
| 1725 TEST_P(RtpSenderVideoTest, RetransmissionTypesVP8BaseLayer) { |
| 1726 RTPVideoHeader header; |
| 1727 header.codec = kRtpVideoVp8; |
| 1728 header.codecHeader.VP8.temporalIdx = 0; |
| 1729 |
| 1730 EXPECT_EQ(kDontRetransmit, |
| 1731 rtp_sender_video_->GetStorageType( |
| 1732 header, kRetransmitOff, kDefaultExpectedRetransmissionTimeMs)); |
| 1733 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1734 header, kRetransmitBaseLayer, |
| 1735 kDefaultExpectedRetransmissionTimeMs)); |
| 1736 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType( |
| 1737 header, kRetransmitHigherLayers, |
| 1738 kDefaultExpectedRetransmissionTimeMs)); |
| 1739 EXPECT_EQ(kAllowRetransmission, |
| 1740 rtp_sender_video_->GetStorageType( |
| 1741 header, kRetransmitHigherLayers | kRetransmitBaseLayer, |
| 1742 kDefaultExpectedRetransmissionTimeMs)); |
| 1743 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType( |
| 1744 header, kConditionallyRetransmitHigherLayers, |
| 1745 kDefaultExpectedRetransmissionTimeMs)); |
| 1746 EXPECT_EQ( |
| 1747 kAllowRetransmission, |
| 1748 rtp_sender_video_->GetStorageType( |
| 1749 header, kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers, |
| 1750 kDefaultExpectedRetransmissionTimeMs)); |
| 1751 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1752 header, kRetransmitAllPackets, |
| 1753 kDefaultExpectedRetransmissionTimeMs)); |
| 1754 } |
| 1755 |
| 1756 TEST_P(RtpSenderVideoTest, RetransmissionTypesVP8HigherLayers) { |
| 1757 RTPVideoHeader header; |
| 1758 header.codec = kRtpVideoVp8; |
| 1759 |
| 1760 for (int tid = 1; tid <= kMaxTemporalStreams; ++tid) { |
| 1761 header.codecHeader.VP8.temporalIdx = tid; |
| 1762 |
| 1763 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType( |
| 1764 header, kRetransmitOff, |
| 1765 kDefaultExpectedRetransmissionTimeMs)); |
| 1766 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType( |
| 1767 header, kRetransmitBaseLayer, |
| 1768 kDefaultExpectedRetransmissionTimeMs)); |
| 1769 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1770 header, kRetransmitHigherLayers, |
| 1771 kDefaultExpectedRetransmissionTimeMs)); |
| 1772 EXPECT_EQ(kAllowRetransmission, |
| 1773 rtp_sender_video_->GetStorageType( |
| 1774 header, kRetransmitHigherLayers | kRetransmitBaseLayer, |
| 1775 kDefaultExpectedRetransmissionTimeMs)); |
| 1776 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1777 header, kRetransmitAllPackets, |
| 1778 kDefaultExpectedRetransmissionTimeMs)); |
| 1779 } |
| 1780 } |
| 1781 |
| 1782 TEST_P(RtpSenderVideoTest, RetransmissionTypesVP9) { |
| 1783 RTPVideoHeader header; |
| 1784 header.codec = kRtpVideoVp9; |
| 1785 |
| 1786 for (int tid = 1; tid <= kMaxTemporalStreams; ++tid) { |
| 1787 header.codecHeader.VP9.temporal_idx = tid; |
| 1788 |
| 1789 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType( |
| 1790 header, kRetransmitOff, |
| 1791 kDefaultExpectedRetransmissionTimeMs)); |
| 1792 EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType( |
| 1793 header, kRetransmitBaseLayer, |
| 1794 kDefaultExpectedRetransmissionTimeMs)); |
| 1795 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1796 header, kRetransmitHigherLayers, |
| 1797 kDefaultExpectedRetransmissionTimeMs)); |
| 1798 EXPECT_EQ(kAllowRetransmission, |
| 1799 rtp_sender_video_->GetStorageType( |
| 1800 header, kRetransmitHigherLayers | kRetransmitBaseLayer, |
| 1801 kDefaultExpectedRetransmissionTimeMs)); |
| 1802 EXPECT_EQ(kAllowRetransmission, rtp_sender_video_->GetStorageType( |
| 1803 header, kRetransmitAllPackets, |
| 1804 kDefaultExpectedRetransmissionTimeMs)); |
| 1805 } |
| 1806 } |
| 1807 |
| 1808 TEST_P(RtpSenderVideoTest, ConditionalRetransmit) { |
| 1809 const int64_t kFrameIntervalMs = 33; |
| 1810 const int64_t kRttMs = (kFrameIntervalMs * 3) / 2; |
| 1811 const uint8_t kSettings = |
| 1812 kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers; |
| 1813 |
| 1814 // Insert VP8 frames for all temporal layers, but stop before the final index. |
| 1815 RTPVideoHeader header; |
| 1816 header.codec = kRtpVideoVp8; |
| 1817 |
| 1818 // Fill averaging window to prevent rounding errors. |
| 1819 constexpr int kNumRepetitions = |
| 1820 (RTPSenderVideo::kTLRateWindowSizeMs + (kFrameIntervalMs / 2)) / |
| 1821 kFrameIntervalMs; |
| 1822 constexpr int kPattern[] = {0, 2, 1, 2}; |
| 1823 for (size_t i = 0; i < arraysize(kPattern) * kNumRepetitions; ++i) { |
| 1824 header.codecHeader.VP8.temporalIdx = kPattern[i % arraysize(kPattern)]; |
| 1825 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs); |
| 1826 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); |
| 1827 } |
| 1828 |
| 1829 // Since we're at the start of the pattern, the next expected frame in TL0 is |
| 1830 // right now. We will wait at most one expected retransmission time before |
| 1831 // acknowledging that it did not arrive, which means this frame and the next |
| 1832 // will not be retransmitted. |
| 1833 header.codecHeader.VP8.temporalIdx = 1; |
| 1834 EXPECT_EQ(StorageType::kDontRetransmit, |
| 1835 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs)); |
| 1836 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); |
| 1837 EXPECT_EQ(StorageType::kDontRetransmit, |
| 1838 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs)); |
| 1839 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); |
| 1840 |
| 1841 // The TL0 frame did not arrive. So allow retransmission. |
| 1842 EXPECT_EQ(StorageType::kAllowRetransmission, |
| 1843 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs)); |
| 1844 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); |
| 1845 |
| 1846 // Insert a frame for TL2. We just had frame in TL1, so the next one there is |
| 1847 // in three frames away. TL0 is still too far in the past. So, allow |
| 1848 // retransmission. |
| 1849 header.codecHeader.VP8.temporalIdx = 2; |
| 1850 EXPECT_EQ(StorageType::kAllowRetransmission, |
| 1851 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs)); |
| 1852 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); |
| 1853 |
| 1854 // Another TL2, next in TL1 is two frames away. Allow again. |
| 1855 EXPECT_EQ(StorageType::kAllowRetransmission, |
| 1856 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs)); |
| 1857 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); |
| 1858 |
| 1859 // Yet another TL2, next in TL1 is now only one frame away, so don't store |
| 1860 // for retransmission. |
| 1861 EXPECT_EQ(StorageType::kDontRetransmit, |
| 1862 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs)); |
| 1863 } |
| 1864 |
| 1865 TEST_P(RtpSenderVideoTest, ConditionalRetransmitLimit) { |
| 1866 const int64_t kFrameIntervalMs = 200; |
| 1867 const int64_t kRttMs = (kFrameIntervalMs * 3) / 2; |
| 1868 const int32_t kSettings = |
| 1869 kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers; |
| 1870 |
| 1871 // Insert VP8 frames for all temporal layers, but stop before the final index. |
| 1872 RTPVideoHeader header; |
| 1873 header.codec = kRtpVideoVp8; |
| 1874 |
| 1875 // Fill averaging window to prevent rounding errors. |
| 1876 constexpr int kNumRepetitions = |
| 1877 (RTPSenderVideo::kTLRateWindowSizeMs + (kFrameIntervalMs / 2)) / |
| 1878 kFrameIntervalMs; |
| 1879 constexpr int kPattern[] = {0, 2, 2, 2}; |
| 1880 for (size_t i = 0; i < arraysize(kPattern) * kNumRepetitions; ++i) { |
| 1881 header.codecHeader.VP8.temporalIdx = kPattern[i % arraysize(kPattern)]; |
| 1882 |
| 1883 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs); |
| 1884 fake_clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); |
| 1885 } |
| 1886 |
| 1887 // Since we're at the start of the pattern, the next expected frame will be |
| 1888 // right now in TL0. Put it in TL1 instead. Regular rules would dictate that |
| 1889 // we don't store for retransmission because we expect a frame in a lower |
| 1890 // layer, but that last frame in TL1 was a long time ago in absolute terms, |
| 1891 // so allow retransmission anyway. |
| 1892 header.codecHeader.VP8.temporalIdx = 1; |
| 1893 EXPECT_EQ(StorageType::kAllowRetransmission, |
| 1894 rtp_sender_video_->GetStorageType(header, kSettings, kRttMs)); |
| 1895 } |
| 1896 |
1655 TEST_P(RtpSenderTest, OnOverheadChanged) { | 1897 TEST_P(RtpSenderTest, OnOverheadChanged) { |
1656 MockOverheadObserver mock_overhead_observer; | 1898 MockOverheadObserver mock_overhead_observer; |
1657 rtp_sender_.reset( | 1899 rtp_sender_.reset( |
1658 new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, | 1900 new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, |
1659 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, | 1901 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, |
1660 &retransmission_rate_limiter_, &mock_overhead_observer)); | 1902 &retransmission_rate_limiter_, &mock_overhead_observer)); |
1661 rtp_sender_->SetSSRC(kSsrc); | 1903 rtp_sender_->SetSSRC(kSsrc); |
1662 | 1904 |
1663 // RTP overhead is 12B. | 1905 // RTP overhead is 12B. |
1664 EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(12)).Times(1); | 1906 EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(12)).Times(1); |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1753 INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead, | 1995 INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead, |
1754 RtpSenderTestWithoutPacer, | 1996 RtpSenderTestWithoutPacer, |
1755 ::testing::Bool()); | 1997 ::testing::Bool()); |
1756 INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead, | 1998 INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead, |
1757 RtpSenderVideoTest, | 1999 RtpSenderVideoTest, |
1758 ::testing::Bool()); | 2000 ::testing::Bool()); |
1759 INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead, | 2001 INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead, |
1760 RtpSenderAudioTest, | 2002 RtpSenderAudioTest, |
1761 ::testing::Bool()); | 2003 ::testing::Bool()); |
1762 } // namespace webrtc | 2004 } // namespace webrtc |
OLD | NEW |