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