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