1 /*
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
3 *
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
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include <iterator>
12 #include <list>
13 #include <memory>
14 #include <set>
15
16 #include "absl/algorithm/container.h"
17 #include "api/call/transport.h"
18 #include "api/transport/field_trial_based_config.h"
19 #include "call/rtp_stream_receiver_controller.h"
20 #include "call/rtx_receive_stream.h"
21 #include "modules/rtp_rtcp/include/receive_statistics.h"
22 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
23 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
24 #include "modules/rtp_rtcp/source/rtp_rtcp_impl2.h"
25 #include "modules/rtp_rtcp/source/rtp_sender_video.h"
26 #include "rtc_base/rate_limiter.h"
27 #include "test/gtest.h"
28
29 namespace webrtc {
30
31 const int kVideoNackListSize = 30;
32 const uint32_t kTestSsrc = 3456;
33 const uint32_t kTestRtxSsrc = kTestSsrc + 1;
34 const uint16_t kTestSequenceNumber = 2345;
35 const uint32_t kTestNumberOfPackets = 1350;
36 const int kTestNumberOfRtxPackets = 149;
37 const int kNumFrames = 30;
38 const int kPayloadType = 123;
39 const int kRtxPayloadType = 98;
40 const int64_t kMaxRttMs = 1000;
41
42 class VerifyingMediaStream : public RtpPacketSinkInterface {
43 public:
VerifyingMediaStream()44 VerifyingMediaStream() {}
45
OnRtpPacket(const RtpPacketReceived & packet)46 void OnRtpPacket(const RtpPacketReceived& packet) override {
47 if (!sequence_numbers_.empty())
48 EXPECT_EQ(kTestSsrc, packet.Ssrc());
49
50 sequence_numbers_.push_back(packet.SequenceNumber());
51 }
52 std::list<uint16_t> sequence_numbers_;
53 };
54
55 class RtxLoopBackTransport : public webrtc::Transport {
56 public:
RtxLoopBackTransport(uint32_t rtx_ssrc)57 explicit RtxLoopBackTransport(uint32_t rtx_ssrc)
58 : count_(0),
59 packet_loss_(0),
60 consecutive_drop_start_(0),
61 consecutive_drop_end_(0),
62 rtx_ssrc_(rtx_ssrc),
63 count_rtx_ssrc_(0),
64 module_(NULL) {}
65
SetSendModule(RtpRtcpInterface * rtpRtcpModule)66 void SetSendModule(RtpRtcpInterface* rtpRtcpModule) {
67 module_ = rtpRtcpModule;
68 }
69
DropEveryNthPacket(int n)70 void DropEveryNthPacket(int n) { packet_loss_ = n; }
71
DropConsecutivePackets(int start,int total)72 void DropConsecutivePackets(int start, int total) {
73 consecutive_drop_start_ = start;
74 consecutive_drop_end_ = start + total;
75 packet_loss_ = 0;
76 }
77
SendRtp(const uint8_t * data,size_t len,const PacketOptions & options)78 bool SendRtp(const uint8_t* data,
79 size_t len,
80 const PacketOptions& options) override {
81 count_++;
82 RtpPacketReceived packet;
83 if (!packet.Parse(data, len))
84 return false;
85 if (packet.Ssrc() == rtx_ssrc_) {
86 count_rtx_ssrc_++;
87 } else {
88 // For non-RTX packets only.
89 expected_sequence_numbers_.insert(expected_sequence_numbers_.end(),
90 packet.SequenceNumber());
91 }
92 if (packet_loss_ > 0) {
93 if ((count_ % packet_loss_) == 0) {
94 return true;
95 }
96 } else if (count_ >= consecutive_drop_start_ &&
97 count_ < consecutive_drop_end_) {
98 return true;
99 }
100 EXPECT_TRUE(stream_receiver_controller_.OnRtpPacket(packet));
101 return true;
102 }
103
SendRtcp(const uint8_t * data,size_t len)104 bool SendRtcp(const uint8_t* data, size_t len) override {
105 module_->IncomingRtcpPacket((const uint8_t*)data, len);
106 return true;
107 }
108 int count_;
109 int packet_loss_;
110 int consecutive_drop_start_;
111 int consecutive_drop_end_;
112 uint32_t rtx_ssrc_;
113 int count_rtx_ssrc_;
114 RtpRtcpInterface* module_;
115 RtpStreamReceiverController stream_receiver_controller_;
116 std::set<uint16_t> expected_sequence_numbers_;
117 };
118
119 class RtpRtcpRtxNackTest : public ::testing::Test {
120 protected:
RtpRtcpRtxNackTest()121 RtpRtcpRtxNackTest()
122 : rtp_rtcp_module_(nullptr),
123 transport_(kTestRtxSsrc),
124 rtx_stream_(&media_stream_, rtx_associated_payload_types_, kTestSsrc),
125 fake_clock(123456),
126 retransmission_rate_limiter_(&fake_clock, kMaxRttMs) {}
~RtpRtcpRtxNackTest()127 ~RtpRtcpRtxNackTest() override {}
128
SetUp()129 void SetUp() override {
130 RtpRtcpInterface::Configuration configuration;
131 configuration.audio = false;
132 configuration.clock = &fake_clock;
133 receive_statistics_ = ReceiveStatistics::Create(&fake_clock);
134 configuration.receive_statistics = receive_statistics_.get();
135 configuration.outgoing_transport = &transport_;
136 configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
137 configuration.local_media_ssrc = kTestSsrc;
138 configuration.rtx_send_ssrc = kTestRtxSsrc;
139 rtp_rtcp_module_ = ModuleRtpRtcpImpl2::Create(configuration);
140 FieldTrialBasedConfig field_trials;
141 RTPSenderVideo::Config video_config;
142 video_config.clock = &fake_clock;
143 video_config.rtp_sender = rtp_rtcp_module_->RtpSender();
144 video_config.field_trials = &field_trials;
145 rtp_sender_video_ = std::make_unique<RTPSenderVideo>(video_config);
146 rtp_rtcp_module_->SetRTCPStatus(RtcpMode::kCompound);
147 rtp_rtcp_module_->SetStorePacketsStatus(true, 600);
148 EXPECT_EQ(0, rtp_rtcp_module_->SetSendingStatus(true));
149 rtp_rtcp_module_->SetSequenceNumber(kTestSequenceNumber);
150 rtp_rtcp_module_->SetStartTimestamp(111111);
151
152 // Used for NACK processing.
153 // TODO(nisse): Unclear on which side? It's confusing to use a
154 // single rtp_rtcp module for both send and receive side.
155 rtp_rtcp_module_->SetRemoteSSRC(kTestSsrc);
156
157 rtp_rtcp_module_->SetRtxSendPayloadType(kRtxPayloadType, kPayloadType);
158 transport_.SetSendModule(rtp_rtcp_module_.get());
159 media_receiver_ = transport_.stream_receiver_controller_.CreateReceiver(
160 kTestSsrc, &media_stream_);
161
162 for (size_t n = 0; n < sizeof(payload_data); n++) {
163 payload_data[n] = n % 10;
164 }
165 }
166
BuildNackList(uint16_t * nack_list)167 int BuildNackList(uint16_t* nack_list) {
168 media_stream_.sequence_numbers_.sort();
169 std::list<uint16_t> missing_sequence_numbers;
170 std::list<uint16_t>::iterator it = media_stream_.sequence_numbers_.begin();
171
172 while (it != media_stream_.sequence_numbers_.end()) {
173 uint16_t sequence_number_1 = *it;
174 ++it;
175 if (it != media_stream_.sequence_numbers_.end()) {
176 uint16_t sequence_number_2 = *it;
177 // Add all missing sequence numbers to list
178 for (uint16_t i = sequence_number_1 + 1; i < sequence_number_2; ++i) {
179 missing_sequence_numbers.push_back(i);
180 }
181 }
182 }
183 int n = 0;
184 for (it = missing_sequence_numbers.begin();
185 it != missing_sequence_numbers.end(); ++it) {
186 nack_list[n++] = (*it);
187 }
188 return n;
189 }
190
ExpectedPacketsReceived()191 bool ExpectedPacketsReceived() {
192 std::list<uint16_t> received_sorted;
193 absl::c_copy(media_stream_.sequence_numbers_,
194 std::back_inserter(received_sorted));
195 received_sorted.sort();
196 return absl::c_equal(received_sorted,
197 transport_.expected_sequence_numbers_);
198 }
199
RunRtxTest(RtxMode rtx_method,int loss)200 void RunRtxTest(RtxMode rtx_method, int loss) {
201 rtx_receiver_ = transport_.stream_receiver_controller_.CreateReceiver(
202 kTestRtxSsrc, &rtx_stream_);
203 rtp_rtcp_module_->SetRtxSendStatus(rtx_method);
204 transport_.DropEveryNthPacket(loss);
205 uint32_t timestamp = 3000;
206 uint16_t nack_list[kVideoNackListSize];
207 for (int frame = 0; frame < kNumFrames; ++frame) {
208 RTPVideoHeader video_header;
209 EXPECT_TRUE(rtp_rtcp_module_->OnSendingRtpFrame(timestamp, timestamp / 90,
210 kPayloadType, false));
211 video_header.frame_type = VideoFrameType::kVideoFrameDelta;
212 EXPECT_TRUE(rtp_sender_video_->SendVideo(
213 kPayloadType, VideoCodecType::kVideoCodecGeneric, timestamp,
214 timestamp / 90, payload_data, video_header, 0));
215 // Min required delay until retransmit = 5 + RTT ms (RTT = 0).
216 fake_clock.AdvanceTimeMilliseconds(5);
217 int length = BuildNackList(nack_list);
218 if (length > 0)
219 rtp_rtcp_module_->SendNACK(nack_list, length);
220 fake_clock.AdvanceTimeMilliseconds(28); // 33ms - 5ms delay.
221 rtp_rtcp_module_->Process();
222 // Prepare next frame.
223 timestamp += 3000;
224 }
225 media_stream_.sequence_numbers_.sort();
226 }
227
228 std::unique_ptr<ReceiveStatistics> receive_statistics_;
229 std::unique_ptr<ModuleRtpRtcpImpl2> rtp_rtcp_module_;
230 std::unique_ptr<RTPSenderVideo> rtp_sender_video_;
231 RtxLoopBackTransport transport_;
232 const std::map<int, int> rtx_associated_payload_types_ = {
233 {kRtxPayloadType, kPayloadType}};
234 VerifyingMediaStream media_stream_;
235 RtxReceiveStream rtx_stream_;
236 uint8_t payload_data[65000];
237 SimulatedClock fake_clock;
238 RateLimiter retransmission_rate_limiter_;
239 std::unique_ptr<RtpStreamReceiverInterface> media_receiver_;
240 std::unique_ptr<RtpStreamReceiverInterface> rtx_receiver_;
241 };
242
TEST_F(RtpRtcpRtxNackTest,LongNackList)243 TEST_F(RtpRtcpRtxNackTest, LongNackList) {
244 const int kNumPacketsToDrop = 900;
245 const int kNumRequiredRtcp = 4;
246 uint32_t timestamp = 3000;
247 uint16_t nack_list[kNumPacketsToDrop];
248 // Disable StorePackets to be able to set a larger packet history.
249 rtp_rtcp_module_->SetStorePacketsStatus(false, 0);
250 // Enable StorePackets with a packet history of 2000 packets.
251 rtp_rtcp_module_->SetStorePacketsStatus(true, 2000);
252 // Drop 900 packets from the second one so that we get a NACK list which is
253 // big enough to require 4 RTCP packets to be fully transmitted to the sender.
254 transport_.DropConsecutivePackets(2, kNumPacketsToDrop);
255 // Send 30 frames which at the default size is roughly what we need to get
256 // enough packets.
257 for (int frame = 0; frame < kNumFrames; ++frame) {
258 RTPVideoHeader video_header;
259 EXPECT_TRUE(rtp_rtcp_module_->OnSendingRtpFrame(timestamp, timestamp / 90,
260 kPayloadType, false));
261 video_header.frame_type = VideoFrameType::kVideoFrameDelta;
262 EXPECT_TRUE(rtp_sender_video_->SendVideo(
263 kPayloadType, VideoCodecType::kVideoCodecGeneric, timestamp,
264 timestamp / 90, payload_data, video_header, 0));
265 // Prepare next frame.
266 timestamp += 3000;
267 fake_clock.AdvanceTimeMilliseconds(33);
268 rtp_rtcp_module_->Process();
269 }
270 EXPECT_FALSE(transport_.expected_sequence_numbers_.empty());
271 EXPECT_FALSE(media_stream_.sequence_numbers_.empty());
272 size_t last_receive_count = media_stream_.sequence_numbers_.size();
273 int length = BuildNackList(nack_list);
274 for (int i = 0; i < kNumRequiredRtcp - 1; ++i) {
275 rtp_rtcp_module_->SendNACK(nack_list, length);
276 EXPECT_GT(media_stream_.sequence_numbers_.size(), last_receive_count);
277 last_receive_count = media_stream_.sequence_numbers_.size();
278 EXPECT_FALSE(ExpectedPacketsReceived());
279 }
280 rtp_rtcp_module_->SendNACK(nack_list, length);
281 EXPECT_GT(media_stream_.sequence_numbers_.size(), last_receive_count);
282 EXPECT_TRUE(ExpectedPacketsReceived());
283 }
284
TEST_F(RtpRtcpRtxNackTest,RtxNack)285 TEST_F(RtpRtcpRtxNackTest, RtxNack) {
286 RunRtxTest(kRtxRetransmitted, 10);
287 EXPECT_EQ(kTestSequenceNumber, *(media_stream_.sequence_numbers_.begin()));
288 EXPECT_EQ(kTestSequenceNumber + kTestNumberOfPackets - 1,
289 *(media_stream_.sequence_numbers_.rbegin()));
290 EXPECT_EQ(kTestNumberOfPackets, media_stream_.sequence_numbers_.size());
291 EXPECT_EQ(kTestNumberOfRtxPackets, transport_.count_rtx_ssrc_);
292 EXPECT_TRUE(ExpectedPacketsReceived());
293 }
294
295 } // namespace webrtc
296