1 /*
2 * Copyright 2018 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 <memory>
12
13 #include "api/test/simulated_network.h"
14 #include "call/fake_network_pipe.h"
15 #include "call/simulated_network.h"
16 #include "modules/rtp_rtcp/source/rtp_packet.h"
17 #include "rtc_base/task_queue_for_test.h"
18 #include "test/call_test.h"
19 #include "test/gtest.h"
20 #include "test/rtcp_packet_parser.h"
21
22 namespace webrtc {
23 class SsrcEndToEndTest : public test::CallTest {
24 protected:
25 void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first);
26 };
27
TEST_F(SsrcEndToEndTest,ReceiverUsesLocalSsrc)28 TEST_F(SsrcEndToEndTest, ReceiverUsesLocalSsrc) {
29 class SyncRtcpObserver : public test::EndToEndTest {
30 public:
31 SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {}
32
33 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
34 test::RtcpPacketParser parser;
35 EXPECT_TRUE(parser.Parse(packet, length));
36 EXPECT_EQ(kReceiverLocalVideoSsrc, parser.sender_ssrc());
37 observation_complete_.Set();
38
39 return SEND_PACKET;
40 }
41
42 void PerformTest() override {
43 EXPECT_TRUE(Wait())
44 << "Timed out while waiting for a receiver RTCP packet to be sent.";
45 }
46 } test;
47
48 RunBaseTest(&test);
49 }
50
TEST_F(SsrcEndToEndTest,UnknownRtpPacketGivesUnknownSsrcReturnCode)51 TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
52 class PacketInputObserver : public PacketReceiver {
53 public:
54 explicit PacketInputObserver(PacketReceiver* receiver)
55 : receiver_(receiver) {}
56
57 bool Wait() { return delivered_packet_.Wait(kDefaultTimeoutMs); }
58
59 private:
60 DeliveryStatus DeliverPacket(MediaType media_type,
61 rtc::CopyOnWriteBuffer packet,
62 int64_t packet_time_us) override {
63 if (RtpHeaderParser::IsRtcp(packet.cdata(), packet.size())) {
64 return receiver_->DeliverPacket(media_type, std::move(packet),
65 packet_time_us);
66 }
67 DeliveryStatus delivery_status = receiver_->DeliverPacket(
68 media_type, std::move(packet), packet_time_us);
69 EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status);
70 delivered_packet_.Set();
71 return delivery_status;
72 }
73
74 PacketReceiver* receiver_;
75 rtc::Event delivered_packet_;
76 };
77
78 std::unique_ptr<test::DirectTransport> send_transport;
79 std::unique_ptr<test::DirectTransport> receive_transport;
80 std::unique_ptr<PacketInputObserver> input_observer;
81
82 SendTask(
83 RTC_FROM_HERE, task_queue(),
84 [this, &send_transport, &receive_transport, &input_observer]() {
85 CreateCalls();
86
87 send_transport = std::make_unique<test::DirectTransport>(
88 task_queue(),
89 std::make_unique<FakeNetworkPipe>(
90 Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
91 BuiltInNetworkBehaviorConfig())),
92 sender_call_.get(), payload_type_map_);
93 receive_transport = std::make_unique<test::DirectTransport>(
94 task_queue(),
95 std::make_unique<FakeNetworkPipe>(
96 Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
97 BuiltInNetworkBehaviorConfig())),
98 receiver_call_.get(), payload_type_map_);
99 input_observer =
100 std::make_unique<PacketInputObserver>(receiver_call_->Receiver());
101 send_transport->SetReceiver(input_observer.get());
102 receive_transport->SetReceiver(sender_call_->Receiver());
103
104 CreateSendConfig(1, 0, 0, send_transport.get());
105 CreateMatchingReceiveConfigs(receive_transport.get());
106
107 CreateVideoStreams();
108 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
109 kDefaultHeight);
110 Start();
111
112 receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]);
113 video_receive_streams_.clear();
114 });
115
116 // Wait() waits for a received packet.
117 EXPECT_TRUE(input_observer->Wait());
118
119 SendTask(RTC_FROM_HERE, task_queue(),
120 [this, &send_transport, &receive_transport]() {
121 Stop();
122 DestroyStreams();
123 send_transport.reset();
124 receive_transport.reset();
125 DestroyCalls();
126 });
127 }
128
TestSendsSetSsrcs(size_t num_ssrcs,bool send_single_ssrc_first)129 void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
130 bool send_single_ssrc_first) {
131 class SendsSetSsrcs : public test::EndToEndTest {
132 public:
133 SendsSetSsrcs(const uint32_t* ssrcs,
134 size_t num_ssrcs,
135 bool send_single_ssrc_first)
136 : EndToEndTest(kDefaultTimeoutMs),
137 num_ssrcs_(num_ssrcs),
138 send_single_ssrc_first_(send_single_ssrc_first),
139 ssrcs_to_observe_(num_ssrcs),
140 expect_single_ssrc_(send_single_ssrc_first),
141 send_stream_(nullptr) {
142 for (size_t i = 0; i < num_ssrcs; ++i)
143 valid_ssrcs_[ssrcs[i]] = true;
144 }
145
146 private:
147 Action OnSendRtp(const uint8_t* packet, size_t length) override {
148 RtpPacket rtp_packet;
149 EXPECT_TRUE(rtp_packet.Parse(packet, length));
150
151 EXPECT_TRUE(valid_ssrcs_[rtp_packet.Ssrc()])
152 << "Received unknown SSRC: " << rtp_packet.Ssrc();
153
154 if (!valid_ssrcs_[rtp_packet.Ssrc()])
155 observation_complete_.Set();
156
157 if (!is_observed_[rtp_packet.Ssrc()]) {
158 is_observed_[rtp_packet.Ssrc()] = true;
159 --ssrcs_to_observe_;
160 if (expect_single_ssrc_) {
161 expect_single_ssrc_ = false;
162 observation_complete_.Set();
163 }
164 }
165
166 if (ssrcs_to_observe_ == 0)
167 observation_complete_.Set();
168
169 return SEND_PACKET;
170 }
171
172 size_t GetNumVideoStreams() const override { return num_ssrcs_; }
173
174 // This test use other VideoStream settings than the the default settings
175 // implemented in DefaultVideoStreamFactory. Therefore this test implement
176 // its own VideoEncoderConfig::VideoStreamFactoryInterface which is created
177 // in ModifyVideoConfigs.
178 class VideoStreamFactory
179 : public VideoEncoderConfig::VideoStreamFactoryInterface {
180 public:
181 VideoStreamFactory() {}
182
183 private:
184 std::vector<VideoStream> CreateEncoderStreams(
185 int width,
186 int height,
187 const VideoEncoderConfig& encoder_config) override {
188 std::vector<VideoStream> streams =
189 test::CreateVideoStreams(width, height, encoder_config);
190 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
191 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
192 streams[i].min_bitrate_bps = 10000;
193 streams[i].target_bitrate_bps = 15000;
194 streams[i].max_bitrate_bps = 20000;
195 }
196 return streams;
197 }
198 };
199
200 void ModifyVideoConfigs(
201 VideoSendStream::Config* send_config,
202 std::vector<VideoReceiveStream::Config>* receive_configs,
203 VideoEncoderConfig* encoder_config) override {
204 encoder_config->video_stream_factory =
205 new rtc::RefCountedObject<VideoStreamFactory>();
206 video_encoder_config_all_streams_ = encoder_config->Copy();
207 if (send_single_ssrc_first_)
208 encoder_config->number_of_streams = 1;
209 }
210
211 void OnVideoStreamsCreated(
212 VideoSendStream* send_stream,
213 const std::vector<VideoReceiveStream*>& receive_streams) override {
214 send_stream_ = send_stream;
215 }
216
217 void PerformTest() override {
218 EXPECT_TRUE(Wait()) << "Timed out while waiting for "
219 << (send_single_ssrc_first_ ? "first SSRC."
220 : "SSRCs.");
221
222 if (send_single_ssrc_first_) {
223 // Set full simulcast and continue with the rest of the SSRCs.
224 send_stream_->ReconfigureVideoEncoder(
225 std::move(video_encoder_config_all_streams_));
226 EXPECT_TRUE(Wait()) << "Timed out while waiting on additional SSRCs.";
227 }
228 }
229
230 private:
231 std::map<uint32_t, bool> valid_ssrcs_;
232 std::map<uint32_t, bool> is_observed_;
233
234 const size_t num_ssrcs_;
235 const bool send_single_ssrc_first_;
236
237 size_t ssrcs_to_observe_;
238 bool expect_single_ssrc_;
239
240 VideoSendStream* send_stream_;
241 VideoEncoderConfig video_encoder_config_all_streams_;
242 } test(kVideoSendSsrcs, num_ssrcs, send_single_ssrc_first);
243
244 RunBaseTest(&test);
245 }
246
TEST_F(SsrcEndToEndTest,SendsSetSsrc)247 TEST_F(SsrcEndToEndTest, SendsSetSsrc) {
248 TestSendsSetSsrcs(1, false);
249 }
250
TEST_F(SsrcEndToEndTest,SendsSetSimulcastSsrcs)251 TEST_F(SsrcEndToEndTest, SendsSetSimulcastSsrcs) {
252 TestSendsSetSsrcs(kNumSimulcastStreams, false);
253 }
254
TEST_F(SsrcEndToEndTest,CanSwitchToUseAllSsrcs)255 TEST_F(SsrcEndToEndTest, CanSwitchToUseAllSsrcs) {
256 TestSendsSetSsrcs(kNumSimulcastStreams, true);
257 }
258
TEST_F(SsrcEndToEndTest,DISABLED_RedundantPayloadsTransmittedOnAllSsrcs)259 TEST_F(SsrcEndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
260 class ObserveRedundantPayloads : public test::EndToEndTest {
261 public:
262 ObserveRedundantPayloads()
263 : EndToEndTest(kDefaultTimeoutMs),
264 ssrcs_to_observe_(kNumSimulcastStreams) {
265 for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
266 registered_rtx_ssrc_[kSendRtxSsrcs[i]] = true;
267 }
268 }
269
270 private:
271 Action OnSendRtp(const uint8_t* packet, size_t length) override {
272 RtpPacket rtp_packet;
273 EXPECT_TRUE(rtp_packet.Parse(packet, length));
274
275 if (!registered_rtx_ssrc_[rtp_packet.Ssrc()])
276 return SEND_PACKET;
277
278 const bool packet_is_redundant_payload = rtp_packet.payload_size() > 0;
279
280 if (!packet_is_redundant_payload)
281 return SEND_PACKET;
282
283 if (!observed_redundant_retransmission_[rtp_packet.Ssrc()]) {
284 observed_redundant_retransmission_[rtp_packet.Ssrc()] = true;
285 if (--ssrcs_to_observe_ == 0)
286 observation_complete_.Set();
287 }
288
289 return SEND_PACKET;
290 }
291
292 size_t GetNumVideoStreams() const override { return kNumSimulcastStreams; }
293
294 void ModifyVideoConfigs(
295 VideoSendStream::Config* send_config,
296 std::vector<VideoReceiveStream::Config>* receive_configs,
297 VideoEncoderConfig* encoder_config) override {
298 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
299 encoder_config->max_bitrate_bps = 50000;
300 for (auto& layer : encoder_config->simulcast_layers) {
301 layer.min_bitrate_bps = 10000;
302 layer.target_bitrate_bps = 15000;
303 layer.max_bitrate_bps = 20000;
304 }
305 send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
306
307 for (size_t i = 0; i < kNumSimulcastStreams; ++i)
308 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
309
310 // Significantly higher than max bitrates for all video streams -> forcing
311 // padding to trigger redundant padding on all RTX SSRCs.
312 encoder_config->min_transmit_bitrate_bps = 100000;
313 }
314
315 void PerformTest() override {
316 EXPECT_TRUE(Wait())
317 << "Timed out while waiting for redundant payloads on all SSRCs.";
318 }
319
320 private:
321 size_t ssrcs_to_observe_;
322 std::map<uint32_t, bool> observed_redundant_retransmission_;
323 std::map<uint32_t, bool> registered_rtx_ssrc_;
324 } test;
325
326 RunBaseTest(&test);
327 }
328 } // namespace webrtc
329