deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 1 | /* |
kjellander | b24317b | 2016-02-10 07:54:43 -0800 | [diff] [blame] | 2 | * Copyright 2012 The WebRTC project authors. All Rights Reserved. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 3 | * |
kjellander | b24317b | 2016-02-10 07:54:43 -0800 | [diff] [blame] | 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. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 9 | */ |
| 10 | |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 11 | #include <stddef.h> |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 12 | |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 13 | #include <cstdint> |
kwiberg | d1fe281 | 2016-04-27 06:47:29 -0700 | [diff] [blame] | 14 | #include <memory> |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 15 | #include <string> |
Tommi | f888bb5 | 2015-12-12 01:37:01 +0100 | [diff] [blame] | 16 | #include <utility> |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 17 | #include <vector> |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 18 | |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 19 | #include "absl/algorithm/container.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 20 | #include "absl/memory/memory.h" |
| 21 | #include "absl/types/optional.h" |
| 22 | #include "api/audio_options.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 23 | #include "api/crypto/crypto_options.h" |
| 24 | #include "api/crypto/frame_decryptor_interface.h" |
| 25 | #include "api/crypto/frame_encryptor_interface.h" |
| 26 | #include "api/dtmf_sender_interface.h" |
| 27 | #include "api/media_stream_interface.h" |
| 28 | #include "api/rtc_error.h" |
Danil Chapovalov | 83bbe91 | 2019-08-07 12:24:53 +0200 | [diff] [blame] | 29 | #include "api/rtc_event_log/rtc_event_log.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 30 | #include "api/rtp_parameters.h" |
Mirko Bonadei | d970807 | 2019-01-25 20:26:48 +0100 | [diff] [blame] | 31 | #include "api/scoped_refptr.h" |
Benjamin Wright | 84583f6 | 2018-10-04 14:22:34 -0700 | [diff] [blame] | 32 | #include "api/test/fake_frame_decryptor.h" |
| 33 | #include "api/test/fake_frame_encryptor.h" |
Jonas Oreland | a3aa9bd | 2019-04-17 07:38:40 +0200 | [diff] [blame] | 34 | #include "api/video/builtin_video_bitrate_allocator_factory.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 35 | #include "media/base/codec.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 36 | #include "media/base/fake_media_engine.h" |
| 37 | #include "media/base/media_channel.h" |
| 38 | #include "media/base/media_config.h" |
| 39 | #include "media/base/media_engine.h" |
| 40 | #include "media/base/rtp_data_engine.h" |
| 41 | #include "media/base/stream_params.h" |
| 42 | #include "media/base/test_utils.h" |
| 43 | #include "media/engine/fake_webrtc_call.h" |
| 44 | #include "p2p/base/dtls_transport_internal.h" |
| 45 | #include "p2p/base/fake_dtls_transport.h" |
| 46 | #include "p2p/base/p2p_constants.h" |
Ruslan Burakov | 501bfba | 2019-02-11 10:29:19 +0100 | [diff] [blame] | 47 | #include "pc/audio_rtp_receiver.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 48 | #include "pc/audio_track.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 49 | #include "pc/channel.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 50 | #include "pc/channel_manager.h" |
| 51 | #include "pc/dtls_srtp_transport.h" |
| 52 | #include "pc/local_audio_source.h" |
| 53 | #include "pc/media_stream.h" |
Ruslan Burakov | 7ea4605 | 2019-02-16 02:07:05 +0100 | [diff] [blame] | 54 | #include "pc/remote_audio_source.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 55 | #include "pc/rtp_receiver.h" |
| 56 | #include "pc/rtp_sender.h" |
| 57 | #include "pc/rtp_transport_internal.h" |
| 58 | #include "pc/test/fake_video_track_source.h" |
Ruslan Burakov | 501bfba | 2019-02-11 10:29:19 +0100 | [diff] [blame] | 59 | #include "pc/video_rtp_receiver.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 60 | #include "pc/video_track.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 61 | #include "rtc_base/checks.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 62 | #include "rtc_base/gunit.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 63 | #include "rtc_base/third_party/sigslot/sigslot.h" |
| 64 | #include "rtc_base/thread.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 65 | #include "test/gmock.h" |
| 66 | #include "test/gtest.h" |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 67 | |
| 68 | using ::testing::_; |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 69 | using ::testing::ContainerEq; |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 70 | using ::testing::Exactly; |
deadbeef | 5dd42fd | 2016-05-02 16:20:01 -0700 | [diff] [blame] | 71 | using ::testing::InvokeWithoutArgs; |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 72 | using ::testing::Return; |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 73 | using RidList = std::vector<std::string>; |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 74 | |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 75 | namespace { |
| 76 | |
Seth Hampson | 845e878 | 2018-03-02 11:34:10 -0800 | [diff] [blame] | 77 | static const char kStreamId1[] = "local_stream_1"; |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 78 | static const char kVideoTrackId[] = "video_1"; |
| 79 | static const char kAudioTrackId[] = "audio_1"; |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 80 | static const uint32_t kVideoSsrc = 98; |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 81 | static const uint32_t kVideoSsrc2 = 100; |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 82 | static const uint32_t kAudioSsrc = 99; |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 83 | static const uint32_t kAudioSsrc2 = 101; |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 84 | static const uint32_t kVideoSsrcSimulcast = 102; |
| 85 | static const uint32_t kVideoSimulcastLayerCount = 2; |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 86 | static const int kDefaultTimeout = 10000; // 10 seconds. |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 87 | |
| 88 | class MockSetStreamsObserver |
| 89 | : public webrtc::RtpSenderBase::SetStreamsObserver { |
| 90 | public: |
| 91 | MOCK_METHOD0(OnSetStreams, void()); |
| 92 | }; |
| 93 | |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 94 | } // namespace |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 95 | |
| 96 | namespace webrtc { |
| 97 | |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 98 | class RtpSenderReceiverTest |
Mirko Bonadei | 6a489f2 | 2019-04-09 15:11:12 +0200 | [diff] [blame] | 99 | : public ::testing::Test, |
| 100 | public ::testing::WithParamInterface<std::pair<RidList, RidList>>, |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 101 | public sigslot::has_slots<> { |
tkchin | 3784b4a | 2016-06-24 19:31:47 -0700 | [diff] [blame] | 102 | public: |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 103 | RtpSenderReceiverTest() |
Steve Anton | 47136dd | 2018-01-12 10:49:35 -0800 | [diff] [blame] | 104 | : network_thread_(rtc::Thread::Current()), |
| 105 | worker_thread_(rtc::Thread::Current()), |
Jonas Oreland | a3aa9bd | 2019-04-17 07:38:40 +0200 | [diff] [blame] | 106 | video_bitrate_allocator_factory_( |
| 107 | webrtc::CreateBuiltinVideoBitrateAllocatorFactory()), |
Steve Anton | 47136dd | 2018-01-12 10:49:35 -0800 | [diff] [blame] | 108 | // Create fake media engine/etc. so we can create channels to use to |
| 109 | // test RtpSenders/RtpReceivers. |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 110 | media_engine_(new cricket::FakeMediaEngine()), |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 111 | channel_manager_(absl::WrapUnique(media_engine_), |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 112 | std::make_unique<cricket::RtpDataEngine>(), |
Steve Anton | 47136dd | 2018-01-12 10:49:35 -0800 | [diff] [blame] | 113 | worker_thread_, |
| 114 | network_thread_), |
Sebastian Jansson | 8f83b42 | 2018-02-21 13:07:13 +0100 | [diff] [blame] | 115 | fake_call_(), |
Seth Hampson | 845e878 | 2018-03-02 11:34:10 -0800 | [diff] [blame] | 116 | local_stream_(MediaStream::Create(kStreamId1)) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 117 | // Create channels to be used by the RtpSenders and RtpReceivers. |
| 118 | channel_manager_.Init(); |
deadbeef | 7af91dd | 2016-12-13 11:29:11 -0800 | [diff] [blame] | 119 | bool srtp_required = true; |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 120 | rtp_dtls_transport_ = std::make_unique<cricket::FakeDtlsTransport>( |
Zhi Huang | e830e68 | 2018-03-30 10:48:35 -0700 | [diff] [blame] | 121 | "fake_dtls_transport", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| 122 | rtp_transport_ = CreateDtlsSrtpTransport(); |
| 123 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 124 | voice_channel_ = channel_manager_.CreateVoiceChannel( |
Zhi Huang | e830e68 | 2018-03-30 10:48:35 -0700 | [diff] [blame] | 125 | &fake_call_, cricket::MediaConfig(), rtp_transport_.get(), |
Anton Sukhanov | 4f08faa | 2019-05-21 11:12:57 -0700 | [diff] [blame] | 126 | MediaTransportConfig(), rtc::Thread::Current(), cricket::CN_AUDIO, |
Amit Hilbuch | bcd39d4 | 2019-01-25 17:13:56 -0800 | [diff] [blame] | 127 | srtp_required, webrtc::CryptoOptions(), &ssrc_generator_, |
| 128 | cricket::AudioOptions()); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 129 | video_channel_ = channel_manager_.CreateVideoChannel( |
Zhi Huang | e830e68 | 2018-03-30 10:48:35 -0700 | [diff] [blame] | 130 | &fake_call_, cricket::MediaConfig(), rtp_transport_.get(), |
Anton Sukhanov | 4f08faa | 2019-05-21 11:12:57 -0700 | [diff] [blame] | 131 | MediaTransportConfig(), rtc::Thread::Current(), cricket::CN_VIDEO, |
Amit Hilbuch | bcd39d4 | 2019-01-25 17:13:56 -0800 | [diff] [blame] | 132 | srtp_required, webrtc::CryptoOptions(), &ssrc_generator_, |
Jonas Oreland | a3aa9bd | 2019-04-17 07:38:40 +0200 | [diff] [blame] | 133 | cricket::VideoOptions(), video_bitrate_allocator_factory_.get()); |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 134 | voice_channel_->Enable(true); |
| 135 | video_channel_->Enable(true); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 136 | voice_media_channel_ = media_engine_->GetVoiceChannel(0); |
| 137 | video_media_channel_ = media_engine_->GetVideoChannel(0); |
| 138 | RTC_CHECK(voice_channel_); |
| 139 | RTC_CHECK(video_channel_); |
| 140 | RTC_CHECK(voice_media_channel_); |
| 141 | RTC_CHECK(video_media_channel_); |
| 142 | |
| 143 | // Create streams for predefined SSRCs. Streams need to exist in order |
| 144 | // for the senders and receievers to apply parameters to them. |
| 145 | // Normally these would be created by SetLocalDescription and |
| 146 | // SetRemoteDescription. |
| 147 | voice_media_channel_->AddSendStream( |
| 148 | cricket::StreamParams::CreateLegacy(kAudioSsrc)); |
| 149 | voice_media_channel_->AddRecvStream( |
| 150 | cricket::StreamParams::CreateLegacy(kAudioSsrc)); |
| 151 | voice_media_channel_->AddSendStream( |
| 152 | cricket::StreamParams::CreateLegacy(kAudioSsrc2)); |
| 153 | voice_media_channel_->AddRecvStream( |
| 154 | cricket::StreamParams::CreateLegacy(kAudioSsrc2)); |
| 155 | video_media_channel_->AddSendStream( |
| 156 | cricket::StreamParams::CreateLegacy(kVideoSsrc)); |
| 157 | video_media_channel_->AddRecvStream( |
| 158 | cricket::StreamParams::CreateLegacy(kVideoSsrc)); |
| 159 | video_media_channel_->AddSendStream( |
| 160 | cricket::StreamParams::CreateLegacy(kVideoSsrc2)); |
| 161 | video_media_channel_->AddRecvStream( |
| 162 | cricket::StreamParams::CreateLegacy(kVideoSsrc2)); |
tkchin | 3784b4a | 2016-06-24 19:31:47 -0700 | [diff] [blame] | 163 | } |
Taylor Brandstetter | 2d54917 | 2016-06-24 14:18:22 -0700 | [diff] [blame] | 164 | |
Zhi Huang | e830e68 | 2018-03-30 10:48:35 -0700 | [diff] [blame] | 165 | std::unique_ptr<webrtc::RtpTransportInternal> CreateDtlsSrtpTransport() { |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 166 | auto dtls_srtp_transport = std::make_unique<webrtc::DtlsSrtpTransport>( |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 167 | /*rtcp_mux_required=*/true); |
Zhi Huang | e830e68 | 2018-03-30 10:48:35 -0700 | [diff] [blame] | 168 | dtls_srtp_transport->SetDtlsTransports(rtp_dtls_transport_.get(), |
| 169 | /*rtcp_dtls_transport=*/nullptr); |
| 170 | return dtls_srtp_transport; |
| 171 | } |
| 172 | |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 173 | // Needed to use DTMF sender. |
| 174 | void AddDtmfCodec() { |
| 175 | cricket::AudioSendParameters params; |
| 176 | const cricket::AudioCodec kTelephoneEventCodec(106, "telephone-event", 8000, |
| 177 | 0, 1); |
| 178 | params.codecs.push_back(kTelephoneEventCodec); |
| 179 | voice_media_channel_->SetSendParameters(params); |
| 180 | } |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 181 | |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 182 | void AddVideoTrack() { AddVideoTrack(false); } |
| 183 | |
| 184 | void AddVideoTrack(bool is_screencast) { |
perkj | a3ede6c | 2016-03-08 01:27:48 +0100 | [diff] [blame] | 185 | rtc::scoped_refptr<VideoTrackSourceInterface> source( |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 186 | FakeVideoTrackSource::Create(is_screencast)); |
perkj | 773be36 | 2017-07-31 23:22:01 -0700 | [diff] [blame] | 187 | video_track_ = |
| 188 | VideoTrack::Create(kVideoTrackId, source, rtc::Thread::Current()); |
deadbeef | e814a0d | 2017-02-25 18:15:09 -0800 | [diff] [blame] | 189 | EXPECT_TRUE(local_stream_->AddTrack(video_track_)); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 190 | } |
| 191 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 192 | void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); } |
| 193 | |
Mirko Bonadei | c61ce0d | 2017-11-21 17:04:20 +0100 | [diff] [blame] | 194 | void CreateAudioRtpSender( |
| 195 | const rtc::scoped_refptr<LocalAudioSource>& source) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 196 | audio_track_ = AudioTrack::Create(kAudioTrackId, source); |
deadbeef | e814a0d | 2017-02-25 18:15:09 -0800 | [diff] [blame] | 197 | EXPECT_TRUE(local_stream_->AddTrack(audio_track_)); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 198 | std::unique_ptr<MockSetStreamsObserver> set_streams_observer = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 199 | std::make_unique<MockSetStreamsObserver>(); |
Steve Anton | 47136dd | 2018-01-12 10:49:35 -0800 | [diff] [blame] | 200 | audio_rtp_sender_ = |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 201 | AudioRtpSender::Create(worker_thread_, audio_track_->id(), nullptr, |
| 202 | set_streams_observer.get()); |
Steve Anton | 111fdfd | 2018-06-25 13:03:36 -0700 | [diff] [blame] | 203 | ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_)); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 204 | EXPECT_CALL(*set_streams_observer, OnSetStreams()); |
| 205 | audio_rtp_sender_->SetStreams({local_stream_->id()}); |
Amit Hilbuch | dd9390c | 2018-11-13 16:26:05 -0800 | [diff] [blame] | 206 | audio_rtp_sender_->SetMediaChannel(voice_media_channel_); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 207 | audio_rtp_sender_->SetSsrc(kAudioSsrc); |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 208 | audio_rtp_sender_->GetOnDestroyedSignal()->connect( |
| 209 | this, &RtpSenderReceiverTest::OnAudioSenderDestroyed); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 210 | VerifyVoiceChannelInput(); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 211 | } |
| 212 | |
Steve Anton | 02ee47c | 2018-01-10 16:26:06 -0800 | [diff] [blame] | 213 | void CreateAudioRtpSenderWithNoTrack() { |
Amit Hilbuch | ea7ef2a | 2019-02-19 15:20:21 -0800 | [diff] [blame] | 214 | audio_rtp_sender_ = |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 215 | AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr); |
Amit Hilbuch | dd9390c | 2018-11-13 16:26:05 -0800 | [diff] [blame] | 216 | audio_rtp_sender_->SetMediaChannel(voice_media_channel_); |
Steve Anton | 02ee47c | 2018-01-10 16:26:06 -0800 | [diff] [blame] | 217 | } |
| 218 | |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 219 | void OnAudioSenderDestroyed() { audio_sender_destroyed_signal_fired_ = true; } |
| 220 | |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 221 | void CreateVideoRtpSender(uint32_t ssrc) { |
| 222 | CreateVideoRtpSender(false, ssrc); |
| 223 | } |
| 224 | |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 225 | void CreateVideoRtpSender() { CreateVideoRtpSender(false); } |
| 226 | |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 227 | cricket::StreamParams CreateSimulcastStreamParams(int num_layers) { |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 228 | std::vector<uint32_t> ssrcs; |
Mirko Bonadei | 649a4c2 | 2019-01-29 10:11:53 +0100 | [diff] [blame] | 229 | ssrcs.reserve(num_layers); |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 230 | for (int i = 0; i < num_layers; ++i) { |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 231 | ssrcs.push_back(kVideoSsrcSimulcast + i); |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 232 | } |
| 233 | return cricket::CreateSimStreamParams("cname", ssrcs); |
| 234 | } |
| 235 | |
| 236 | uint32_t CreateVideoRtpSender(const cricket::StreamParams& stream_params) { |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 237 | video_media_channel_->AddSendStream(stream_params); |
| 238 | uint32_t primary_ssrc = stream_params.first_ssrc(); |
| 239 | CreateVideoRtpSender(primary_ssrc); |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 240 | return primary_ssrc; |
| 241 | } |
| 242 | |
| 243 | uint32_t CreateVideoRtpSenderWithSimulcast( |
| 244 | int num_layers = kVideoSimulcastLayerCount) { |
| 245 | return CreateVideoRtpSender(CreateSimulcastStreamParams(num_layers)); |
| 246 | } |
| 247 | |
| 248 | uint32_t CreateVideoRtpSenderWithSimulcast( |
| 249 | const std::vector<std::string>& rids) { |
| 250 | cricket::StreamParams stream_params = |
| 251 | CreateSimulcastStreamParams(rids.size()); |
| 252 | std::vector<cricket::RidDescription> rid_descriptions; |
| 253 | absl::c_transform( |
| 254 | rids, std::back_inserter(rid_descriptions), [](const std::string& rid) { |
| 255 | return cricket::RidDescription(rid, cricket::RidDirection::kSend); |
| 256 | }); |
| 257 | stream_params.set_rids(rid_descriptions); |
| 258 | return CreateVideoRtpSender(stream_params); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 259 | } |
| 260 | |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 261 | void CreateVideoRtpSender(bool is_screencast, uint32_t ssrc = kVideoSsrc) { |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 262 | AddVideoTrack(is_screencast); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 263 | std::unique_ptr<MockSetStreamsObserver> set_streams_observer = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 264 | std::make_unique<MockSetStreamsObserver>(); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 265 | video_rtp_sender_ = VideoRtpSender::Create( |
| 266 | worker_thread_, video_track_->id(), set_streams_observer.get()); |
Steve Anton | 111fdfd | 2018-06-25 13:03:36 -0700 | [diff] [blame] | 267 | ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_)); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 268 | EXPECT_CALL(*set_streams_observer, OnSetStreams()); |
| 269 | video_rtp_sender_->SetStreams({local_stream_->id()}); |
Amit Hilbuch | dd9390c | 2018-11-13 16:26:05 -0800 | [diff] [blame] | 270 | video_rtp_sender_->SetMediaChannel(video_media_channel_); |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 271 | video_rtp_sender_->SetSsrc(ssrc); |
| 272 | VerifyVideoChannelInput(ssrc); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 273 | } |
Steve Anton | 02ee47c | 2018-01-10 16:26:06 -0800 | [diff] [blame] | 274 | void CreateVideoRtpSenderWithNoTrack() { |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 275 | video_rtp_sender_ = |
| 276 | VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr); |
Amit Hilbuch | dd9390c | 2018-11-13 16:26:05 -0800 | [diff] [blame] | 277 | video_rtp_sender_->SetMediaChannel(video_media_channel_); |
Steve Anton | 02ee47c | 2018-01-10 16:26:06 -0800 | [diff] [blame] | 278 | } |
| 279 | |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 280 | void DestroyAudioRtpSender() { |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 281 | audio_rtp_sender_ = nullptr; |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 282 | VerifyVoiceChannelNoInput(); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 283 | } |
| 284 | |
| 285 | void DestroyVideoRtpSender() { |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 286 | video_rtp_sender_ = nullptr; |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 287 | VerifyVideoChannelNoInput(); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 288 | } |
| 289 | |
Henrik Boström | 9e6fd2b | 2017-11-21 13:41:51 +0100 | [diff] [blame] | 290 | void CreateAudioRtpReceiver( |
| 291 | std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams = {}) { |
Mirko Bonadei | 05cf6be | 2019-01-31 21:38:12 +0100 | [diff] [blame] | 292 | audio_rtp_receiver_ = |
| 293 | new AudioRtpReceiver(rtc::Thread::Current(), kAudioTrackId, streams); |
Amit Hilbuch | dd9390c | 2018-11-13 16:26:05 -0800 | [diff] [blame] | 294 | audio_rtp_receiver_->SetMediaChannel(voice_media_channel_); |
Steve Anton | d367921 | 2018-01-17 17:41:02 -0800 | [diff] [blame] | 295 | audio_rtp_receiver_->SetupMediaChannel(kAudioSsrc); |
perkj | d61bf80 | 2016-03-24 03:16:19 -0700 | [diff] [blame] | 296 | audio_track_ = audio_rtp_receiver_->audio_track(); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 297 | VerifyVoiceChannelOutput(); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 298 | } |
| 299 | |
Henrik Boström | 9e6fd2b | 2017-11-21 13:41:51 +0100 | [diff] [blame] | 300 | void CreateVideoRtpReceiver( |
| 301 | std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams = {}) { |
Mirko Bonadei | 05cf6be | 2019-01-31 21:38:12 +0100 | [diff] [blame] | 302 | video_rtp_receiver_ = |
| 303 | new VideoRtpReceiver(rtc::Thread::Current(), kVideoTrackId, streams); |
Amit Hilbuch | dd9390c | 2018-11-13 16:26:05 -0800 | [diff] [blame] | 304 | video_rtp_receiver_->SetMediaChannel(video_media_channel_); |
Steve Anton | d367921 | 2018-01-17 17:41:02 -0800 | [diff] [blame] | 305 | video_rtp_receiver_->SetupMediaChannel(kVideoSsrc); |
perkj | f0dcfe2 | 2016-03-10 18:32:00 +0100 | [diff] [blame] | 306 | video_track_ = video_rtp_receiver_->video_track(); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 307 | VerifyVideoChannelOutput(); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 308 | } |
| 309 | |
Florent Castelli | 38332cd | 2018-11-20 14:08:06 +0100 | [diff] [blame] | 310 | void CreateVideoRtpReceiverWithSimulcast( |
| 311 | std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams = {}, |
| 312 | int num_layers = kVideoSimulcastLayerCount) { |
| 313 | std::vector<uint32_t> ssrcs; |
Mirko Bonadei | 649a4c2 | 2019-01-29 10:11:53 +0100 | [diff] [blame] | 314 | ssrcs.reserve(num_layers); |
Florent Castelli | 38332cd | 2018-11-20 14:08:06 +0100 | [diff] [blame] | 315 | for (int i = 0; i < num_layers; ++i) |
| 316 | ssrcs.push_back(kVideoSsrcSimulcast + i); |
| 317 | cricket::StreamParams stream_params = |
| 318 | cricket::CreateSimStreamParams("cname", ssrcs); |
| 319 | video_media_channel_->AddRecvStream(stream_params); |
| 320 | uint32_t primary_ssrc = stream_params.first_ssrc(); |
| 321 | |
Mirko Bonadei | 05cf6be | 2019-01-31 21:38:12 +0100 | [diff] [blame] | 322 | video_rtp_receiver_ = |
| 323 | new VideoRtpReceiver(rtc::Thread::Current(), kVideoTrackId, streams); |
Florent Castelli | 38332cd | 2018-11-20 14:08:06 +0100 | [diff] [blame] | 324 | video_rtp_receiver_->SetMediaChannel(video_media_channel_); |
| 325 | video_rtp_receiver_->SetupMediaChannel(primary_ssrc); |
| 326 | video_track_ = video_rtp_receiver_->video_track(); |
| 327 | } |
| 328 | |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 329 | void DestroyAudioRtpReceiver() { |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 330 | audio_rtp_receiver_ = nullptr; |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 331 | VerifyVoiceChannelNoOutput(); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | void DestroyVideoRtpReceiver() { |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 335 | video_rtp_receiver_ = nullptr; |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 336 | VerifyVideoChannelNoOutput(); |
| 337 | } |
| 338 | |
| 339 | void VerifyVoiceChannelInput() { VerifyVoiceChannelInput(kAudioSsrc); } |
| 340 | |
| 341 | void VerifyVoiceChannelInput(uint32_t ssrc) { |
| 342 | // Verify that the media channel has an audio source, and the stream isn't |
| 343 | // muted. |
| 344 | EXPECT_TRUE(voice_media_channel_->HasSource(ssrc)); |
| 345 | EXPECT_FALSE(voice_media_channel_->IsStreamMuted(ssrc)); |
| 346 | } |
| 347 | |
| 348 | void VerifyVideoChannelInput() { VerifyVideoChannelInput(kVideoSsrc); } |
| 349 | |
| 350 | void VerifyVideoChannelInput(uint32_t ssrc) { |
| 351 | // Verify that the media channel has a video source, |
| 352 | EXPECT_TRUE(video_media_channel_->HasSource(ssrc)); |
| 353 | } |
| 354 | |
| 355 | void VerifyVoiceChannelNoInput() { VerifyVoiceChannelNoInput(kAudioSsrc); } |
| 356 | |
| 357 | void VerifyVoiceChannelNoInput(uint32_t ssrc) { |
| 358 | // Verify that the media channel's source is reset. |
| 359 | EXPECT_FALSE(voice_media_channel_->HasSource(ssrc)); |
| 360 | } |
| 361 | |
| 362 | void VerifyVideoChannelNoInput() { VerifyVideoChannelNoInput(kVideoSsrc); } |
| 363 | |
| 364 | void VerifyVideoChannelNoInput(uint32_t ssrc) { |
| 365 | // Verify that the media channel's source is reset. |
| 366 | EXPECT_FALSE(video_media_channel_->HasSource(ssrc)); |
| 367 | } |
| 368 | |
| 369 | void VerifyVoiceChannelOutput() { |
| 370 | // Verify that the volume is initialized to 1. |
| 371 | double volume; |
| 372 | EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 373 | EXPECT_EQ(1, volume); |
| 374 | } |
| 375 | |
| 376 | void VerifyVideoChannelOutput() { |
| 377 | // Verify that the media channel has a sink. |
| 378 | EXPECT_TRUE(video_media_channel_->HasSink(kVideoSsrc)); |
| 379 | } |
| 380 | |
| 381 | void VerifyVoiceChannelNoOutput() { |
| 382 | // Verify that the volume is reset to 0. |
| 383 | double volume; |
| 384 | EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 385 | EXPECT_EQ(0, volume); |
| 386 | } |
| 387 | |
| 388 | void VerifyVideoChannelNoOutput() { |
| 389 | // Verify that the media channel's sink is reset. |
| 390 | EXPECT_FALSE(video_media_channel_->HasSink(kVideoSsrc)); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 391 | } |
| 392 | |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 393 | // Verifies that the encoding layers contain the specified RIDs. |
| 394 | bool VerifyEncodingLayers(const VideoRtpSender& sender, |
| 395 | const std::vector<std::string>& rids) { |
| 396 | bool has_failure = HasFailure(); |
| 397 | RtpParameters parameters = sender.GetParameters(); |
| 398 | std::vector<std::string> encoding_rids; |
| 399 | absl::c_transform( |
| 400 | parameters.encodings, std::back_inserter(encoding_rids), |
| 401 | [](const RtpEncodingParameters& encoding) { return encoding.rid; }); |
| 402 | EXPECT_THAT(rids, ContainerEq(encoding_rids)); |
| 403 | return has_failure || !HasFailure(); |
| 404 | } |
| 405 | |
| 406 | // Runs a test for disabling the encoding layers on the specified sender. |
| 407 | void RunDisableEncodingLayersTest( |
| 408 | const std::vector<std::string>& all_layers, |
| 409 | const std::vector<std::string>& disabled_layers, |
| 410 | VideoRtpSender* sender) { |
| 411 | std::vector<std::string> expected; |
| 412 | absl::c_copy_if(all_layers, std::back_inserter(expected), |
| 413 | [&disabled_layers](const std::string& rid) { |
| 414 | return !absl::c_linear_search(disabled_layers, rid); |
| 415 | }); |
| 416 | |
| 417 | EXPECT_TRUE(VerifyEncodingLayers(*sender, all_layers)); |
| 418 | sender->DisableEncodingLayers(disabled_layers); |
| 419 | EXPECT_TRUE(VerifyEncodingLayers(*sender, expected)); |
| 420 | } |
| 421 | |
| 422 | // Runs a test for setting an encoding layer as inactive. |
| 423 | // This test assumes that some layers have already been disabled. |
| 424 | void RunSetLastLayerAsInactiveTest(VideoRtpSender* sender) { |
| 425 | auto parameters = sender->GetParameters(); |
| 426 | if (parameters.encodings.size() == 0) { |
| 427 | return; |
| 428 | } |
| 429 | |
| 430 | RtpEncodingParameters& encoding = parameters.encodings.back(); |
| 431 | auto rid = encoding.rid; |
| 432 | EXPECT_TRUE(encoding.active); |
| 433 | encoding.active = false; |
| 434 | auto error = sender->SetParameters(parameters); |
| 435 | ASSERT_TRUE(error.ok()); |
| 436 | parameters = sender->GetParameters(); |
| 437 | RtpEncodingParameters& result_encoding = parameters.encodings.back(); |
| 438 | EXPECT_EQ(rid, result_encoding.rid); |
| 439 | EXPECT_FALSE(result_encoding.active); |
| 440 | } |
| 441 | |
| 442 | // Runs a test for disabling the encoding layers on a sender without a media |
| 443 | // channel. |
| 444 | void RunDisableSimulcastLayersWithoutMediaEngineTest( |
| 445 | const std::vector<std::string>& all_layers, |
| 446 | const std::vector<std::string>& disabled_layers) { |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 447 | auto sender = VideoRtpSender::Create(rtc::Thread::Current(), "1", nullptr); |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 448 | RtpParameters parameters; |
| 449 | parameters.encodings.resize(all_layers.size()); |
| 450 | for (size_t i = 0; i < all_layers.size(); ++i) { |
| 451 | parameters.encodings[i].rid = all_layers[i]; |
| 452 | } |
Amit Hilbuch | ea7ef2a | 2019-02-19 15:20:21 -0800 | [diff] [blame] | 453 | sender->set_init_send_encodings(parameters.encodings); |
| 454 | RunDisableEncodingLayersTest(all_layers, disabled_layers, sender.get()); |
| 455 | RunSetLastLayerAsInactiveTest(sender.get()); |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 456 | } |
| 457 | |
| 458 | // Runs a test for disabling the encoding layers on a sender with a media |
| 459 | // channel. |
| 460 | void RunDisableSimulcastLayersWithMediaEngineTest( |
| 461 | const std::vector<std::string>& all_layers, |
| 462 | const std::vector<std::string>& disabled_layers) { |
| 463 | uint32_t ssrc = CreateVideoRtpSenderWithSimulcast(all_layers); |
| 464 | RunDisableEncodingLayersTest(all_layers, disabled_layers, |
| 465 | video_rtp_sender_.get()); |
| 466 | |
| 467 | auto channel_parameters = video_media_channel_->GetRtpSendParameters(ssrc); |
| 468 | ASSERT_EQ(channel_parameters.encodings.size(), all_layers.size()); |
| 469 | for (size_t i = 0; i < all_layers.size(); ++i) { |
| 470 | EXPECT_EQ(all_layers[i], channel_parameters.encodings[i].rid); |
| 471 | bool is_active = !absl::c_linear_search(disabled_layers, all_layers[i]); |
| 472 | EXPECT_EQ(is_active, channel_parameters.encodings[i].active); |
| 473 | } |
| 474 | |
| 475 | RunSetLastLayerAsInactiveTest(video_rtp_sender_.get()); |
| 476 | } |
| 477 | |
Ruslan Burakov | 4bac79e | 2019-04-03 19:55:33 +0200 | [diff] [blame] | 478 | // Check that minimum Jitter Buffer delay is propagated to the underlying |
| 479 | // |media_channel|. |
| 480 | void VerifyRtpReceiverDelayBehaviour(cricket::Delayable* media_channel, |
| 481 | RtpReceiverInterface* receiver, |
| 482 | uint32_t ssrc) { |
| 483 | receiver->SetJitterBufferMinimumDelay(/*delay_seconds=*/0.5); |
| 484 | absl::optional<int> delay_ms = |
| 485 | media_channel->GetBaseMinimumPlayoutDelayMs(ssrc); // In milliseconds. |
| 486 | EXPECT_DOUBLE_EQ(0.5, delay_ms.value_or(0) / 1000.0); |
| 487 | } |
| 488 | |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 489 | protected: |
Steve Anton | 47136dd | 2018-01-12 10:49:35 -0800 | [diff] [blame] | 490 | rtc::Thread* const network_thread_; |
| 491 | rtc::Thread* const worker_thread_; |
Danil Chapovalov | 83bbe91 | 2019-08-07 12:24:53 +0200 | [diff] [blame] | 492 | webrtc::RtcEventLogNull event_log_; |
Zhi Huang | e830e68 | 2018-03-30 10:48:35 -0700 | [diff] [blame] | 493 | // The |rtp_dtls_transport_| and |rtp_transport_| should be destroyed after |
| 494 | // the |channel_manager|. |
| 495 | std::unique_ptr<cricket::DtlsTransportInternal> rtp_dtls_transport_; |
| 496 | std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport_; |
Jonas Oreland | a3aa9bd | 2019-04-17 07:38:40 +0200 | [diff] [blame] | 497 | std::unique_ptr<webrtc::VideoBitrateAllocatorFactory> |
| 498 | video_bitrate_allocator_factory_; |
deadbeef | 112b2e9 | 2017-02-10 20:13:37 -0800 | [diff] [blame] | 499 | // |media_engine_| is actually owned by |channel_manager_|. |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 500 | cricket::FakeMediaEngine* media_engine_; |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 501 | cricket::ChannelManager channel_manager_; |
| 502 | cricket::FakeCall fake_call_; |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 503 | cricket::VoiceChannel* voice_channel_; |
| 504 | cricket::VideoChannel* video_channel_; |
| 505 | cricket::FakeVoiceMediaChannel* voice_media_channel_; |
| 506 | cricket::FakeVideoMediaChannel* video_media_channel_; |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 507 | rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_; |
| 508 | rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_; |
| 509 | rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_; |
| 510 | rtc::scoped_refptr<VideoRtpReceiver> video_rtp_receiver_; |
deadbeef | e814a0d | 2017-02-25 18:15:09 -0800 | [diff] [blame] | 511 | rtc::scoped_refptr<MediaStreamInterface> local_stream_; |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 512 | rtc::scoped_refptr<VideoTrackInterface> video_track_; |
| 513 | rtc::scoped_refptr<AudioTrackInterface> audio_track_; |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 514 | bool audio_sender_destroyed_signal_fired_ = false; |
Amit Hilbuch | bcd39d4 | 2019-01-25 17:13:56 -0800 | [diff] [blame] | 515 | rtc::UniqueRandomIdGenerator ssrc_generator_; |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 516 | }; |
| 517 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 518 | // Test that |voice_channel_| is updated when an audio track is associated |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 519 | // and disassociated with an AudioRtpSender. |
| 520 | TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpSender) { |
| 521 | CreateAudioRtpSender(); |
| 522 | DestroyAudioRtpSender(); |
| 523 | } |
| 524 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 525 | // Test that |video_channel_| is updated when a video track is associated and |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 526 | // disassociated with a VideoRtpSender. |
| 527 | TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpSender) { |
| 528 | CreateVideoRtpSender(); |
| 529 | DestroyVideoRtpSender(); |
| 530 | } |
| 531 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 532 | // Test that |voice_channel_| is updated when a remote audio track is |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 533 | // associated and disassociated with an AudioRtpReceiver. |
| 534 | TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpReceiver) { |
| 535 | CreateAudioRtpReceiver(); |
| 536 | DestroyAudioRtpReceiver(); |
| 537 | } |
| 538 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 539 | // Test that |video_channel_| is updated when a remote video track is |
| 540 | // associated and disassociated with a VideoRtpReceiver. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 541 | TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpReceiver) { |
| 542 | CreateVideoRtpReceiver(); |
| 543 | DestroyVideoRtpReceiver(); |
| 544 | } |
| 545 | |
Henrik Boström | 9e6fd2b | 2017-11-21 13:41:51 +0100 | [diff] [blame] | 546 | TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpReceiverWithStreams) { |
| 547 | CreateAudioRtpReceiver({local_stream_}); |
| 548 | DestroyAudioRtpReceiver(); |
| 549 | } |
| 550 | |
| 551 | TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpReceiverWithStreams) { |
| 552 | CreateVideoRtpReceiver({local_stream_}); |
| 553 | DestroyVideoRtpReceiver(); |
| 554 | } |
| 555 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 556 | // Test that the AudioRtpSender applies options from the local audio source. |
| 557 | TEST_F(RtpSenderReceiverTest, LocalAudioSourceOptionsApplied) { |
| 558 | cricket::AudioOptions options; |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 559 | options.echo_cancellation = true; |
deadbeef | 757146b | 2017-02-10 21:26:48 -0800 | [diff] [blame] | 560 | auto source = LocalAudioSource::Create(&options); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 561 | CreateAudioRtpSender(source.get()); |
Taylor Brandstetter | 2d54917 | 2016-06-24 14:18:22 -0700 | [diff] [blame] | 562 | |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 563 | EXPECT_EQ(true, voice_media_channel_->options().echo_cancellation); |
Taylor Brandstetter | 2d54917 | 2016-06-24 14:18:22 -0700 | [diff] [blame] | 564 | |
| 565 | DestroyAudioRtpSender(); |
| 566 | } |
| 567 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 568 | // Test that the stream is muted when the track is disabled, and unmuted when |
| 569 | // the track is enabled. |
| 570 | TEST_F(RtpSenderReceiverTest, LocalAudioTrackDisable) { |
| 571 | CreateAudioRtpSender(); |
| 572 | |
| 573 | audio_track_->set_enabled(false); |
| 574 | EXPECT_TRUE(voice_media_channel_->IsStreamMuted(kAudioSsrc)); |
| 575 | |
| 576 | audio_track_->set_enabled(true); |
| 577 | EXPECT_FALSE(voice_media_channel_->IsStreamMuted(kAudioSsrc)); |
| 578 | |
| 579 | DestroyAudioRtpSender(); |
| 580 | } |
| 581 | |
| 582 | // Test that the volume is set to 0 when the track is disabled, and back to |
| 583 | // 1 when the track is enabled. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 584 | TEST_F(RtpSenderReceiverTest, RemoteAudioTrackDisable) { |
| 585 | CreateAudioRtpReceiver(); |
| 586 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 587 | double volume; |
| 588 | EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 589 | EXPECT_EQ(1, volume); |
Taylor Brandstetter | 2d54917 | 2016-06-24 14:18:22 -0700 | [diff] [blame] | 590 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 591 | audio_track_->set_enabled(false); |
| 592 | EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 593 | EXPECT_EQ(0, volume); |
| 594 | |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 595 | audio_track_->set_enabled(true); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 596 | EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 597 | EXPECT_EQ(1, volume); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 598 | |
| 599 | DestroyAudioRtpReceiver(); |
| 600 | } |
| 601 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 602 | // Currently no action is taken when a remote video track is disabled or |
| 603 | // enabled, so there's nothing to test here, other than what is normally |
| 604 | // verified in DestroyVideoRtpSender. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 605 | TEST_F(RtpSenderReceiverTest, LocalVideoTrackDisable) { |
| 606 | CreateVideoRtpSender(); |
| 607 | |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 608 | video_track_->set_enabled(false); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 609 | video_track_->set_enabled(true); |
| 610 | |
| 611 | DestroyVideoRtpSender(); |
| 612 | } |
| 613 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 614 | // Test that the state of the video track created by the VideoRtpReceiver is |
| 615 | // updated when the receiver is destroyed. |
perkj | f0dcfe2 | 2016-03-10 18:32:00 +0100 | [diff] [blame] | 616 | TEST_F(RtpSenderReceiverTest, RemoteVideoTrackState) { |
| 617 | CreateVideoRtpReceiver(); |
| 618 | |
| 619 | EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track_->state()); |
| 620 | EXPECT_EQ(webrtc::MediaSourceInterface::kLive, |
| 621 | video_track_->GetSource()->state()); |
| 622 | |
| 623 | DestroyVideoRtpReceiver(); |
| 624 | |
| 625 | EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, video_track_->state()); |
| 626 | EXPECT_EQ(webrtc::MediaSourceInterface::kEnded, |
| 627 | video_track_->GetSource()->state()); |
| 628 | } |
| 629 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 630 | // Currently no action is taken when a remote video track is disabled or |
| 631 | // enabled, so there's nothing to test here, other than what is normally |
| 632 | // verified in DestroyVideoRtpReceiver. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 633 | TEST_F(RtpSenderReceiverTest, RemoteVideoTrackDisable) { |
| 634 | CreateVideoRtpReceiver(); |
| 635 | |
| 636 | video_track_->set_enabled(false); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 637 | video_track_->set_enabled(true); |
| 638 | |
| 639 | DestroyVideoRtpReceiver(); |
| 640 | } |
| 641 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 642 | // Test that the AudioRtpReceiver applies volume changes from the track source |
| 643 | // to the media channel. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 644 | TEST_F(RtpSenderReceiverTest, RemoteAudioTrackSetVolume) { |
| 645 | CreateAudioRtpReceiver(); |
| 646 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 647 | double volume; |
| 648 | audio_track_->GetSource()->SetVolume(0.5); |
| 649 | EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 650 | EXPECT_EQ(0.5, volume); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 651 | |
| 652 | // Disable the audio track, this should prevent setting the volume. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 653 | audio_track_->set_enabled(false); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 654 | audio_track_->GetSource()->SetVolume(0.8); |
| 655 | EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 656 | EXPECT_EQ(0, volume); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 657 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 658 | // When the track is enabled, the previously set volume should take effect. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 659 | audio_track_->set_enabled(true); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 660 | EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 661 | EXPECT_EQ(0.8, volume); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 662 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 663 | // Try changing volume one more time. |
| 664 | audio_track_->GetSource()->SetVolume(0.9); |
| 665 | EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 666 | EXPECT_EQ(0.9, volume); |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 667 | |
| 668 | DestroyAudioRtpReceiver(); |
| 669 | } |
| 670 | |
Ruslan Burakov | 4bac79e | 2019-04-03 19:55:33 +0200 | [diff] [blame] | 671 | TEST_F(RtpSenderReceiverTest, AudioRtpReceiverDelay) { |
| 672 | CreateAudioRtpReceiver(); |
| 673 | VerifyRtpReceiverDelayBehaviour(voice_media_channel_, |
| 674 | audio_rtp_receiver_.get(), kAudioSsrc); |
Ruslan Burakov | 4bac79e | 2019-04-03 19:55:33 +0200 | [diff] [blame] | 675 | } |
| 676 | |
| 677 | TEST_F(RtpSenderReceiverTest, VideoRtpReceiverDelay) { |
| 678 | CreateVideoRtpReceiver(); |
| 679 | VerifyRtpReceiverDelayBehaviour(video_media_channel_, |
| 680 | video_rtp_receiver_.get(), kVideoSsrc); |
| 681 | } |
| 682 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 683 | // Test that the media channel isn't enabled for sending if the audio sender |
| 684 | // doesn't have both a track and SSRC. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 685 | TEST_F(RtpSenderReceiverTest, AudioSenderWithoutTrackAndSsrc) { |
Steve Anton | 02ee47c | 2018-01-10 16:26:06 -0800 | [diff] [blame] | 686 | CreateAudioRtpSenderWithNoTrack(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 687 | rtc::scoped_refptr<AudioTrackInterface> track = |
| 688 | AudioTrack::Create(kAudioTrackId, nullptr); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 689 | |
| 690 | // Track but no SSRC. |
| 691 | EXPECT_TRUE(audio_rtp_sender_->SetTrack(track)); |
| 692 | VerifyVoiceChannelNoInput(); |
| 693 | |
| 694 | // SSRC but no track. |
| 695 | EXPECT_TRUE(audio_rtp_sender_->SetTrack(nullptr)); |
| 696 | audio_rtp_sender_->SetSsrc(kAudioSsrc); |
| 697 | VerifyVoiceChannelNoInput(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 698 | } |
| 699 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 700 | // Test that the media channel isn't enabled for sending if the video sender |
| 701 | // doesn't have both a track and SSRC. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 702 | TEST_F(RtpSenderReceiverTest, VideoSenderWithoutTrackAndSsrc) { |
Steve Anton | 02ee47c | 2018-01-10 16:26:06 -0800 | [diff] [blame] | 703 | CreateVideoRtpSenderWithNoTrack(); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 704 | |
| 705 | // Track but no SSRC. |
| 706 | EXPECT_TRUE(video_rtp_sender_->SetTrack(video_track_)); |
| 707 | VerifyVideoChannelNoInput(); |
| 708 | |
| 709 | // SSRC but no track. |
| 710 | EXPECT_TRUE(video_rtp_sender_->SetTrack(nullptr)); |
| 711 | video_rtp_sender_->SetSsrc(kVideoSsrc); |
| 712 | VerifyVideoChannelNoInput(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 713 | } |
| 714 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 715 | // Test that the media channel is enabled for sending when the audio sender |
| 716 | // has a track and SSRC, when the SSRC is set first. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 717 | TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupSsrcThenTrack) { |
Steve Anton | 02ee47c | 2018-01-10 16:26:06 -0800 | [diff] [blame] | 718 | CreateAudioRtpSenderWithNoTrack(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 719 | rtc::scoped_refptr<AudioTrackInterface> track = |
| 720 | AudioTrack::Create(kAudioTrackId, nullptr); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 721 | audio_rtp_sender_->SetSsrc(kAudioSsrc); |
| 722 | audio_rtp_sender_->SetTrack(track); |
| 723 | VerifyVoiceChannelInput(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 724 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 725 | DestroyAudioRtpSender(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 726 | } |
| 727 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 728 | // Test that the media channel is enabled for sending when the audio sender |
| 729 | // has a track and SSRC, when the SSRC is set last. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 730 | TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupTrackThenSsrc) { |
Steve Anton | 02ee47c | 2018-01-10 16:26:06 -0800 | [diff] [blame] | 731 | CreateAudioRtpSenderWithNoTrack(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 732 | rtc::scoped_refptr<AudioTrackInterface> track = |
| 733 | AudioTrack::Create(kAudioTrackId, nullptr); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 734 | audio_rtp_sender_->SetTrack(track); |
| 735 | audio_rtp_sender_->SetSsrc(kAudioSsrc); |
| 736 | VerifyVoiceChannelInput(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 737 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 738 | DestroyAudioRtpSender(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 739 | } |
| 740 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 741 | // Test that the media channel is enabled for sending when the video sender |
| 742 | // has a track and SSRC, when the SSRC is set first. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 743 | TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupSsrcThenTrack) { |
nisse | af510af | 2016-03-21 08:20:42 -0700 | [diff] [blame] | 744 | AddVideoTrack(); |
Steve Anton | 02ee47c | 2018-01-10 16:26:06 -0800 | [diff] [blame] | 745 | CreateVideoRtpSenderWithNoTrack(); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 746 | video_rtp_sender_->SetSsrc(kVideoSsrc); |
| 747 | video_rtp_sender_->SetTrack(video_track_); |
| 748 | VerifyVideoChannelInput(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 749 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 750 | DestroyVideoRtpSender(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 751 | } |
| 752 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 753 | // Test that the media channel is enabled for sending when the video sender |
| 754 | // has a track and SSRC, when the SSRC is set last. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 755 | TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupTrackThenSsrc) { |
nisse | af510af | 2016-03-21 08:20:42 -0700 | [diff] [blame] | 756 | AddVideoTrack(); |
Steve Anton | 02ee47c | 2018-01-10 16:26:06 -0800 | [diff] [blame] | 757 | CreateVideoRtpSenderWithNoTrack(); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 758 | video_rtp_sender_->SetTrack(video_track_); |
| 759 | video_rtp_sender_->SetSsrc(kVideoSsrc); |
| 760 | VerifyVideoChannelInput(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 761 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 762 | DestroyVideoRtpSender(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 763 | } |
| 764 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 765 | // Test that the media channel stops sending when the audio sender's SSRC is set |
| 766 | // to 0. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 767 | TEST_F(RtpSenderReceiverTest, AudioSenderSsrcSetToZero) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 768 | CreateAudioRtpSender(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 769 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 770 | audio_rtp_sender_->SetSsrc(0); |
| 771 | VerifyVoiceChannelNoInput(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 772 | } |
| 773 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 774 | // Test that the media channel stops sending when the video sender's SSRC is set |
| 775 | // to 0. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 776 | TEST_F(RtpSenderReceiverTest, VideoSenderSsrcSetToZero) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 777 | CreateAudioRtpSender(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 778 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 779 | audio_rtp_sender_->SetSsrc(0); |
| 780 | VerifyVideoChannelNoInput(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 781 | } |
| 782 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 783 | // Test that the media channel stops sending when the audio sender's track is |
| 784 | // set to null. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 785 | TEST_F(RtpSenderReceiverTest, AudioSenderTrackSetToNull) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 786 | CreateAudioRtpSender(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 787 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 788 | EXPECT_TRUE(audio_rtp_sender_->SetTrack(nullptr)); |
| 789 | VerifyVoiceChannelNoInput(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 790 | } |
| 791 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 792 | // Test that the media channel stops sending when the video sender's track is |
| 793 | // set to null. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 794 | TEST_F(RtpSenderReceiverTest, VideoSenderTrackSetToNull) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 795 | CreateVideoRtpSender(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 796 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 797 | video_rtp_sender_->SetSsrc(0); |
| 798 | VerifyVideoChannelNoInput(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 799 | } |
| 800 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 801 | // Test that when the audio sender's SSRC is changed, the media channel stops |
| 802 | // sending with the old SSRC and starts sending with the new one. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 803 | TEST_F(RtpSenderReceiverTest, AudioSenderSsrcChanged) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 804 | CreateAudioRtpSender(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 805 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 806 | audio_rtp_sender_->SetSsrc(kAudioSsrc2); |
| 807 | VerifyVoiceChannelNoInput(kAudioSsrc); |
| 808 | VerifyVoiceChannelInput(kAudioSsrc2); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 809 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 810 | audio_rtp_sender_ = nullptr; |
| 811 | VerifyVoiceChannelNoInput(kAudioSsrc2); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 812 | } |
| 813 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 814 | // Test that when the audio sender's SSRC is changed, the media channel stops |
| 815 | // sending with the old SSRC and starts sending with the new one. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 816 | TEST_F(RtpSenderReceiverTest, VideoSenderSsrcChanged) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 817 | CreateVideoRtpSender(); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 818 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 819 | video_rtp_sender_->SetSsrc(kVideoSsrc2); |
| 820 | VerifyVideoChannelNoInput(kVideoSsrc); |
| 821 | VerifyVideoChannelInput(kVideoSsrc2); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 822 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 823 | video_rtp_sender_ = nullptr; |
| 824 | VerifyVideoChannelNoInput(kVideoSsrc2); |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 825 | } |
| 826 | |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 827 | TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParameters) { |
| 828 | CreateAudioRtpSender(); |
| 829 | |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 830 | RtpParameters params = audio_rtp_sender_->GetParameters(); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 831 | EXPECT_EQ(1u, params.encodings.size()); |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 832 | EXPECT_TRUE(audio_rtp_sender_->SetParameters(params).ok()); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 833 | |
| 834 | DestroyAudioRtpSender(); |
| 835 | } |
| 836 | |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 837 | TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParametersBeforeNegotiation) { |
Amit Hilbuch | ea7ef2a | 2019-02-19 15:20:21 -0800 | [diff] [blame] | 838 | audio_rtp_sender_ = |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 839 | AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 840 | |
| 841 | RtpParameters params = audio_rtp_sender_->GetParameters(); |
| 842 | ASSERT_EQ(1u, params.encodings.size()); |
| 843 | params.encodings[0].max_bitrate_bps = 90000; |
| 844 | EXPECT_TRUE(audio_rtp_sender_->SetParameters(params).ok()); |
| 845 | |
| 846 | params = audio_rtp_sender_->GetParameters(); |
| 847 | EXPECT_TRUE(audio_rtp_sender_->SetParameters(params).ok()); |
| 848 | EXPECT_EQ(params.encodings[0].max_bitrate_bps, 90000); |
| 849 | |
| 850 | DestroyAudioRtpSender(); |
| 851 | } |
| 852 | |
| 853 | TEST_F(RtpSenderReceiverTest, AudioSenderInitParametersMovedAfterNegotiation) { |
| 854 | audio_track_ = AudioTrack::Create(kAudioTrackId, nullptr); |
| 855 | EXPECT_TRUE(local_stream_->AddTrack(audio_track_)); |
| 856 | |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 857 | std::unique_ptr<MockSetStreamsObserver> set_streams_observer = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 858 | std::make_unique<MockSetStreamsObserver>(); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 859 | audio_rtp_sender_ = AudioRtpSender::Create( |
| 860 | worker_thread_, audio_track_->id(), nullptr, set_streams_observer.get()); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 861 | ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_)); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 862 | EXPECT_CALL(*set_streams_observer, OnSetStreams()); |
| 863 | audio_rtp_sender_->SetStreams({local_stream_->id()}); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 864 | |
| 865 | std::vector<RtpEncodingParameters> init_encodings(1); |
| 866 | init_encodings[0].max_bitrate_bps = 60000; |
| 867 | audio_rtp_sender_->set_init_send_encodings(init_encodings); |
| 868 | |
| 869 | RtpParameters params = audio_rtp_sender_->GetParameters(); |
| 870 | ASSERT_EQ(1u, params.encodings.size()); |
| 871 | EXPECT_EQ(params.encodings[0].max_bitrate_bps, 60000); |
| 872 | |
| 873 | // Simulate the setLocalDescription call |
| 874 | std::vector<uint32_t> ssrcs(1, 1); |
| 875 | cricket::StreamParams stream_params = |
| 876 | cricket::CreateSimStreamParams("cname", ssrcs); |
| 877 | voice_media_channel_->AddSendStream(stream_params); |
Amit Hilbuch | dd9390c | 2018-11-13 16:26:05 -0800 | [diff] [blame] | 878 | audio_rtp_sender_->SetMediaChannel(voice_media_channel_); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 879 | audio_rtp_sender_->SetSsrc(1); |
| 880 | |
| 881 | params = audio_rtp_sender_->GetParameters(); |
| 882 | ASSERT_EQ(1u, params.encodings.size()); |
| 883 | EXPECT_EQ(params.encodings[0].max_bitrate_bps, 60000); |
| 884 | |
| 885 | DestroyAudioRtpSender(); |
| 886 | } |
| 887 | |
| 888 | TEST_F(RtpSenderReceiverTest, |
| 889 | AudioSenderMustCallGetParametersBeforeSetParametersBeforeNegotiation) { |
Amit Hilbuch | ea7ef2a | 2019-02-19 15:20:21 -0800 | [diff] [blame] | 890 | audio_rtp_sender_ = |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 891 | AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 892 | |
| 893 | RtpParameters params; |
| 894 | RTCError result = audio_rtp_sender_->SetParameters(params); |
| 895 | EXPECT_EQ(RTCErrorType::INVALID_STATE, result.type()); |
| 896 | DestroyAudioRtpSender(); |
| 897 | } |
| 898 | |
Florent Castelli | cebf50f | 2018-05-03 15:31:53 +0200 | [diff] [blame] | 899 | TEST_F(RtpSenderReceiverTest, |
| 900 | AudioSenderMustCallGetParametersBeforeSetParameters) { |
| 901 | CreateAudioRtpSender(); |
| 902 | |
| 903 | RtpParameters params; |
| 904 | RTCError result = audio_rtp_sender_->SetParameters(params); |
| 905 | EXPECT_EQ(RTCErrorType::INVALID_STATE, result.type()); |
| 906 | |
| 907 | DestroyAudioRtpSender(); |
| 908 | } |
| 909 | |
| 910 | TEST_F(RtpSenderReceiverTest, |
| 911 | AudioSenderSetParametersInvalidatesTransactionId) { |
| 912 | CreateAudioRtpSender(); |
| 913 | |
| 914 | RtpParameters params = audio_rtp_sender_->GetParameters(); |
| 915 | EXPECT_EQ(1u, params.encodings.size()); |
| 916 | EXPECT_TRUE(audio_rtp_sender_->SetParameters(params).ok()); |
| 917 | RTCError result = audio_rtp_sender_->SetParameters(params); |
| 918 | EXPECT_EQ(RTCErrorType::INVALID_STATE, result.type()); |
| 919 | |
| 920 | DestroyAudioRtpSender(); |
| 921 | } |
| 922 | |
| 923 | TEST_F(RtpSenderReceiverTest, AudioSenderDetectTransactionIdModification) { |
| 924 | CreateAudioRtpSender(); |
| 925 | |
| 926 | RtpParameters params = audio_rtp_sender_->GetParameters(); |
| 927 | params.transaction_id = ""; |
| 928 | RTCError result = audio_rtp_sender_->SetParameters(params); |
| 929 | EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, result.type()); |
| 930 | |
| 931 | DestroyAudioRtpSender(); |
| 932 | } |
| 933 | |
| 934 | TEST_F(RtpSenderReceiverTest, AudioSenderCheckTransactionIdRefresh) { |
| 935 | CreateAudioRtpSender(); |
| 936 | |
| 937 | RtpParameters params = audio_rtp_sender_->GetParameters(); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 938 | EXPECT_NE(params.transaction_id.size(), 0U); |
Florent Castelli | cebf50f | 2018-05-03 15:31:53 +0200 | [diff] [blame] | 939 | auto saved_transaction_id = params.transaction_id; |
| 940 | params = audio_rtp_sender_->GetParameters(); |
| 941 | EXPECT_NE(saved_transaction_id, params.transaction_id); |
| 942 | |
| 943 | DestroyAudioRtpSender(); |
| 944 | } |
| 945 | |
| 946 | TEST_F(RtpSenderReceiverTest, AudioSenderSetParametersOldValueFail) { |
| 947 | CreateAudioRtpSender(); |
| 948 | |
| 949 | RtpParameters params = audio_rtp_sender_->GetParameters(); |
| 950 | RtpParameters second_params = audio_rtp_sender_->GetParameters(); |
| 951 | |
| 952 | RTCError result = audio_rtp_sender_->SetParameters(params); |
| 953 | EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, result.type()); |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 954 | DestroyAudioRtpSender(); |
| 955 | } |
| 956 | |
| 957 | TEST_F(RtpSenderReceiverTest, AudioSenderCantSetUnimplementedRtpParameters) { |
| 958 | CreateAudioRtpSender(); |
| 959 | RtpParameters params = audio_rtp_sender_->GetParameters(); |
| 960 | EXPECT_EQ(1u, params.encodings.size()); |
| 961 | |
Florent Castelli | 87b3c51 | 2018-07-18 16:00:28 +0200 | [diff] [blame] | 962 | // Unimplemented RtpParameters: mid |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 963 | params.mid = "dummy_mid"; |
| 964 | EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER, |
| 965 | audio_rtp_sender_->SetParameters(params).type()); |
| 966 | params = audio_rtp_sender_->GetParameters(); |
| 967 | |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 968 | DestroyAudioRtpSender(); |
| 969 | } |
| 970 | |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 971 | TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) { |
| 972 | CreateAudioRtpSender(); |
| 973 | |
| 974 | EXPECT_EQ(-1, voice_media_channel_->max_bps()); |
| 975 | webrtc::RtpParameters params = audio_rtp_sender_->GetParameters(); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 976 | EXPECT_EQ(1U, params.encodings.size()); |
deadbeef | e702b30 | 2017-02-04 12:09:01 -0800 | [diff] [blame] | 977 | EXPECT_FALSE(params.encodings[0].max_bitrate_bps); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 978 | params.encodings[0].max_bitrate_bps = 1000; |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 979 | EXPECT_TRUE(audio_rtp_sender_->SetParameters(params).ok()); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 980 | |
| 981 | // Read back the parameters and verify they have been changed. |
| 982 | params = audio_rtp_sender_->GetParameters(); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 983 | EXPECT_EQ(1U, params.encodings.size()); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 984 | EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 985 | |
| 986 | // Verify that the audio channel received the new parameters. |
| 987 | params = voice_media_channel_->GetRtpSendParameters(kAudioSsrc); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 988 | EXPECT_EQ(1U, params.encodings.size()); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 989 | EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 990 | |
| 991 | // Verify that the global bitrate limit has not been changed. |
| 992 | EXPECT_EQ(-1, voice_media_channel_->max_bps()); |
| 993 | |
| 994 | DestroyAudioRtpSender(); |
| 995 | } |
| 996 | |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 997 | TEST_F(RtpSenderReceiverTest, SetAudioBitratePriority) { |
| 998 | CreateAudioRtpSender(); |
| 999 | |
| 1000 | webrtc::RtpParameters params = audio_rtp_sender_->GetParameters(); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 1001 | EXPECT_EQ(1U, params.encodings.size()); |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 1002 | EXPECT_EQ(webrtc::kDefaultBitratePriority, |
| 1003 | params.encodings[0].bitrate_priority); |
| 1004 | double new_bitrate_priority = 2.0; |
| 1005 | params.encodings[0].bitrate_priority = new_bitrate_priority; |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 1006 | EXPECT_TRUE(audio_rtp_sender_->SetParameters(params).ok()); |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 1007 | |
| 1008 | params = audio_rtp_sender_->GetParameters(); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 1009 | EXPECT_EQ(1U, params.encodings.size()); |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 1010 | EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority); |
| 1011 | |
| 1012 | params = voice_media_channel_->GetRtpSendParameters(kAudioSsrc); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 1013 | EXPECT_EQ(1U, params.encodings.size()); |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 1014 | EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority); |
| 1015 | |
| 1016 | DestroyAudioRtpSender(); |
| 1017 | } |
| 1018 | |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1019 | TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParameters) { |
| 1020 | CreateVideoRtpSender(); |
| 1021 | |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1022 | RtpParameters params = video_rtp_sender_->GetParameters(); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 1023 | EXPECT_EQ(1u, params.encodings.size()); |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 1024 | EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1025 | |
| 1026 | DestroyVideoRtpSender(); |
| 1027 | } |
| 1028 | |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1029 | TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParametersBeforeNegotiation) { |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1030 | video_rtp_sender_ = |
| 1031 | VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1032 | |
| 1033 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1034 | ASSERT_EQ(1u, params.encodings.size()); |
| 1035 | params.encodings[0].max_bitrate_bps = 90000; |
| 1036 | EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); |
| 1037 | |
| 1038 | params = video_rtp_sender_->GetParameters(); |
| 1039 | EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); |
| 1040 | EXPECT_EQ(params.encodings[0].max_bitrate_bps, 90000); |
| 1041 | |
| 1042 | DestroyVideoRtpSender(); |
| 1043 | } |
| 1044 | |
| 1045 | TEST_F(RtpSenderReceiverTest, VideoSenderInitParametersMovedAfterNegotiation) { |
| 1046 | AddVideoTrack(false); |
| 1047 | |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1048 | std::unique_ptr<MockSetStreamsObserver> set_streams_observer = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 1049 | std::make_unique<MockSetStreamsObserver>(); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1050 | video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(), |
| 1051 | set_streams_observer.get()); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1052 | ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_)); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1053 | EXPECT_CALL(*set_streams_observer, OnSetStreams()); |
| 1054 | video_rtp_sender_->SetStreams({local_stream_->id()}); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1055 | |
| 1056 | std::vector<RtpEncodingParameters> init_encodings(2); |
| 1057 | init_encodings[0].max_bitrate_bps = 60000; |
| 1058 | init_encodings[1].max_bitrate_bps = 900000; |
| 1059 | video_rtp_sender_->set_init_send_encodings(init_encodings); |
| 1060 | |
| 1061 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1062 | ASSERT_EQ(2u, params.encodings.size()); |
| 1063 | EXPECT_EQ(params.encodings[0].max_bitrate_bps, 60000); |
| 1064 | EXPECT_EQ(params.encodings[1].max_bitrate_bps, 900000); |
| 1065 | |
| 1066 | // Simulate the setLocalDescription call |
| 1067 | std::vector<uint32_t> ssrcs; |
Mirko Bonadei | 649a4c2 | 2019-01-29 10:11:53 +0100 | [diff] [blame] | 1068 | ssrcs.reserve(2); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1069 | for (int i = 0; i < 2; ++i) |
| 1070 | ssrcs.push_back(kVideoSsrcSimulcast + i); |
| 1071 | cricket::StreamParams stream_params = |
| 1072 | cricket::CreateSimStreamParams("cname", ssrcs); |
| 1073 | video_media_channel_->AddSendStream(stream_params); |
Amit Hilbuch | dd9390c | 2018-11-13 16:26:05 -0800 | [diff] [blame] | 1074 | video_rtp_sender_->SetMediaChannel(video_media_channel_); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1075 | video_rtp_sender_->SetSsrc(kVideoSsrcSimulcast); |
| 1076 | |
| 1077 | params = video_rtp_sender_->GetParameters(); |
| 1078 | ASSERT_EQ(2u, params.encodings.size()); |
| 1079 | EXPECT_EQ(params.encodings[0].max_bitrate_bps, 60000); |
| 1080 | EXPECT_EQ(params.encodings[1].max_bitrate_bps, 900000); |
| 1081 | |
| 1082 | DestroyVideoRtpSender(); |
| 1083 | } |
| 1084 | |
| 1085 | TEST_F(RtpSenderReceiverTest, |
| 1086 | VideoSenderInitParametersMovedAfterManualSimulcastAndNegotiation) { |
| 1087 | AddVideoTrack(false); |
| 1088 | |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1089 | std::unique_ptr<MockSetStreamsObserver> set_streams_observer = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 1090 | std::make_unique<MockSetStreamsObserver>(); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1091 | video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(), |
| 1092 | set_streams_observer.get()); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1093 | ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_)); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1094 | EXPECT_CALL(*set_streams_observer, OnSetStreams()); |
| 1095 | video_rtp_sender_->SetStreams({local_stream_->id()}); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1096 | |
| 1097 | std::vector<RtpEncodingParameters> init_encodings(1); |
| 1098 | init_encodings[0].max_bitrate_bps = 60000; |
| 1099 | video_rtp_sender_->set_init_send_encodings(init_encodings); |
| 1100 | |
| 1101 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1102 | ASSERT_EQ(1u, params.encodings.size()); |
| 1103 | EXPECT_EQ(params.encodings[0].max_bitrate_bps, 60000); |
| 1104 | |
| 1105 | // Simulate the setLocalDescription call as if the user used SDP munging |
| 1106 | // to enable simulcast |
| 1107 | std::vector<uint32_t> ssrcs; |
Mirko Bonadei | 649a4c2 | 2019-01-29 10:11:53 +0100 | [diff] [blame] | 1108 | ssrcs.reserve(2); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1109 | for (int i = 0; i < 2; ++i) |
| 1110 | ssrcs.push_back(kVideoSsrcSimulcast + i); |
| 1111 | cricket::StreamParams stream_params = |
| 1112 | cricket::CreateSimStreamParams("cname", ssrcs); |
| 1113 | video_media_channel_->AddSendStream(stream_params); |
Amit Hilbuch | dd9390c | 2018-11-13 16:26:05 -0800 | [diff] [blame] | 1114 | video_rtp_sender_->SetMediaChannel(video_media_channel_); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1115 | video_rtp_sender_->SetSsrc(kVideoSsrcSimulcast); |
| 1116 | |
| 1117 | params = video_rtp_sender_->GetParameters(); |
| 1118 | ASSERT_EQ(2u, params.encodings.size()); |
| 1119 | EXPECT_EQ(params.encodings[0].max_bitrate_bps, 60000); |
| 1120 | |
| 1121 | DestroyVideoRtpSender(); |
| 1122 | } |
| 1123 | |
| 1124 | TEST_F(RtpSenderReceiverTest, |
| 1125 | VideoSenderMustCallGetParametersBeforeSetParametersBeforeNegotiation) { |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1126 | video_rtp_sender_ = |
| 1127 | VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1128 | |
| 1129 | RtpParameters params; |
| 1130 | RTCError result = video_rtp_sender_->SetParameters(params); |
| 1131 | EXPECT_EQ(RTCErrorType::INVALID_STATE, result.type()); |
| 1132 | DestroyVideoRtpSender(); |
| 1133 | } |
| 1134 | |
Florent Castelli | cebf50f | 2018-05-03 15:31:53 +0200 | [diff] [blame] | 1135 | TEST_F(RtpSenderReceiverTest, |
| 1136 | VideoSenderMustCallGetParametersBeforeSetParameters) { |
| 1137 | CreateVideoRtpSender(); |
| 1138 | |
| 1139 | RtpParameters params; |
| 1140 | RTCError result = video_rtp_sender_->SetParameters(params); |
| 1141 | EXPECT_EQ(RTCErrorType::INVALID_STATE, result.type()); |
| 1142 | |
| 1143 | DestroyVideoRtpSender(); |
| 1144 | } |
| 1145 | |
| 1146 | TEST_F(RtpSenderReceiverTest, |
| 1147 | VideoSenderSetParametersInvalidatesTransactionId) { |
| 1148 | CreateVideoRtpSender(); |
| 1149 | |
| 1150 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1151 | EXPECT_EQ(1u, params.encodings.size()); |
| 1152 | EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); |
| 1153 | RTCError result = video_rtp_sender_->SetParameters(params); |
| 1154 | EXPECT_EQ(RTCErrorType::INVALID_STATE, result.type()); |
| 1155 | |
| 1156 | DestroyVideoRtpSender(); |
| 1157 | } |
| 1158 | |
| 1159 | TEST_F(RtpSenderReceiverTest, VideoSenderDetectTransactionIdModification) { |
| 1160 | CreateVideoRtpSender(); |
| 1161 | |
| 1162 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1163 | params.transaction_id = ""; |
| 1164 | RTCError result = video_rtp_sender_->SetParameters(params); |
| 1165 | EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, result.type()); |
| 1166 | |
| 1167 | DestroyVideoRtpSender(); |
| 1168 | } |
| 1169 | |
| 1170 | TEST_F(RtpSenderReceiverTest, VideoSenderCheckTransactionIdRefresh) { |
| 1171 | CreateVideoRtpSender(); |
| 1172 | |
| 1173 | RtpParameters params = video_rtp_sender_->GetParameters(); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 1174 | EXPECT_NE(params.transaction_id.size(), 0U); |
Florent Castelli | cebf50f | 2018-05-03 15:31:53 +0200 | [diff] [blame] | 1175 | auto saved_transaction_id = params.transaction_id; |
| 1176 | params = video_rtp_sender_->GetParameters(); |
| 1177 | EXPECT_NE(saved_transaction_id, params.transaction_id); |
| 1178 | |
| 1179 | DestroyVideoRtpSender(); |
| 1180 | } |
| 1181 | |
| 1182 | TEST_F(RtpSenderReceiverTest, VideoSenderSetParametersOldValueFail) { |
| 1183 | CreateVideoRtpSender(); |
| 1184 | |
| 1185 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1186 | RtpParameters second_params = video_rtp_sender_->GetParameters(); |
| 1187 | |
| 1188 | RTCError result = video_rtp_sender_->SetParameters(params); |
| 1189 | EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, result.type()); |
| 1190 | |
| 1191 | DestroyVideoRtpSender(); |
| 1192 | } |
| 1193 | |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 1194 | TEST_F(RtpSenderReceiverTest, VideoSenderCantSetUnimplementedRtpParameters) { |
| 1195 | CreateVideoRtpSender(); |
| 1196 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1197 | EXPECT_EQ(1u, params.encodings.size()); |
| 1198 | |
Florent Castelli | 87b3c51 | 2018-07-18 16:00:28 +0200 | [diff] [blame] | 1199 | // Unimplemented RtpParameters: mid |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 1200 | params.mid = "dummy_mid"; |
| 1201 | EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER, |
| 1202 | video_rtp_sender_->SetParameters(params).type()); |
| 1203 | params = video_rtp_sender_->GetParameters(); |
| 1204 | |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 1205 | DestroyVideoRtpSender(); |
| 1206 | } |
| 1207 | |
Florent Castelli | c1a0bcb | 2019-01-29 14:26:48 +0100 | [diff] [blame] | 1208 | TEST_F(RtpSenderReceiverTest, VideoSenderCanSetScaleResolutionDownBy) { |
| 1209 | CreateVideoRtpSender(); |
| 1210 | |
| 1211 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1212 | params.encodings[0].scale_resolution_down_by = 2; |
| 1213 | |
| 1214 | EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); |
| 1215 | params = video_rtp_sender_->GetParameters(); |
| 1216 | EXPECT_EQ(2, params.encodings[0].scale_resolution_down_by); |
| 1217 | |
| 1218 | DestroyVideoRtpSender(); |
| 1219 | } |
| 1220 | |
| 1221 | TEST_F(RtpSenderReceiverTest, VideoSenderDetectInvalidScaleResolutionDownBy) { |
| 1222 | CreateVideoRtpSender(); |
| 1223 | |
| 1224 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1225 | params.encodings[0].scale_resolution_down_by = 0.5; |
| 1226 | RTCError result = video_rtp_sender_->SetParameters(params); |
| 1227 | EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.type()); |
| 1228 | |
| 1229 | DestroyVideoRtpSender(); |
| 1230 | } |
| 1231 | |
Florent Castelli | 907dc80 | 2019-12-06 15:03:19 +0100 | [diff] [blame] | 1232 | TEST_F(RtpSenderReceiverTest, VideoSenderCanSetMaxFramerate) { |
| 1233 | CreateVideoRtpSender(); |
| 1234 | |
| 1235 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1236 | params.encodings[0].max_framerate = 20; |
| 1237 | |
| 1238 | EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); |
| 1239 | params = video_rtp_sender_->GetParameters(); |
| 1240 | EXPECT_EQ(20., params.encodings[0].max_framerate); |
| 1241 | |
| 1242 | DestroyVideoRtpSender(); |
| 1243 | } |
| 1244 | |
| 1245 | TEST_F(RtpSenderReceiverTest, VideoSenderCanSetMaxFramerateZero) { |
| 1246 | CreateVideoRtpSender(); |
| 1247 | |
| 1248 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1249 | params.encodings[0].max_framerate = 0.; |
| 1250 | |
| 1251 | EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); |
| 1252 | params = video_rtp_sender_->GetParameters(); |
| 1253 | EXPECT_EQ(0., params.encodings[0].max_framerate); |
| 1254 | |
| 1255 | DestroyVideoRtpSender(); |
| 1256 | } |
| 1257 | |
| 1258 | TEST_F(RtpSenderReceiverTest, VideoSenderDetectInvalidMaxFramerate) { |
| 1259 | CreateVideoRtpSender(); |
| 1260 | |
| 1261 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1262 | params.encodings[0].max_framerate = -5.; |
| 1263 | RTCError result = video_rtp_sender_->SetParameters(params); |
| 1264 | EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.type()); |
| 1265 | |
| 1266 | DestroyVideoRtpSender(); |
| 1267 | } |
| 1268 | |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 1269 | // A video sender can have multiple simulcast layers, in which case it will |
| 1270 | // contain multiple RtpEncodingParameters. This tests that if this is the case |
| 1271 | // (simulcast), then we can't set the bitrate_priority, or max_bitrate_bps |
| 1272 | // for any encodings besides at index 0, because these are both implemented |
| 1273 | // "per-sender." |
| 1274 | TEST_F(RtpSenderReceiverTest, VideoSenderCantSetPerSenderEncodingParameters) { |
| 1275 | // Add a simulcast specific send stream that contains 2 encoding parameters. |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1276 | CreateVideoRtpSenderWithSimulcast(); |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 1277 | RtpParameters params = video_rtp_sender_->GetParameters(); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1278 | EXPECT_EQ(kVideoSimulcastLayerCount, params.encodings.size()); |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 1279 | |
| 1280 | params.encodings[1].bitrate_priority = 2.0; |
| 1281 | EXPECT_EQ(RTCErrorType::UNSUPPORTED_PARAMETER, |
| 1282 | video_rtp_sender_->SetParameters(params).type()); |
| 1283 | params = video_rtp_sender_->GetParameters(); |
| 1284 | |
Seth Hampson | 2d2c888 | 2018-05-16 16:02:32 -0700 | [diff] [blame] | 1285 | DestroyVideoRtpSender(); |
| 1286 | } |
| 1287 | |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1288 | TEST_F(RtpSenderReceiverTest, VideoSenderCantSetReadOnlyEncodingParameters) { |
| 1289 | // Add a simulcast specific send stream that contains 2 encoding parameters. |
| 1290 | CreateVideoRtpSenderWithSimulcast(); |
| 1291 | RtpParameters params = video_rtp_sender_->GetParameters(); |
| 1292 | EXPECT_EQ(kVideoSimulcastLayerCount, params.encodings.size()); |
| 1293 | |
| 1294 | for (size_t i = 0; i < params.encodings.size(); i++) { |
| 1295 | params.encodings[i].ssrc = 1337; |
| 1296 | EXPECT_EQ(RTCErrorType::INVALID_MODIFICATION, |
| 1297 | video_rtp_sender_->SetParameters(params).type()); |
| 1298 | params = video_rtp_sender_->GetParameters(); |
| 1299 | } |
| 1300 | |
| 1301 | DestroyVideoRtpSender(); |
| 1302 | } |
| 1303 | |
Ă…sa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 1304 | TEST_F(RtpSenderReceiverTest, SetVideoMinMaxSendBitrate) { |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 1305 | CreateVideoRtpSender(); |
| 1306 | |
| 1307 | EXPECT_EQ(-1, video_media_channel_->max_bps()); |
| 1308 | webrtc::RtpParameters params = video_rtp_sender_->GetParameters(); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 1309 | EXPECT_EQ(1U, params.encodings.size()); |
Ă…sa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 1310 | EXPECT_FALSE(params.encodings[0].min_bitrate_bps); |
deadbeef | e702b30 | 2017-02-04 12:09:01 -0800 | [diff] [blame] | 1311 | EXPECT_FALSE(params.encodings[0].max_bitrate_bps); |
Ă…sa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 1312 | params.encodings[0].min_bitrate_bps = 100; |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1313 | params.encodings[0].max_bitrate_bps = 1000; |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 1314 | EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 1315 | |
| 1316 | // Read back the parameters and verify they have been changed. |
| 1317 | params = video_rtp_sender_->GetParameters(); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 1318 | EXPECT_EQ(1U, params.encodings.size()); |
Ă…sa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 1319 | EXPECT_EQ(100, params.encodings[0].min_bitrate_bps); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1320 | EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 1321 | |
| 1322 | // Verify that the video channel received the new parameters. |
| 1323 | params = video_media_channel_->GetRtpSendParameters(kVideoSsrc); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 1324 | EXPECT_EQ(1U, params.encodings.size()); |
Ă…sa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 1325 | EXPECT_EQ(100, params.encodings[0].min_bitrate_bps); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1326 | EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps); |
Taylor Brandstetter | ba29c6a | 2016-06-27 16:30:35 -0700 | [diff] [blame] | 1327 | |
| 1328 | // Verify that the global bitrate limit has not been changed. |
| 1329 | EXPECT_EQ(-1, video_media_channel_->max_bps()); |
| 1330 | |
| 1331 | DestroyVideoRtpSender(); |
| 1332 | } |
| 1333 | |
Ă…sa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 1334 | TEST_F(RtpSenderReceiverTest, SetVideoMinMaxSendBitrateSimulcast) { |
| 1335 | // Add a simulcast specific send stream that contains 2 encoding parameters. |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1336 | CreateVideoRtpSenderWithSimulcast(); |
Ă…sa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 1337 | |
| 1338 | RtpParameters params = video_rtp_sender_->GetParameters(); |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1339 | EXPECT_EQ(kVideoSimulcastLayerCount, params.encodings.size()); |
Ă…sa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 1340 | params.encodings[0].min_bitrate_bps = 100; |
| 1341 | params.encodings[0].max_bitrate_bps = 1000; |
| 1342 | params.encodings[1].min_bitrate_bps = 200; |
| 1343 | params.encodings[1].max_bitrate_bps = 2000; |
| 1344 | EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); |
| 1345 | |
| 1346 | // Verify that the video channel received the new parameters. |
Florent Castelli | 892acf0 | 2018-10-01 22:47:20 +0200 | [diff] [blame] | 1347 | params = video_media_channel_->GetRtpSendParameters(kVideoSsrcSimulcast); |
| 1348 | EXPECT_EQ(kVideoSimulcastLayerCount, params.encodings.size()); |
Ă…sa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 1349 | EXPECT_EQ(100, params.encodings[0].min_bitrate_bps); |
| 1350 | EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps); |
| 1351 | EXPECT_EQ(200, params.encodings[1].min_bitrate_bps); |
| 1352 | EXPECT_EQ(2000, params.encodings[1].max_bitrate_bps); |
| 1353 | |
| 1354 | DestroyVideoRtpSender(); |
| 1355 | } |
| 1356 | |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 1357 | TEST_F(RtpSenderReceiverTest, SetVideoBitratePriority) { |
| 1358 | CreateVideoRtpSender(); |
| 1359 | |
| 1360 | webrtc::RtpParameters params = video_rtp_sender_->GetParameters(); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 1361 | EXPECT_EQ(1U, params.encodings.size()); |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 1362 | EXPECT_EQ(webrtc::kDefaultBitratePriority, |
| 1363 | params.encodings[0].bitrate_priority); |
| 1364 | double new_bitrate_priority = 2.0; |
| 1365 | params.encodings[0].bitrate_priority = new_bitrate_priority; |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 1366 | EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok()); |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 1367 | |
| 1368 | params = video_rtp_sender_->GetParameters(); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 1369 | EXPECT_EQ(1U, params.encodings.size()); |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 1370 | EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority); |
| 1371 | |
| 1372 | params = video_media_channel_->GetRtpSendParameters(kVideoSsrc); |
Mirko Bonadei | e12c1fe | 2018-07-03 12:53:23 +0200 | [diff] [blame] | 1373 | EXPECT_EQ(1U, params.encodings.size()); |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 1374 | EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority); |
| 1375 | |
| 1376 | DestroyVideoRtpSender(); |
| 1377 | } |
| 1378 | |
Florent Castelli | 38332cd | 2018-11-20 14:08:06 +0100 | [diff] [blame] | 1379 | TEST_F(RtpSenderReceiverTest, VideoReceiverCanGetParametersWithSimulcast) { |
| 1380 | CreateVideoRtpReceiverWithSimulcast({}, 2); |
| 1381 | |
| 1382 | RtpParameters params = video_rtp_receiver_->GetParameters(); |
| 1383 | EXPECT_EQ(2u, params.encodings.size()); |
| 1384 | |
| 1385 | DestroyVideoRtpReceiver(); |
| 1386 | } |
| 1387 | |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1388 | // Test that makes sure that a video track content hint translates to the proper |
| 1389 | // value for sources that are not screencast. |
| 1390 | TEST_F(RtpSenderReceiverTest, PropagatesVideoTrackContentHint) { |
| 1391 | CreateVideoRtpSender(); |
| 1392 | |
| 1393 | video_track_->set_enabled(true); |
| 1394 | |
| 1395 | // |video_track_| is not screencast by default. |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1396 | EXPECT_EQ(false, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1397 | // No content hint should be set by default. |
| 1398 | EXPECT_EQ(VideoTrackInterface::ContentHint::kNone, |
| 1399 | video_track_->content_hint()); |
| 1400 | // Setting detailed should turn a non-screencast source into screencast mode. |
| 1401 | video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1402 | EXPECT_EQ(true, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1403 | // Removing the content hint should turn the track back into non-screencast |
| 1404 | // mode. |
| 1405 | video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1406 | EXPECT_EQ(false, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1407 | // Setting fluid should remain in non-screencast mode (its default). |
| 1408 | video_track_->set_content_hint(VideoTrackInterface::ContentHint::kFluid); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1409 | EXPECT_EQ(false, video_media_channel_->options().is_screencast); |
Harald Alvestrand | c19ab07 | 2018-06-18 08:53:10 +0200 | [diff] [blame] | 1410 | // Setting text should have the same effect as Detailed |
| 1411 | video_track_->set_content_hint(VideoTrackInterface::ContentHint::kText); |
| 1412 | EXPECT_EQ(true, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1413 | |
| 1414 | DestroyVideoRtpSender(); |
| 1415 | } |
| 1416 | |
| 1417 | // Test that makes sure that a video track content hint translates to the proper |
| 1418 | // value for screencast sources. |
| 1419 | TEST_F(RtpSenderReceiverTest, |
| 1420 | PropagatesVideoTrackContentHintForScreencastSource) { |
| 1421 | CreateVideoRtpSender(true); |
| 1422 | |
| 1423 | video_track_->set_enabled(true); |
| 1424 | |
| 1425 | // |video_track_| with a screencast source should be screencast by default. |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1426 | EXPECT_EQ(true, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1427 | // No content hint should be set by default. |
| 1428 | EXPECT_EQ(VideoTrackInterface::ContentHint::kNone, |
| 1429 | video_track_->content_hint()); |
| 1430 | // Setting fluid should turn a screencast source into non-screencast mode. |
| 1431 | video_track_->set_content_hint(VideoTrackInterface::ContentHint::kFluid); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1432 | EXPECT_EQ(false, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1433 | // Removing the content hint should turn the track back into screencast mode. |
| 1434 | video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1435 | EXPECT_EQ(true, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1436 | // Setting detailed should still remain in screencast mode (its default). |
| 1437 | video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1438 | EXPECT_EQ(true, video_media_channel_->options().is_screencast); |
Harald Alvestrand | c19ab07 | 2018-06-18 08:53:10 +0200 | [diff] [blame] | 1439 | // Setting text should have the same effect as Detailed |
| 1440 | video_track_->set_content_hint(VideoTrackInterface::ContentHint::kText); |
| 1441 | EXPECT_EQ(true, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1442 | |
| 1443 | DestroyVideoRtpSender(); |
| 1444 | } |
| 1445 | |
| 1446 | // Test that makes sure any content hints that are set on a track before |
| 1447 | // VideoRtpSender is ready to send are still applied when it gets ready to send. |
| 1448 | TEST_F(RtpSenderReceiverTest, |
| 1449 | PropagatesVideoTrackContentHintSetBeforeEnabling) { |
| 1450 | AddVideoTrack(); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1451 | std::unique_ptr<MockSetStreamsObserver> set_streams_observer = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 1452 | std::make_unique<MockSetStreamsObserver>(); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1453 | // Setting detailed overrides the default non-screencast mode. This should be |
| 1454 | // applied even if the track is set on construction. |
| 1455 | video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1456 | video_rtp_sender_ = VideoRtpSender::Create(worker_thread_, video_track_->id(), |
| 1457 | set_streams_observer.get()); |
Steve Anton | 111fdfd | 2018-06-25 13:03:36 -0700 | [diff] [blame] | 1458 | ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_)); |
Guido Urdaneta | 1ff16c8 | 2019-05-20 19:31:53 +0200 | [diff] [blame] | 1459 | EXPECT_CALL(*set_streams_observer, OnSetStreams()); |
| 1460 | video_rtp_sender_->SetStreams({local_stream_->id()}); |
Amit Hilbuch | dd9390c | 2018-11-13 16:26:05 -0800 | [diff] [blame] | 1461 | video_rtp_sender_->SetMediaChannel(video_media_channel_); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1462 | video_track_->set_enabled(true); |
| 1463 | |
| 1464 | // Sender is not ready to send (no SSRC) so no option should have been set. |
Danil Chapovalov | 66cadcc | 2018-06-19 16:47:43 +0200 | [diff] [blame] | 1465 | EXPECT_EQ(absl::nullopt, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1466 | |
| 1467 | // Verify that the content hint is accounted for when video_rtp_sender_ does |
| 1468 | // get enabled. |
| 1469 | video_rtp_sender_->SetSsrc(kVideoSsrc); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1470 | EXPECT_EQ(true, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1471 | |
| 1472 | // And removing the hint should go back to false (to verify that false was |
| 1473 | // default correctly). |
| 1474 | video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone); |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1475 | EXPECT_EQ(false, video_media_channel_->options().is_screencast); |
pbos | 5214a0a | 2016-12-16 15:39:11 -0800 | [diff] [blame] | 1476 | |
| 1477 | DestroyVideoRtpSender(); |
| 1478 | } |
| 1479 | |
deadbeef | 20cb0c1 | 2017-02-01 20:27:00 -0800 | [diff] [blame] | 1480 | TEST_F(RtpSenderReceiverTest, AudioSenderHasDtmfSender) { |
| 1481 | CreateAudioRtpSender(); |
| 1482 | EXPECT_NE(nullptr, audio_rtp_sender_->GetDtmfSender()); |
| 1483 | } |
| 1484 | |
| 1485 | TEST_F(RtpSenderReceiverTest, VideoSenderDoesNotHaveDtmfSender) { |
| 1486 | CreateVideoRtpSender(); |
| 1487 | EXPECT_EQ(nullptr, video_rtp_sender_->GetDtmfSender()); |
| 1488 | } |
| 1489 | |
| 1490 | // Test that the DTMF sender is really using |voice_channel_|, and thus returns |
| 1491 | // true/false from CanSendDtmf based on what |voice_channel_| returns. |
| 1492 | TEST_F(RtpSenderReceiverTest, CanInsertDtmf) { |
| 1493 | AddDtmfCodec(); |
| 1494 | CreateAudioRtpSender(); |
| 1495 | auto dtmf_sender = audio_rtp_sender_->GetDtmfSender(); |
| 1496 | ASSERT_NE(nullptr, dtmf_sender); |
| 1497 | EXPECT_TRUE(dtmf_sender->CanInsertDtmf()); |
| 1498 | } |
| 1499 | |
| 1500 | TEST_F(RtpSenderReceiverTest, CanNotInsertDtmf) { |
| 1501 | CreateAudioRtpSender(); |
| 1502 | auto dtmf_sender = audio_rtp_sender_->GetDtmfSender(); |
| 1503 | ASSERT_NE(nullptr, dtmf_sender); |
| 1504 | // DTMF codec has not been added, as it was in the above test. |
| 1505 | EXPECT_FALSE(dtmf_sender->CanInsertDtmf()); |
| 1506 | } |
| 1507 | |
| 1508 | TEST_F(RtpSenderReceiverTest, InsertDtmf) { |
| 1509 | AddDtmfCodec(); |
| 1510 | CreateAudioRtpSender(); |
| 1511 | auto dtmf_sender = audio_rtp_sender_->GetDtmfSender(); |
| 1512 | ASSERT_NE(nullptr, dtmf_sender); |
| 1513 | |
| 1514 | EXPECT_EQ(0U, voice_media_channel_->dtmf_info_queue().size()); |
| 1515 | |
| 1516 | // Insert DTMF |
| 1517 | const int expected_duration = 90; |
| 1518 | dtmf_sender->InsertDtmf("012", expected_duration, 100); |
| 1519 | |
| 1520 | // Verify |
| 1521 | ASSERT_EQ_WAIT(3U, voice_media_channel_->dtmf_info_queue().size(), |
| 1522 | kDefaultTimeout); |
| 1523 | const uint32_t send_ssrc = |
| 1524 | voice_media_channel_->send_streams()[0].first_ssrc(); |
| 1525 | EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[0], |
| 1526 | send_ssrc, 0, expected_duration)); |
| 1527 | EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[1], |
| 1528 | send_ssrc, 1, expected_duration)); |
| 1529 | EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[2], |
| 1530 | send_ssrc, 2, expected_duration)); |
| 1531 | } |
| 1532 | |
| 1533 | // Make sure the signal from "GetOnDestroyedSignal()" fires when the sender is |
| 1534 | // destroyed, which is needed for the DTMF sender. |
| 1535 | TEST_F(RtpSenderReceiverTest, TestOnDestroyedSignal) { |
| 1536 | CreateAudioRtpSender(); |
| 1537 | EXPECT_FALSE(audio_sender_destroyed_signal_fired_); |
| 1538 | audio_rtp_sender_ = nullptr; |
| 1539 | EXPECT_TRUE(audio_sender_destroyed_signal_fired_); |
| 1540 | } |
| 1541 | |
Benjamin Wright | 84583f6 | 2018-10-04 14:22:34 -0700 | [diff] [blame] | 1542 | // Validate that the default FrameEncryptor setting is nullptr. |
| 1543 | TEST_F(RtpSenderReceiverTest, AudioSenderCanSetFrameEncryptor) { |
| 1544 | CreateAudioRtpSender(); |
| 1545 | rtc::scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor( |
| 1546 | new FakeFrameEncryptor()); |
| 1547 | EXPECT_EQ(nullptr, audio_rtp_sender_->GetFrameEncryptor()); |
| 1548 | audio_rtp_sender_->SetFrameEncryptor(fake_frame_encryptor); |
| 1549 | EXPECT_EQ(fake_frame_encryptor.get(), |
| 1550 | audio_rtp_sender_->GetFrameEncryptor().get()); |
| 1551 | } |
| 1552 | |
Benjamin Wright | c462a6e | 2018-10-26 13:16:16 -0700 | [diff] [blame] | 1553 | // Validate that setting a FrameEncryptor after the send stream is stopped does |
| 1554 | // nothing. |
| 1555 | TEST_F(RtpSenderReceiverTest, AudioSenderCannotSetFrameEncryptorAfterStop) { |
| 1556 | CreateAudioRtpSender(); |
| 1557 | rtc::scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor( |
| 1558 | new FakeFrameEncryptor()); |
| 1559 | EXPECT_EQ(nullptr, audio_rtp_sender_->GetFrameEncryptor()); |
| 1560 | audio_rtp_sender_->Stop(); |
| 1561 | audio_rtp_sender_->SetFrameEncryptor(fake_frame_encryptor); |
| 1562 | // TODO(webrtc:9926) - Validate media channel not set once fakes updated. |
| 1563 | } |
| 1564 | |
Benjamin Wright | 84583f6 | 2018-10-04 14:22:34 -0700 | [diff] [blame] | 1565 | // Validate that the default FrameEncryptor setting is nullptr. |
| 1566 | TEST_F(RtpSenderReceiverTest, AudioReceiverCanSetFrameDecryptor) { |
| 1567 | CreateAudioRtpReceiver(); |
| 1568 | rtc::scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor( |
| 1569 | new FakeFrameDecryptor()); |
| 1570 | EXPECT_EQ(nullptr, audio_rtp_receiver_->GetFrameDecryptor()); |
| 1571 | audio_rtp_receiver_->SetFrameDecryptor(fake_frame_decryptor); |
| 1572 | EXPECT_EQ(fake_frame_decryptor.get(), |
| 1573 | audio_rtp_receiver_->GetFrameDecryptor().get()); |
| 1574 | } |
| 1575 | |
Benjamin Wright | c462a6e | 2018-10-26 13:16:16 -0700 | [diff] [blame] | 1576 | // Validate that the default FrameEncryptor setting is nullptr. |
| 1577 | TEST_F(RtpSenderReceiverTest, AudioReceiverCannotSetFrameDecryptorAfterStop) { |
| 1578 | CreateAudioRtpReceiver(); |
| 1579 | rtc::scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor( |
| 1580 | new FakeFrameDecryptor()); |
| 1581 | EXPECT_EQ(nullptr, audio_rtp_receiver_->GetFrameDecryptor()); |
| 1582 | audio_rtp_receiver_->Stop(); |
| 1583 | audio_rtp_receiver_->SetFrameDecryptor(fake_frame_decryptor); |
| 1584 | // TODO(webrtc:9926) - Validate media channel not set once fakes updated. |
| 1585 | } |
| 1586 | |
| 1587 | // Validate that the default FrameEncryptor setting is nullptr. |
| 1588 | TEST_F(RtpSenderReceiverTest, VideoSenderCanSetFrameEncryptor) { |
| 1589 | CreateVideoRtpSender(); |
| 1590 | rtc::scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor( |
| 1591 | new FakeFrameEncryptor()); |
| 1592 | EXPECT_EQ(nullptr, video_rtp_sender_->GetFrameEncryptor()); |
| 1593 | video_rtp_sender_->SetFrameEncryptor(fake_frame_encryptor); |
| 1594 | EXPECT_EQ(fake_frame_encryptor.get(), |
| 1595 | video_rtp_sender_->GetFrameEncryptor().get()); |
| 1596 | } |
| 1597 | |
| 1598 | // Validate that setting a FrameEncryptor after the send stream is stopped does |
| 1599 | // nothing. |
| 1600 | TEST_F(RtpSenderReceiverTest, VideoSenderCannotSetFrameEncryptorAfterStop) { |
| 1601 | CreateVideoRtpSender(); |
| 1602 | rtc::scoped_refptr<FrameEncryptorInterface> fake_frame_encryptor( |
| 1603 | new FakeFrameEncryptor()); |
| 1604 | EXPECT_EQ(nullptr, video_rtp_sender_->GetFrameEncryptor()); |
| 1605 | video_rtp_sender_->Stop(); |
| 1606 | video_rtp_sender_->SetFrameEncryptor(fake_frame_encryptor); |
| 1607 | // TODO(webrtc:9926) - Validate media channel not set once fakes updated. |
| 1608 | } |
| 1609 | |
| 1610 | // Validate that the default FrameEncryptor setting is nullptr. |
| 1611 | TEST_F(RtpSenderReceiverTest, VideoReceiverCanSetFrameDecryptor) { |
| 1612 | CreateVideoRtpReceiver(); |
| 1613 | rtc::scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor( |
| 1614 | new FakeFrameDecryptor()); |
| 1615 | EXPECT_EQ(nullptr, video_rtp_receiver_->GetFrameDecryptor()); |
| 1616 | video_rtp_receiver_->SetFrameDecryptor(fake_frame_decryptor); |
| 1617 | EXPECT_EQ(fake_frame_decryptor.get(), |
| 1618 | video_rtp_receiver_->GetFrameDecryptor().get()); |
| 1619 | } |
| 1620 | |
| 1621 | // Validate that the default FrameEncryptor setting is nullptr. |
| 1622 | TEST_F(RtpSenderReceiverTest, VideoReceiverCannotSetFrameDecryptorAfterStop) { |
| 1623 | CreateVideoRtpReceiver(); |
| 1624 | rtc::scoped_refptr<FrameDecryptorInterface> fake_frame_decryptor( |
| 1625 | new FakeFrameDecryptor()); |
| 1626 | EXPECT_EQ(nullptr, video_rtp_receiver_->GetFrameDecryptor()); |
| 1627 | video_rtp_receiver_->Stop(); |
| 1628 | video_rtp_receiver_->SetFrameDecryptor(fake_frame_decryptor); |
| 1629 | // TODO(webrtc:9926) - Validate media channel not set once fakes updated. |
| 1630 | } |
| 1631 | |
Amit Hilbuch | 619b294 | 2019-02-26 15:55:19 -0800 | [diff] [blame] | 1632 | // Checks that calling the internal methods for get/set parameters do not |
| 1633 | // invalidate any parameters retreived by clients. |
| 1634 | TEST_F(RtpSenderReceiverTest, |
| 1635 | InternalParameterMethodsDoNotInvalidateTransaction) { |
| 1636 | CreateVideoRtpSender(); |
| 1637 | RtpParameters parameters = video_rtp_sender_->GetParameters(); |
| 1638 | RtpParameters new_parameters = video_rtp_sender_->GetParametersInternal(); |
| 1639 | new_parameters.encodings[0].active = false; |
| 1640 | video_rtp_sender_->SetParametersInternal(new_parameters); |
| 1641 | new_parameters.encodings[0].active = true; |
| 1642 | video_rtp_sender_->SetParametersInternal(new_parameters); |
| 1643 | parameters.encodings[0].active = false; |
| 1644 | EXPECT_TRUE(video_rtp_sender_->SetParameters(parameters).ok()); |
| 1645 | } |
| 1646 | |
Amit Hilbuch | 2297d33 | 2019-02-19 12:49:22 -0800 | [diff] [blame] | 1647 | // Helper method for syntactic sugar for accepting a vector with '{}' notation. |
| 1648 | std::pair<RidList, RidList> CreatePairOfRidVectors( |
| 1649 | const std::vector<std::string>& first, |
| 1650 | const std::vector<std::string>& second) { |
| 1651 | return std::make_pair(first, second); |
| 1652 | } |
| 1653 | |
| 1654 | // These parameters are used to test disabling simulcast layers. |
| 1655 | const std::pair<RidList, RidList> kDisableSimulcastLayersParameters[] = { |
| 1656 | // Tests removing the first layer. This is a special case because |
| 1657 | // the first layer's SSRC is also the 'primary' SSRC used to associate the |
| 1658 | // parameters to the media channel. |
| 1659 | CreatePairOfRidVectors({"1", "2", "3", "4"}, {"1"}), |
| 1660 | // Tests removing some layers. |
| 1661 | CreatePairOfRidVectors({"1", "2", "3", "4"}, {"2", "4"}), |
| 1662 | // Tests simulcast rejected scenario all layers except first are rejected. |
| 1663 | CreatePairOfRidVectors({"1", "2", "3", "4"}, {"2", "3", "4"}), |
| 1664 | // Tests removing all layers. |
| 1665 | CreatePairOfRidVectors({"1", "2", "3", "4"}, {"1", "2", "3", "4"}), |
| 1666 | }; |
| 1667 | |
| 1668 | // Runs test for disabling layers on a sender without a media engine set. |
| 1669 | TEST_P(RtpSenderReceiverTest, DisableSimulcastLayersWithoutMediaEngine) { |
| 1670 | auto parameter = GetParam(); |
| 1671 | RunDisableSimulcastLayersWithoutMediaEngineTest(parameter.first, |
| 1672 | parameter.second); |
| 1673 | } |
| 1674 | |
| 1675 | // Runs test for disabling layers on a sender with a media engine set. |
| 1676 | TEST_P(RtpSenderReceiverTest, DisableSimulcastLayersWithMediaEngine) { |
| 1677 | auto parameter = GetParam(); |
| 1678 | RunDisableSimulcastLayersWithMediaEngineTest(parameter.first, |
| 1679 | parameter.second); |
| 1680 | } |
| 1681 | |
| 1682 | INSTANTIATE_TEST_SUITE_P( |
| 1683 | DisableSimulcastLayersInSender, |
| 1684 | RtpSenderReceiverTest, |
| 1685 | ::testing::ValuesIn(kDisableSimulcastLayersParameters)); |
| 1686 | |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 1687 | } // namespace webrtc |