1 /*
2 * Copyright 2019 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 #include <ostream> // no-presubmit-check TODO(webrtc:8982)
13
14 #include "absl/algorithm/container.h"
15 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
16 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
17 #include "api/create_peerconnection_factory.h"
18 #include "api/media_types.h"
19 #include "api/rtc_error.h"
20 #include "api/rtp_transceiver_interface.h"
21 #include "api/uma_metrics.h"
22 #include "api/video_codecs/builtin_video_decoder_factory.h"
23 #include "api/video_codecs/builtin_video_encoder_factory.h"
24 #include "pc/peer_connection.h"
25 #include "pc/peer_connection_wrapper.h"
26 #include "pc/test/fake_audio_capture_module.h"
27 #include "pc/test/mock_peer_connection_observers.h"
28 #include "rtc_base/gunit.h"
29 #include "system_wrappers/include/metrics.h"
30 #include "test/gmock.h"
31
32 using ::testing::Contains;
33 using ::testing::Each;
34 using ::testing::ElementsAre;
35 using ::testing::ElementsAreArray;
36 using ::testing::Eq;
37 using ::testing::Field;
38 using ::testing::IsEmpty;
39 using ::testing::Ne;
40 using ::testing::Pair;
41 using ::testing::Property;
42 using ::testing::SizeIs;
43
44 using cricket::MediaContentDescription;
45 using cricket::RidDescription;
46 using cricket::SimulcastDescription;
47 using cricket::SimulcastLayer;
48 using cricket::StreamParams;
49
50 namespace cricket {
51
operator <<(std::ostream & os,const SimulcastLayer & layer)52 std::ostream& operator<<( // no-presubmit-check TODO(webrtc:8982)
53 std::ostream& os, // no-presubmit-check TODO(webrtc:8982)
54 const SimulcastLayer& layer) {
55 if (layer.is_paused) {
56 os << "~";
57 }
58 return os << layer.rid;
59 }
60
61 } // namespace cricket
62
63 namespace {
64
CreateLayers(const std::vector<std::string> & rids,const std::vector<bool> & active)65 std::vector<SimulcastLayer> CreateLayers(const std::vector<std::string>& rids,
66 const std::vector<bool>& active) {
67 RTC_DCHECK_EQ(rids.size(), active.size());
68 std::vector<SimulcastLayer> result;
69 absl::c_transform(rids, active, std::back_inserter(result),
70 [](const std::string& rid, bool is_active) {
71 return SimulcastLayer(rid, !is_active);
72 });
73 return result;
74 }
CreateLayers(const std::vector<std::string> & rids,bool active)75 std::vector<SimulcastLayer> CreateLayers(const std::vector<std::string>& rids,
76 bool active) {
77 return CreateLayers(rids, std::vector<bool>(rids.size(), active));
78 }
79
80 #if RTC_METRICS_ENABLED
CreateLayers(int num_layers,bool active)81 std::vector<SimulcastLayer> CreateLayers(int num_layers, bool active) {
82 rtc::UniqueStringGenerator rid_generator;
83 std::vector<std::string> rids;
84 for (int i = 0; i < num_layers; ++i) {
85 rids.push_back(rid_generator());
86 }
87 return CreateLayers(rids, active);
88 }
89 #endif
90
91 } // namespace
92
93 namespace webrtc {
94
95 class PeerConnectionSimulcastTests : public ::testing::Test {
96 public:
PeerConnectionSimulcastTests()97 PeerConnectionSimulcastTests()
98 : pc_factory_(
99 CreatePeerConnectionFactory(rtc::Thread::Current(),
100 rtc::Thread::Current(),
101 rtc::Thread::Current(),
102 FakeAudioCaptureModule::Create(),
103 CreateBuiltinAudioEncoderFactory(),
104 CreateBuiltinAudioDecoderFactory(),
105 CreateBuiltinVideoEncoderFactory(),
106 CreateBuiltinVideoDecoderFactory(),
107 nullptr,
108 nullptr)) {}
109
CreatePeerConnection(MockPeerConnectionObserver * observer)110 rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
111 MockPeerConnectionObserver* observer) {
112 PeerConnectionInterface::RTCConfiguration config;
113 config.sdp_semantics = SdpSemantics::kUnifiedPlan;
114 PeerConnectionDependencies pcd(observer);
115 auto pc = pc_factory_->CreatePeerConnection(config, std::move(pcd));
116 EXPECT_TRUE(pc);
117 observer->SetPeerConnectionInterface(pc);
118 return pc;
119 }
120
CreatePeerConnectionWrapper()121 std::unique_ptr<PeerConnectionWrapper> CreatePeerConnectionWrapper() {
122 auto observer = std::make_unique<MockPeerConnectionObserver>();
123 auto pc = CreatePeerConnection(observer.get());
124 return std::make_unique<PeerConnectionWrapper>(pc_factory_, pc,
125 std::move(observer));
126 }
127
ExchangeOfferAnswer(PeerConnectionWrapper * local,PeerConnectionWrapper * remote,const std::vector<SimulcastLayer> & answer_layers)128 void ExchangeOfferAnswer(PeerConnectionWrapper* local,
129 PeerConnectionWrapper* remote,
130 const std::vector<SimulcastLayer>& answer_layers) {
131 auto offer = local->CreateOfferAndSetAsLocal();
132 // Remove simulcast as the second peer connection won't support it.
133 RemoveSimulcast(offer.get());
134 std::string err;
135 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &err)) << err;
136 auto answer = remote->CreateAnswerAndSetAsLocal();
137 // Setup the answer to look like a server response.
138 auto mcd_answer = answer->description()->contents()[0].media_description();
139 auto& receive_layers = mcd_answer->simulcast_description().receive_layers();
140 for (const SimulcastLayer& layer : answer_layers) {
141 receive_layers.AddLayer(layer);
142 }
143 EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &err)) << err;
144 }
145
CreateTransceiverInit(const std::vector<SimulcastLayer> & layers)146 RtpTransceiverInit CreateTransceiverInit(
147 const std::vector<SimulcastLayer>& layers) {
148 RtpTransceiverInit init;
149 for (const SimulcastLayer& layer : layers) {
150 RtpEncodingParameters encoding;
151 encoding.rid = layer.rid;
152 encoding.active = !layer.is_paused;
153 init.send_encodings.push_back(encoding);
154 }
155 return init;
156 }
157
AddTransceiver(PeerConnectionWrapper * pc,const std::vector<SimulcastLayer> & layers)158 rtc::scoped_refptr<RtpTransceiverInterface> AddTransceiver(
159 PeerConnectionWrapper* pc,
160 const std::vector<SimulcastLayer>& layers) {
161 auto init = CreateTransceiverInit(layers);
162 return pc->AddTransceiver(cricket::MEDIA_TYPE_VIDEO, init);
163 }
164
RemoveSimulcast(SessionDescriptionInterface * sd)165 SimulcastDescription RemoveSimulcast(SessionDescriptionInterface* sd) {
166 auto mcd = sd->description()->contents()[0].media_description();
167 auto result = mcd->simulcast_description();
168 mcd->set_simulcast_description(SimulcastDescription());
169 return result;
170 }
171
AddRequestToReceiveSimulcast(const std::vector<SimulcastLayer> & layers,SessionDescriptionInterface * sd)172 void AddRequestToReceiveSimulcast(const std::vector<SimulcastLayer>& layers,
173 SessionDescriptionInterface* sd) {
174 auto mcd = sd->description()->contents()[0].media_description();
175 SimulcastDescription simulcast;
176 auto& receive_layers = simulcast.receive_layers();
177 for (const SimulcastLayer& layer : layers) {
178 receive_layers.AddLayer(layer);
179 }
180 mcd->set_simulcast_description(simulcast);
181 }
182
ValidateTransceiverParameters(rtc::scoped_refptr<RtpTransceiverInterface> transceiver,const std::vector<SimulcastLayer> & layers)183 void ValidateTransceiverParameters(
184 rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
185 const std::vector<SimulcastLayer>& layers) {
186 auto parameters = transceiver->sender()->GetParameters();
187 std::vector<SimulcastLayer> result_layers;
188 absl::c_transform(parameters.encodings, std::back_inserter(result_layers),
189 [](const RtpEncodingParameters& encoding) {
190 return SimulcastLayer(encoding.rid, !encoding.active);
191 });
192 EXPECT_THAT(result_layers, ElementsAreArray(layers));
193 }
194
195 private:
196 rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
197 };
198
199 #if RTC_METRICS_ENABLED
200 // This class is used to test the metrics emitted for simulcast.
201 class PeerConnectionSimulcastMetricsTests
202 : public PeerConnectionSimulcastTests,
203 public ::testing::WithParamInterface<int> {
204 protected:
PeerConnectionSimulcastMetricsTests()205 PeerConnectionSimulcastMetricsTests() { webrtc::metrics::Reset(); }
206
LocalDescriptionSamples()207 std::map<int, int> LocalDescriptionSamples() {
208 return metrics::Samples(
209 "WebRTC.PeerConnection.Simulcast.ApplyLocalDescription");
210 }
RemoteDescriptionSamples()211 std::map<int, int> RemoteDescriptionSamples() {
212 return metrics::Samples(
213 "WebRTC.PeerConnection.Simulcast.ApplyRemoteDescription");
214 }
215 };
216 #endif
217
218 // Validates that RIDs are supported arguments when adding a transceiver.
TEST_F(PeerConnectionSimulcastTests,CanCreateTransceiverWithRid)219 TEST_F(PeerConnectionSimulcastTests, CanCreateTransceiverWithRid) {
220 auto pc = CreatePeerConnectionWrapper();
221 auto layers = CreateLayers({"f"}, true);
222 auto transceiver = AddTransceiver(pc.get(), layers);
223 ASSERT_TRUE(transceiver);
224 auto parameters = transceiver->sender()->GetParameters();
225 // Single RID should be removed.
226 EXPECT_THAT(parameters.encodings,
227 ElementsAre(Field("rid", &RtpEncodingParameters::rid, Eq(""))));
228 }
229
TEST_F(PeerConnectionSimulcastTests,CanCreateTransceiverWithSimulcast)230 TEST_F(PeerConnectionSimulcastTests, CanCreateTransceiverWithSimulcast) {
231 auto pc = CreatePeerConnectionWrapper();
232 auto layers = CreateLayers({"f", "h", "q"}, true);
233 auto transceiver = AddTransceiver(pc.get(), layers);
234 ASSERT_TRUE(transceiver);
235 ValidateTransceiverParameters(transceiver, layers);
236 }
237
TEST_F(PeerConnectionSimulcastTests,RidsAreAutogeneratedIfNotProvided)238 TEST_F(PeerConnectionSimulcastTests, RidsAreAutogeneratedIfNotProvided) {
239 auto pc = CreatePeerConnectionWrapper();
240 auto init = CreateTransceiverInit(CreateLayers({"f", "h", "q"}, true));
241 for (RtpEncodingParameters& parameters : init.send_encodings) {
242 parameters.rid = "";
243 }
244 auto transceiver = pc->AddTransceiver(cricket::MEDIA_TYPE_VIDEO, init);
245 auto parameters = transceiver->sender()->GetParameters();
246 ASSERT_EQ(3u, parameters.encodings.size());
247 EXPECT_THAT(parameters.encodings,
248 Each(Field("rid", &RtpEncodingParameters::rid, Ne(""))));
249 }
250
251 // Validates that an error is returned when there is a mix of supplied and not
252 // supplied RIDs in a call to AddTransceiver.
TEST_F(PeerConnectionSimulcastTests,MustSupplyAllOrNoRidsInSimulcast)253 TEST_F(PeerConnectionSimulcastTests, MustSupplyAllOrNoRidsInSimulcast) {
254 auto pc_wrapper = CreatePeerConnectionWrapper();
255 auto pc = pc_wrapper->pc();
256 // Cannot create a layer with empty RID. Remove the RID after init is created.
257 auto layers = CreateLayers({"f", "h", "remove"}, true);
258 auto init = CreateTransceiverInit(layers);
259 init.send_encodings[2].rid = "";
260 auto error = pc->AddTransceiver(cricket::MEDIA_TYPE_VIDEO, init);
261 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, error.error().type());
262 }
263
264 // Validates that an error is returned when illegal RIDs are supplied.
TEST_F(PeerConnectionSimulcastTests,ChecksForIllegalRidValues)265 TEST_F(PeerConnectionSimulcastTests, ChecksForIllegalRidValues) {
266 auto pc_wrapper = CreatePeerConnectionWrapper();
267 auto pc = pc_wrapper->pc();
268 auto layers = CreateLayers({"f", "h", "~q"}, true);
269 auto init = CreateTransceiverInit(layers);
270 auto error = pc->AddTransceiver(cricket::MEDIA_TYPE_VIDEO, init);
271 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, error.error().type());
272 }
273
274 // Validates that a single RID is removed from the encoding layer.
TEST_F(PeerConnectionSimulcastTests,SingleRidIsRemovedFromSessionDescription)275 TEST_F(PeerConnectionSimulcastTests, SingleRidIsRemovedFromSessionDescription) {
276 auto pc = CreatePeerConnectionWrapper();
277 auto transceiver = AddTransceiver(pc.get(), CreateLayers({"1"}, true));
278 auto offer = pc->CreateOfferAndSetAsLocal();
279 ASSERT_TRUE(offer);
280 auto contents = offer->description()->contents();
281 ASSERT_EQ(1u, contents.size());
282 EXPECT_THAT(contents[0].media_description()->streams(),
283 ElementsAre(Property(&StreamParams::has_rids, false)));
284 }
285
TEST_F(PeerConnectionSimulcastTests,SimulcastLayersRemovedFromTail)286 TEST_F(PeerConnectionSimulcastTests, SimulcastLayersRemovedFromTail) {
287 static_assert(
288 kMaxSimulcastStreams < 8,
289 "Test assumes that the platform does not allow 8 simulcast layers");
290 auto pc = CreatePeerConnectionWrapper();
291 auto layers = CreateLayers({"1", "2", "3", "4", "5", "6", "7", "8"}, true);
292 std::vector<SimulcastLayer> expected_layers;
293 std::copy_n(layers.begin(), kMaxSimulcastStreams,
294 std::back_inserter(expected_layers));
295 auto transceiver = AddTransceiver(pc.get(), layers);
296 ValidateTransceiverParameters(transceiver, expected_layers);
297 }
298
299 // Checks that an offfer to send simulcast contains a SimulcastDescription.
TEST_F(PeerConnectionSimulcastTests,SimulcastAppearsInSessionDescription)300 TEST_F(PeerConnectionSimulcastTests, SimulcastAppearsInSessionDescription) {
301 auto pc = CreatePeerConnectionWrapper();
302 std::vector<std::string> rids({"f", "h", "q"});
303 auto layers = CreateLayers(rids, true);
304 auto transceiver = AddTransceiver(pc.get(), layers);
305 auto offer = pc->CreateOffer();
306 ASSERT_TRUE(offer);
307 auto contents = offer->description()->contents();
308 ASSERT_EQ(1u, contents.size());
309 auto content = contents[0];
310 auto mcd = content.media_description();
311 ASSERT_TRUE(mcd->HasSimulcast());
312 auto simulcast = mcd->simulcast_description();
313 EXPECT_THAT(simulcast.receive_layers(), IsEmpty());
314 // The size is validated separately because GetAllLayers() flattens the list.
315 EXPECT_THAT(simulcast.send_layers(), SizeIs(3));
316 std::vector<SimulcastLayer> result = simulcast.send_layers().GetAllLayers();
317 EXPECT_THAT(result, ElementsAreArray(layers));
318 auto streams = mcd->streams();
319 ASSERT_EQ(1u, streams.size());
320 auto stream = streams[0];
321 EXPECT_FALSE(stream.has_ssrcs());
322 EXPECT_TRUE(stream.has_rids());
323 std::vector<std::string> result_rids;
324 absl::c_transform(stream.rids(), std::back_inserter(result_rids),
325 [](const RidDescription& rid) { return rid.rid; });
326 EXPECT_THAT(result_rids, ElementsAreArray(rids));
327 }
328
329 // Checks that Simulcast layers propagate to the sender parameters.
TEST_F(PeerConnectionSimulcastTests,SimulcastLayersAreSetInSender)330 TEST_F(PeerConnectionSimulcastTests, SimulcastLayersAreSetInSender) {
331 auto local = CreatePeerConnectionWrapper();
332 auto remote = CreatePeerConnectionWrapper();
333 auto layers = CreateLayers({"f", "h", "q"}, true);
334 auto transceiver = AddTransceiver(local.get(), layers);
335 auto offer = local->CreateOfferAndSetAsLocal();
336 {
337 SCOPED_TRACE("after create offer");
338 ValidateTransceiverParameters(transceiver, layers);
339 }
340 // Remove simulcast as the second peer connection won't support it.
341 auto simulcast = RemoveSimulcast(offer.get());
342 std::string error;
343 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
344 auto answer = remote->CreateAnswerAndSetAsLocal();
345
346 // Setup an answer that mimics a server accepting simulcast.
347 auto mcd_answer = answer->description()->contents()[0].media_description();
348 mcd_answer->mutable_streams().clear();
349 auto simulcast_layers = simulcast.send_layers().GetAllLayers();
350 auto& receive_layers = mcd_answer->simulcast_description().receive_layers();
351 for (const auto& layer : simulcast_layers) {
352 receive_layers.AddLayer(layer);
353 }
354 EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &error)) << error;
355 {
356 SCOPED_TRACE("after set remote");
357 ValidateTransceiverParameters(transceiver, layers);
358 }
359 }
360
361 // Checks that paused Simulcast layers propagate to the sender parameters.
TEST_F(PeerConnectionSimulcastTests,PausedSimulcastLayersAreDisabledInSender)362 TEST_F(PeerConnectionSimulcastTests, PausedSimulcastLayersAreDisabledInSender) {
363 auto local = CreatePeerConnectionWrapper();
364 auto remote = CreatePeerConnectionWrapper();
365 auto layers = CreateLayers({"f", "h", "q"}, {true, false, true});
366 auto server_layers = CreateLayers({"f", "h", "q"}, {true, false, false});
367 RTC_DCHECK_EQ(layers.size(), server_layers.size());
368 auto transceiver = AddTransceiver(local.get(), layers);
369 auto offer = local->CreateOfferAndSetAsLocal();
370 {
371 SCOPED_TRACE("after create offer");
372 ValidateTransceiverParameters(transceiver, layers);
373 }
374
375 // Remove simulcast as the second peer connection won't support it.
376 RemoveSimulcast(offer.get());
377 std::string error;
378 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
379 auto answer = remote->CreateAnswerAndSetAsLocal();
380
381 // Setup an answer that mimics a server accepting simulcast.
382 auto mcd_answer = answer->description()->contents()[0].media_description();
383 mcd_answer->mutable_streams().clear();
384 auto& receive_layers = mcd_answer->simulcast_description().receive_layers();
385 for (const SimulcastLayer& layer : server_layers) {
386 receive_layers.AddLayer(layer);
387 }
388 EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &error)) << error;
389 {
390 SCOPED_TRACE("after set remote");
391 ValidateTransceiverParameters(transceiver, server_layers);
392 }
393 }
394
395 // Checks that when Simulcast is not supported by the remote party, then all
396 // the layers (except the first) are removed.
TEST_F(PeerConnectionSimulcastTests,SimulcastRejectedRemovesExtraLayers)397 TEST_F(PeerConnectionSimulcastTests, SimulcastRejectedRemovesExtraLayers) {
398 auto local = CreatePeerConnectionWrapper();
399 auto remote = CreatePeerConnectionWrapper();
400 auto layers = CreateLayers({"1", "2", "3", "4"}, true);
401 auto transceiver = AddTransceiver(local.get(), layers);
402 ExchangeOfferAnswer(local.get(), remote.get(), {});
403 auto parameters = transceiver->sender()->GetParameters();
404 // Should only have the first layer.
405 EXPECT_THAT(parameters.encodings,
406 ElementsAre(Field("rid", &RtpEncodingParameters::rid, Eq("1"))));
407 }
408
409 // Checks that if Simulcast is supported by remote party, but some layers are
410 // rejected, then only rejected layers are removed from the sender.
TEST_F(PeerConnectionSimulcastTests,RejectedSimulcastLayersAreDeactivated)411 TEST_F(PeerConnectionSimulcastTests, RejectedSimulcastLayersAreDeactivated) {
412 auto local = CreatePeerConnectionWrapper();
413 auto remote = CreatePeerConnectionWrapper();
414 auto layers = CreateLayers({"1", "2", "3"}, true);
415 auto expected_layers = CreateLayers({"2", "3"}, true);
416 auto transceiver = AddTransceiver(local.get(), layers);
417 auto offer = local->CreateOfferAndSetAsLocal();
418 {
419 SCOPED_TRACE("after create offer");
420 ValidateTransceiverParameters(transceiver, layers);
421 }
422 // Remove simulcast as the second peer connection won't support it.
423 auto removed_simulcast = RemoveSimulcast(offer.get());
424 std::string error;
425 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
426 auto answer = remote->CreateAnswerAndSetAsLocal();
427 auto mcd_answer = answer->description()->contents()[0].media_description();
428 // Setup the answer to look like a server response.
429 // Remove one of the layers to reject it in the answer.
430 auto simulcast_layers = removed_simulcast.send_layers().GetAllLayers();
431 simulcast_layers.erase(simulcast_layers.begin());
432 auto& receive_layers = mcd_answer->simulcast_description().receive_layers();
433 for (const auto& layer : simulcast_layers) {
434 receive_layers.AddLayer(layer);
435 }
436 ASSERT_TRUE(mcd_answer->HasSimulcast());
437 EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &error)) << error;
438 {
439 SCOPED_TRACE("after set remote");
440 ValidateTransceiverParameters(transceiver, expected_layers);
441 }
442 }
443
444 // Checks that simulcast is set up correctly when the server sends an offer
445 // requesting to receive simulcast.
TEST_F(PeerConnectionSimulcastTests,ServerSendsOfferToReceiveSimulcast)446 TEST_F(PeerConnectionSimulcastTests, ServerSendsOfferToReceiveSimulcast) {
447 auto local = CreatePeerConnectionWrapper();
448 auto remote = CreatePeerConnectionWrapper();
449 auto layers = CreateLayers({"f", "h", "q"}, true);
450 AddTransceiver(local.get(), layers);
451 auto offer = local->CreateOfferAndSetAsLocal();
452 // Remove simulcast as a sender and set it up as a receiver.
453 RemoveSimulcast(offer.get());
454 AddRequestToReceiveSimulcast(layers, offer.get());
455 std::string error;
456 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
457 auto transceiver = remote->pc()->GetTransceivers()[0];
458 transceiver->SetDirectionWithError(RtpTransceiverDirection::kSendRecv);
459 EXPECT_TRUE(remote->CreateAnswerAndSetAsLocal());
460 ValidateTransceiverParameters(transceiver, layers);
461 }
462
463 // Checks that SetRemoteDescription doesn't attempt to associate a transceiver
464 // when simulcast is requested by the server.
TEST_F(PeerConnectionSimulcastTests,TransceiverIsNotRecycledWithSimulcast)465 TEST_F(PeerConnectionSimulcastTests, TransceiverIsNotRecycledWithSimulcast) {
466 auto local = CreatePeerConnectionWrapper();
467 auto remote = CreatePeerConnectionWrapper();
468 auto layers = CreateLayers({"f", "h", "q"}, true);
469 AddTransceiver(local.get(), layers);
470 auto offer = local->CreateOfferAndSetAsLocal();
471 // Remove simulcast as a sender and set it up as a receiver.
472 RemoveSimulcast(offer.get());
473 AddRequestToReceiveSimulcast(layers, offer.get());
474 // Call AddTrack so that a transceiver is created.
475 remote->AddVideoTrack("fake_track");
476 std::string error;
477 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
478 auto transceivers = remote->pc()->GetTransceivers();
479 ASSERT_EQ(2u, transceivers.size());
480 auto transceiver = transceivers[1];
481 transceiver->SetDirectionWithError(RtpTransceiverDirection::kSendRecv);
482 EXPECT_TRUE(remote->CreateAnswerAndSetAsLocal());
483 ValidateTransceiverParameters(transceiver, layers);
484 }
485
486 // Checks that if the number of layers changes during negotiation, then any
487 // outstanding get/set parameters transaction is invalidated.
TEST_F(PeerConnectionSimulcastTests,ParametersAreInvalidatedWhenLayersChange)488 TEST_F(PeerConnectionSimulcastTests, ParametersAreInvalidatedWhenLayersChange) {
489 auto local = CreatePeerConnectionWrapper();
490 auto remote = CreatePeerConnectionWrapper();
491 auto layers = CreateLayers({"1", "2", "3"}, true);
492 auto transceiver = AddTransceiver(local.get(), layers);
493 auto parameters = transceiver->sender()->GetParameters();
494 ASSERT_EQ(3u, parameters.encodings.size());
495 // Response will reject simulcast altogether.
496 ExchangeOfferAnswer(local.get(), remote.get(), {});
497 auto result = transceiver->sender()->SetParameters(parameters);
498 EXPECT_EQ(RTCErrorType::INVALID_STATE, result.type());
499 }
500
501 // Checks that even though negotiation modifies the sender's parameters, an
502 // outstanding get/set parameters transaction is not invalidated.
503 // This test negotiates twice because initial parameters before negotiation
504 // is missing critical information and cannot be set on the sender.
TEST_F(PeerConnectionSimulcastTests,NegotiationDoesNotInvalidateParameterTransactions)505 TEST_F(PeerConnectionSimulcastTests,
506 NegotiationDoesNotInvalidateParameterTransactions) {
507 auto local = CreatePeerConnectionWrapper();
508 auto remote = CreatePeerConnectionWrapper();
509 auto layers = CreateLayers({"1", "2", "3"}, true);
510 auto expected_layers = CreateLayers({"1", "2", "3"}, false);
511 auto transceiver = AddTransceiver(local.get(), layers);
512 ExchangeOfferAnswer(local.get(), remote.get(), expected_layers);
513
514 // Verify that negotiation does not invalidate the parameters.
515 auto parameters = transceiver->sender()->GetParameters();
516 ExchangeOfferAnswer(local.get(), remote.get(), expected_layers);
517
518 auto result = transceiver->sender()->SetParameters(parameters);
519 EXPECT_TRUE(result.ok());
520 ValidateTransceiverParameters(transceiver, expected_layers);
521 }
522
523 // Tests that simulcast is disabled if the RID extension is not negotiated
524 // regardless of if the RIDs and simulcast attribute were negotiated properly.
TEST_F(PeerConnectionSimulcastTests,NegotiationDoesNotHaveRidExtension)525 TEST_F(PeerConnectionSimulcastTests, NegotiationDoesNotHaveRidExtension) {
526 auto local = CreatePeerConnectionWrapper();
527 auto remote = CreatePeerConnectionWrapper();
528 auto layers = CreateLayers({"1", "2", "3"}, true);
529 auto expected_layers = CreateLayers({"1"}, true);
530 auto transceiver = AddTransceiver(local.get(), layers);
531 auto offer = local->CreateOfferAndSetAsLocal();
532 // Remove simulcast as the second peer connection won't support it.
533 RemoveSimulcast(offer.get());
534 std::string err;
535 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &err)) << err;
536 auto answer = remote->CreateAnswerAndSetAsLocal();
537 // Setup the answer to look like a server response.
538 // Drop the RID header extension.
539 auto mcd_answer = answer->description()->contents()[0].media_description();
540 auto& receive_layers = mcd_answer->simulcast_description().receive_layers();
541 for (const SimulcastLayer& layer : layers) {
542 receive_layers.AddLayer(layer);
543 }
544 cricket::RtpHeaderExtensions extensions;
545 for (auto extension : mcd_answer->rtp_header_extensions()) {
546 if (extension.uri != RtpExtension::kRidUri) {
547 extensions.push_back(extension);
548 }
549 }
550 mcd_answer->set_rtp_header_extensions(extensions);
551 EXPECT_EQ(layers.size(), mcd_answer->simulcast_description()
552 .receive_layers()
553 .GetAllLayers()
554 .size());
555 EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &err)) << err;
556 ValidateTransceiverParameters(transceiver, expected_layers);
557 }
558
559 #if RTC_METRICS_ENABLED
560 //
561 // Checks the logged metrics when simulcast is not used.
TEST_F(PeerConnectionSimulcastMetricsTests,NoSimulcastUsageIsLogged)562 TEST_F(PeerConnectionSimulcastMetricsTests, NoSimulcastUsageIsLogged) {
563 auto local = CreatePeerConnectionWrapper();
564 auto remote = CreatePeerConnectionWrapper();
565 auto layers = CreateLayers(0, true);
566 AddTransceiver(local.get(), layers);
567 ExchangeOfferAnswer(local.get(), remote.get(), layers);
568
569 EXPECT_THAT(LocalDescriptionSamples(),
570 ElementsAre(Pair(kSimulcastApiVersionNone, 2)));
571 EXPECT_THAT(RemoteDescriptionSamples(),
572 ElementsAre(Pair(kSimulcastApiVersionNone, 2)));
573 }
574
575 // Checks the logged metrics when spec-compliant simulcast is used.
TEST_F(PeerConnectionSimulcastMetricsTests,SpecComplianceIsLogged)576 TEST_F(PeerConnectionSimulcastMetricsTests, SpecComplianceIsLogged) {
577 auto local = CreatePeerConnectionWrapper();
578 auto remote = CreatePeerConnectionWrapper();
579 auto layers = CreateLayers(3, true);
580 AddTransceiver(local.get(), layers);
581 ExchangeOfferAnswer(local.get(), remote.get(), layers);
582
583 // Expecting 2 invocations of each, because we have 2 peer connections.
584 // Only the local peer connection will be aware of simulcast.
585 // The remote peer connection will think that there is no simulcast.
586 EXPECT_THAT(LocalDescriptionSamples(),
587 ElementsAre(Pair(kSimulcastApiVersionNone, 1),
588 Pair(kSimulcastApiVersionSpecCompliant, 1)));
589 EXPECT_THAT(RemoteDescriptionSamples(),
590 ElementsAre(Pair(kSimulcastApiVersionNone, 1),
591 Pair(kSimulcastApiVersionSpecCompliant, 1)));
592 }
593
594 // Checks the logged metrics when and incoming request to send spec-compliant
595 // simulcast is received from the remote party.
TEST_F(PeerConnectionSimulcastMetricsTests,IncomingSimulcastIsLogged)596 TEST_F(PeerConnectionSimulcastMetricsTests, IncomingSimulcastIsLogged) {
597 auto local = CreatePeerConnectionWrapper();
598 auto remote = CreatePeerConnectionWrapper();
599 auto layers = CreateLayers(3, true);
600 AddTransceiver(local.get(), layers);
601 auto offer = local->CreateOfferAndSetAsLocal();
602 EXPECT_THAT(LocalDescriptionSamples(),
603 ElementsAre(Pair(kSimulcastApiVersionSpecCompliant, 1)));
604
605 // Remove simulcast as a sender and set it up as a receiver.
606 RemoveSimulcast(offer.get());
607 AddRequestToReceiveSimulcast(layers, offer.get());
608 std::string error;
609 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
610 EXPECT_THAT(RemoteDescriptionSamples(),
611 ElementsAre(Pair(kSimulcastApiVersionSpecCompliant, 1)));
612
613 auto transceiver = remote->pc()->GetTransceivers()[0];
614 transceiver->SetDirectionWithError(RtpTransceiverDirection::kSendRecv);
615 EXPECT_TRUE(remote->CreateAnswerAndSetAsLocal());
616 EXPECT_THAT(LocalDescriptionSamples(),
617 ElementsAre(Pair(kSimulcastApiVersionSpecCompliant, 2)));
618 }
619
620 // Checks that a spec-compliant simulcast offer that is rejected is logged.
TEST_F(PeerConnectionSimulcastMetricsTests,RejectedSimulcastIsLogged)621 TEST_F(PeerConnectionSimulcastMetricsTests, RejectedSimulcastIsLogged) {
622 auto local = CreatePeerConnectionWrapper();
623 auto remote = CreatePeerConnectionWrapper();
624 auto layers = CreateLayers({"1", "2", "3"}, true);
625 AddTransceiver(local.get(), layers);
626 auto offer = local->CreateOfferAndSetAsLocal();
627 EXPECT_THAT(LocalDescriptionSamples(),
628 ElementsAre(Pair(kSimulcastApiVersionSpecCompliant, 1)));
629 RemoveSimulcast(offer.get());
630 std::string error;
631 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
632 EXPECT_THAT(RemoteDescriptionSamples(),
633 ElementsAre(Pair(kSimulcastApiVersionNone, 1)));
634
635 auto answer = remote->CreateAnswerAndSetAsLocal();
636 EXPECT_THAT(LocalDescriptionSamples(),
637 ElementsAre(Pair(kSimulcastApiVersionNone, 1),
638 Pair(kSimulcastApiVersionSpecCompliant, 1)));
639 EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &error)) << error;
640 EXPECT_THAT(RemoteDescriptionSamples(),
641 ElementsAre(Pair(kSimulcastApiVersionNone, 2)));
642 }
643
644 // Checks the logged metrics when legacy munging simulcast technique is used.
TEST_F(PeerConnectionSimulcastMetricsTests,LegacySimulcastIsLogged)645 TEST_F(PeerConnectionSimulcastMetricsTests, LegacySimulcastIsLogged) {
646 auto local = CreatePeerConnectionWrapper();
647 auto remote = CreatePeerConnectionWrapper();
648 auto layers = CreateLayers(0, true);
649 AddTransceiver(local.get(), layers);
650 auto offer = local->CreateOffer();
651 // Munge the SDP to set up legacy simulcast.
652 const std::string end_line = "\r\n";
653 std::string sdp;
654 offer->ToString(&sdp);
655 rtc::StringBuilder builder(sdp);
656 builder << "a=ssrc:1111 cname:slimshady" << end_line;
657 builder << "a=ssrc:2222 cname:slimshady" << end_line;
658 builder << "a=ssrc:3333 cname:slimshady" << end_line;
659 builder << "a=ssrc-group:SIM 1111 2222 3333" << end_line;
660
661 SdpParseError parse_error;
662 auto sd =
663 CreateSessionDescription(SdpType::kOffer, builder.str(), &parse_error);
664 ASSERT_TRUE(sd) << parse_error.line << parse_error.description;
665 std::string error;
666 EXPECT_TRUE(local->SetLocalDescription(std::move(sd), &error)) << error;
667 EXPECT_THAT(LocalDescriptionSamples(),
668 ElementsAre(Pair(kSimulcastApiVersionLegacy, 1)));
669 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
670 EXPECT_THAT(RemoteDescriptionSamples(),
671 ElementsAre(Pair(kSimulcastApiVersionNone, 1)));
672 auto answer = remote->CreateAnswerAndSetAsLocal();
673 EXPECT_THAT(LocalDescriptionSamples(),
674 ElementsAre(Pair(kSimulcastApiVersionNone, 1),
675 Pair(kSimulcastApiVersionLegacy, 1)));
676 // Legacy simulcast is not signaled in remote description.
677 EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &error)) << error;
678 EXPECT_THAT(RemoteDescriptionSamples(),
679 ElementsAre(Pair(kSimulcastApiVersionNone, 2)));
680 }
681
682 // Checks that disabling simulcast is logged in the metrics.
TEST_F(PeerConnectionSimulcastMetricsTests,SimulcastDisabledIsLogged)683 TEST_F(PeerConnectionSimulcastMetricsTests, SimulcastDisabledIsLogged) {
684 auto local = CreatePeerConnectionWrapper();
685 auto remote = CreatePeerConnectionWrapper();
686 auto layers = CreateLayers({"1", "2", "3"}, true);
687 AddTransceiver(local.get(), layers);
688 auto offer = local->CreateOfferAndSetAsLocal();
689 RemoveSimulcast(offer.get());
690 std::string error;
691 EXPECT_TRUE(remote->SetRemoteDescription(std::move(offer), &error)) << error;
692 auto answer = remote->CreateAnswerAndSetAsLocal();
693 EXPECT_TRUE(local->SetRemoteDescription(std::move(answer), &error)) << error;
694
695 EXPECT_EQ(1, metrics::NumSamples("WebRTC.PeerConnection.Simulcast.Disabled"));
696 EXPECT_EQ(1,
697 metrics::NumEvents("WebRTC.PeerConnection.Simulcast.Disabled", 1));
698 }
699
700 // Checks that the disabled metric is not logged if simulcast is not disabled.
TEST_F(PeerConnectionSimulcastMetricsTests,SimulcastDisabledIsNotLogged)701 TEST_F(PeerConnectionSimulcastMetricsTests, SimulcastDisabledIsNotLogged) {
702 auto local = CreatePeerConnectionWrapper();
703 auto remote = CreatePeerConnectionWrapper();
704 auto layers = CreateLayers({"1", "2", "3"}, true);
705 AddTransceiver(local.get(), layers);
706 ExchangeOfferAnswer(local.get(), remote.get(), layers);
707
708 EXPECT_EQ(0, metrics::NumSamples("WebRTC.PeerConnection.Simulcast.Disabled"));
709 }
710
711 const int kMaxLayersInMetricsTest = 8;
712
713 // Checks that the number of send encodings is logged in a metric.
TEST_P(PeerConnectionSimulcastMetricsTests,NumberOfSendEncodingsIsLogged)714 TEST_P(PeerConnectionSimulcastMetricsTests, NumberOfSendEncodingsIsLogged) {
715 auto local = CreatePeerConnectionWrapper();
716 auto num_layers = GetParam();
717 auto layers = CreateLayers(num_layers, true);
718 AddTransceiver(local.get(), layers);
719 EXPECT_EQ(1, metrics::NumSamples(
720 "WebRTC.PeerConnection.Simulcast.NumberOfSendEncodings"));
721 EXPECT_EQ(1, metrics::NumEvents(
722 "WebRTC.PeerConnection.Simulcast.NumberOfSendEncodings",
723 num_layers));
724 }
725
726 INSTANTIATE_TEST_SUITE_P(NumberOfSendEncodings,
727 PeerConnectionSimulcastMetricsTests,
728 ::testing::Range(0, kMaxLayersInMetricsTest));
729 #endif
730 } // namespace webrtc
731