pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "test/call_test.h" |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 12 | |
| 13 | #include <algorithm> |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 14 | #include <memory> |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 15 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 16 | #include "api/audio_codecs/builtin_audio_decoder_factory.h" |
| 17 | #include "api/audio_codecs/builtin_audio_encoder_factory.h" |
Danil Chapovalov | a92e624 | 2019-04-18 10:58:56 +0200 | [diff] [blame] | 18 | #include "api/task_queue/default_task_queue_factory.h" |
Danil Chapovalov | 44db436 | 2019-09-30 04:16:28 +0200 | [diff] [blame] | 19 | #include "api/task_queue/task_queue_base.h" |
Jiawei Ou | c2ebe21 | 2018-11-08 10:02:56 -0800 | [diff] [blame] | 20 | #include "api/video/builtin_video_bitrate_allocator_factory.h" |
Niels Möller | 0a8f435 | 2018-05-18 11:37:23 +0200 | [diff] [blame] | 21 | #include "api/video_codecs/video_encoder_config.h" |
Artem Titov | 4e199e9 | 2018-08-20 13:30:39 +0200 | [diff] [blame] | 22 | #include "call/fake_network_pipe.h" |
Artem Titov | 4e199e9 | 2018-08-20 13:30:39 +0200 | [diff] [blame] | 23 | #include "call/simulated_network.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 24 | #include "modules/audio_mixer/audio_mixer_impl.h" |
| 25 | #include "rtc_base/checks.h" |
| 26 | #include "rtc_base/event.h" |
Niels Möller | 4db138e | 2018-04-19 09:04:13 +0200 | [diff] [blame] | 27 | #include "test/fake_encoder.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 28 | #include "test/testsupport/file_utils.h" |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 29 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 30 | namespace webrtc { |
| 31 | namespace test { |
| 32 | |
| 33 | CallTest::CallTest() |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 34 | : clock_(Clock::GetRealTimeClock()), |
Danil Chapovalov | a92e624 | 2019-04-18 10:58:56 +0200 | [diff] [blame] | 35 | task_queue_factory_(CreateDefaultTaskQueueFactory()), |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 36 | send_event_log_(std::make_unique<RtcEventLogNull>()), |
| 37 | recv_event_log_(std::make_unique<RtcEventLogNull>()), |
Anton Sukhanov | 4f08faa | 2019-05-21 11:12:57 -0700 | [diff] [blame] | 38 | audio_send_config_(/*send_transport=*/nullptr, MediaTransportConfig()), |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 39 | audio_send_stream_(nullptr), |
Erik Språng | 6a32de4 | 2019-01-09 15:46:36 +0100 | [diff] [blame] | 40 | frame_generator_capturer_(nullptr), |
Niels Möller | 4db138e | 2018-04-19 09:04:13 +0200 | [diff] [blame] | 41 | fake_encoder_factory_([this]() { |
Ilya Nikolaevskiy | b0588e6 | 2018-08-27 14:12:27 +0200 | [diff] [blame] | 42 | std::unique_ptr<FakeEncoder> fake_encoder; |
| 43 | if (video_encoder_configs_[0].codec_type == kVideoCodecVP8) { |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 44 | fake_encoder = std::make_unique<FakeVP8Encoder>(clock_); |
Ilya Nikolaevskiy | b0588e6 | 2018-08-27 14:12:27 +0200 | [diff] [blame] | 45 | } else { |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 46 | fake_encoder = std::make_unique<FakeEncoder>(clock_); |
Ilya Nikolaevskiy | b0588e6 | 2018-08-27 14:12:27 +0200 | [diff] [blame] | 47 | } |
| 48 | fake_encoder->SetMaxBitrate(fake_encoder_max_bitrate_); |
| 49 | return fake_encoder; |
Niels Möller | 4db138e | 2018-04-19 09:04:13 +0200 | [diff] [blame] | 50 | }), |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 51 | fake_decoder_factory_([]() { return std::make_unique<FakeDecoder>(); }), |
Jiawei Ou | c2ebe21 | 2018-11-08 10:02:56 -0800 | [diff] [blame] | 52 | bitrate_allocator_factory_(CreateBuiltinVideoBitrateAllocatorFactory()), |
Stefan Holmer | 04cb763 | 2016-01-14 20:34:30 +0100 | [diff] [blame] | 53 | num_video_streams_(1), |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 54 | num_audio_streams_(0), |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 55 | num_flexfec_streams_(0), |
Niels Möller | 2784a03 | 2018-03-28 14:16:04 +0200 | [diff] [blame] | 56 | audio_decoder_factory_(CreateBuiltinAudioDecoderFactory()), |
| 57 | audio_encoder_factory_(CreateBuiltinAudioEncoderFactory()), |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 58 | task_queue_("CallTestTaskQueue") {} |
pbos@webrtc.org | 32452b2 | 2014-10-22 12:15:24 +0000 | [diff] [blame] | 59 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 60 | CallTest::~CallTest() { |
Tommi | 31d1bce | 2019-08-27 11:34:20 +0200 | [diff] [blame] | 61 | // In most cases the task_queue_ should have been stopped by now, assuming |
| 62 | // the regular path of using CallTest to call PerformTest (followed by |
| 63 | // cleanup). However, there are some tests that don't use the class that way |
| 64 | // hence we need this special handling for cleaning up. |
| 65 | if (task_queue_.IsRunning()) { |
| 66 | task_queue_.SendTask([this]() { |
| 67 | fake_send_audio_device_ = nullptr; |
| 68 | fake_recv_audio_device_ = nullptr; |
| 69 | video_sources_.clear(); |
| 70 | }); |
| 71 | } |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 72 | } |
| 73 | |
Elad Alon | d8d3248 | 2019-02-18 23:45:57 +0100 | [diff] [blame] | 74 | void CallTest::RegisterRtpExtension(const RtpExtension& extension) { |
| 75 | for (const RtpExtension& registered_extension : rtp_extensions_) { |
| 76 | if (registered_extension.id == extension.id) { |
| 77 | ASSERT_EQ(registered_extension.uri, extension.uri) |
| 78 | << "Different URIs associated with ID " << extension.id << "."; |
| 79 | ASSERT_EQ(registered_extension.encrypt, extension.encrypt) |
| 80 | << "Encryption mismatch associated with ID " << extension.id << "."; |
| 81 | return; |
| 82 | } else { // Different IDs. |
| 83 | // Different IDs referring to the same extension probably indicate |
| 84 | // a mistake in the test. |
| 85 | ASSERT_FALSE(registered_extension.uri == extension.uri && |
| 86 | registered_extension.encrypt == extension.encrypt) |
| 87 | << "URI " << extension.uri |
| 88 | << (extension.encrypt ? " with " : " without ") |
| 89 | << "encryption already registered with a different " |
| 90 | << "ID (" << extension.id << " vs. " << registered_extension.id |
| 91 | << ")."; |
| 92 | } |
| 93 | } |
| 94 | rtp_extensions_.push_back(extension); |
| 95 | } |
| 96 | |
stefan | e74eef1 | 2016-01-08 06:47:13 -0800 | [diff] [blame] | 97 | void CallTest::RunBaseTest(BaseTest* test) { |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 98 | task_queue_.SendTask([this, test]() { |
| 99 | num_video_streams_ = test->GetNumVideoStreams(); |
| 100 | num_audio_streams_ = test->GetNumAudioStreams(); |
| 101 | num_flexfec_streams_ = test->GetNumFlexfecStreams(); |
| 102 | RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0); |
Sebastian Jansson | 7258224 | 2018-07-13 13:19:42 +0200 | [diff] [blame] | 103 | Call::Config send_config(send_event_log_.get()); |
Niels Möller | de8e6e6 | 2018-11-13 15:10:33 +0100 | [diff] [blame] | 104 | test->ModifySenderBitrateConfig(&send_config.bitrate_config); |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 105 | if (num_audio_streams_ > 0) { |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 106 | CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer()); |
| 107 | test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(), |
| 108 | fake_recv_audio_device_.get()); |
Ivo Creusen | 62337e5 | 2018-01-09 14:17:33 +0100 | [diff] [blame] | 109 | apm_send_ = AudioProcessingBuilder().Create(); |
| 110 | apm_recv_ = AudioProcessingBuilder().Create(); |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 111 | EXPECT_EQ(0, fake_send_audio_device_->Init()); |
| 112 | EXPECT_EQ(0, fake_recv_audio_device_->Init()); |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 113 | AudioState::Config audio_state_config; |
aleloi | 10111bc | 2016-11-17 06:48:48 -0800 | [diff] [blame] | 114 | audio_state_config.audio_mixer = AudioMixerImpl::Create(); |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 115 | audio_state_config.audio_processing = apm_send_; |
Fredrik Solenberg | 2a87797 | 2017-12-15 16:42:15 +0100 | [diff] [blame] | 116 | audio_state_config.audio_device_module = fake_send_audio_device_; |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 117 | send_config.audio_state = AudioState::Create(audio_state_config); |
Fredrik Solenberg | d319534 | 2017-11-21 20:33:05 +0100 | [diff] [blame] | 118 | fake_send_audio_device_->RegisterAudioCallback( |
| 119 | send_config.audio_state->audio_transport()); |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 120 | } |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 121 | CreateSenderCall(send_config); |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 122 | if (test->ShouldCreateReceivers()) { |
Sebastian Jansson | 7258224 | 2018-07-13 13:19:42 +0200 | [diff] [blame] | 123 | Call::Config recv_config(recv_event_log_.get()); |
Niels Möller | de8e6e6 | 2018-11-13 15:10:33 +0100 | [diff] [blame] | 124 | test->ModifyReceiverBitrateConfig(&recv_config.bitrate_config); |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 125 | if (num_audio_streams_ > 0) { |
| 126 | AudioState::Config audio_state_config; |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 127 | audio_state_config.audio_mixer = AudioMixerImpl::Create(); |
| 128 | audio_state_config.audio_processing = apm_recv_; |
Fredrik Solenberg | 2a87797 | 2017-12-15 16:42:15 +0100 | [diff] [blame] | 129 | audio_state_config.audio_device_module = fake_recv_audio_device_; |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 130 | recv_config.audio_state = AudioState::Create(audio_state_config); |
Fredrik Solenberg | d319534 | 2017-11-21 20:33:05 +0100 | [diff] [blame] | 131 | fake_recv_audio_device_->RegisterAudioCallback( |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 132 | recv_config.audio_state->audio_transport()); |
| 133 | } |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 134 | CreateReceiverCall(recv_config); |
| 135 | } |
| 136 | test->OnCallsCreated(sender_call_.get(), receiver_call_.get()); |
Danil Chapovalov | 44db436 | 2019-09-30 04:16:28 +0200 | [diff] [blame] | 137 | receive_transport_ = test->CreateReceiveTransport(&task_queue_); |
| 138 | send_transport_ = |
| 139 | test->CreateSendTransport(&task_queue_, sender_call_.get()); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 140 | |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 141 | if (test->ShouldCreateReceivers()) { |
| 142 | send_transport_->SetReceiver(receiver_call_->Receiver()); |
| 143 | receive_transport_->SetReceiver(sender_call_->Receiver()); |
| 144 | if (num_video_streams_ > 0) |
| 145 | receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); |
| 146 | if (num_audio_streams_ > 0) |
| 147 | receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp); |
| 148 | } else { |
| 149 | // Sender-only call delivers to itself. |
| 150 | send_transport_->SetReceiver(sender_call_->Receiver()); |
| 151 | receive_transport_->SetReceiver(nullptr); |
| 152 | } |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 153 | |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 154 | CreateSendConfig(num_video_streams_, num_audio_streams_, |
| 155 | num_flexfec_streams_, send_transport_.get()); |
| 156 | if (test->ShouldCreateReceivers()) { |
| 157 | CreateMatchingReceiveConfigs(receive_transport_.get()); |
| 158 | } |
| 159 | if (num_video_streams_ > 0) { |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 160 | test->ModifyVideoConfigs(GetVideoSendConfig(), &video_receive_configs_, |
| 161 | GetVideoEncoderConfig()); |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 162 | } |
| 163 | if (num_audio_streams_ > 0) { |
| 164 | test->ModifyAudioConfigs(&audio_send_config_, &audio_receive_configs_); |
| 165 | } |
| 166 | if (num_flexfec_streams_ > 0) { |
| 167 | test->ModifyFlexfecConfigs(&flexfec_receive_configs_); |
| 168 | } |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 169 | |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 170 | if (num_flexfec_streams_ > 0) { |
| 171 | CreateFlexfecStreams(); |
| 172 | test->OnFlexfecStreamsCreated(flexfec_receive_streams_); |
| 173 | } |
| 174 | if (num_video_streams_ > 0) { |
| 175 | CreateVideoStreams(); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 176 | test->OnVideoStreamsCreated(GetVideoSendStream(), video_receive_streams_); |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 177 | } |
| 178 | if (num_audio_streams_ > 0) { |
| 179 | CreateAudioStreams(); |
| 180 | test->OnAudioStreamsCreated(audio_send_stream_, audio_receive_streams_); |
| 181 | } |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 182 | |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 183 | if (num_video_streams_ > 0) { |
| 184 | int width = kDefaultWidth; |
| 185 | int height = kDefaultHeight; |
| 186 | int frame_rate = kDefaultFramerate; |
| 187 | test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate); |
Åsa Persson | cb7eddb | 2018-11-05 14:11:44 +0100 | [diff] [blame] | 188 | test->ModifyVideoDegradationPreference(°radation_preference_); |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 189 | CreateFrameGeneratorCapturer(frame_rate, width, height); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 190 | test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_); |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 191 | } |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 192 | |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 193 | Start(); |
| 194 | }); |
| 195 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 196 | test->PerformTest(); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 197 | |
Fredrik Solenberg | 73276ad | 2017-09-14 14:46:47 +0200 | [diff] [blame] | 198 | task_queue_.SendTask([this, test]() { |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 199 | Stop(); |
Fredrik Solenberg | 73276ad | 2017-09-14 14:46:47 +0200 | [diff] [blame] | 200 | test->OnStreamsStopped(); |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 201 | DestroyStreams(); |
| 202 | send_transport_.reset(); |
| 203 | receive_transport_.reset(); |
Tommi | 31d1bce | 2019-08-27 11:34:20 +0200 | [diff] [blame] | 204 | |
Erik Språng | 6a32de4 | 2019-01-09 15:46:36 +0100 | [diff] [blame] | 205 | frame_generator_capturer_ = nullptr; |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 206 | DestroyCalls(); |
Tommi | 31d1bce | 2019-08-27 11:34:20 +0200 | [diff] [blame] | 207 | |
| 208 | fake_send_audio_device_ = nullptr; |
| 209 | fake_recv_audio_device_ = nullptr; |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 210 | }); |
Tommi | 31d1bce | 2019-08-27 11:34:20 +0200 | [diff] [blame] | 211 | |
| 212 | // To avoid a race condition during destruction, which can happen while |
| 213 | // a derived class is being destructed but pending tasks might still run |
| 214 | // because the |task_queue_| is still in scope, we stop the TQ here. |
| 215 | // Note that tests should not be posting more tasks during teardown but |
| 216 | // as is, that's hard to control with the current test harness. E.g. transport |
| 217 | // classes continue to issue callbacks (e.g. OnSendRtp) during teardown, which |
| 218 | // can have a ripple effect. |
| 219 | task_queue_.Stop(); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 220 | } |
| 221 | |
Sebastian Jansson | 8e6602f | 2018-07-13 10:43:20 +0200 | [diff] [blame] | 222 | void CallTest::CreateCalls() { |
| 223 | CreateCalls(Call::Config(send_event_log_.get()), |
| 224 | Call::Config(recv_event_log_.get())); |
| 225 | } |
| 226 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 227 | void CallTest::CreateCalls(const Call::Config& sender_config, |
| 228 | const Call::Config& receiver_config) { |
| 229 | CreateSenderCall(sender_config); |
| 230 | CreateReceiverCall(receiver_config); |
| 231 | } |
| 232 | |
Sebastian Jansson | 8e6602f | 2018-07-13 10:43:20 +0200 | [diff] [blame] | 233 | void CallTest::CreateSenderCall() { |
| 234 | CreateSenderCall(Call::Config(send_event_log_.get())); |
| 235 | } |
| 236 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 237 | void CallTest::CreateSenderCall(const Call::Config& config) { |
Ying Wang | cab77fd | 2019-04-16 11:12:49 +0200 | [diff] [blame] | 238 | auto sender_config = config; |
Danil Chapovalov | 53d45ba | 2019-07-03 14:56:33 +0200 | [diff] [blame] | 239 | sender_config.task_queue_factory = task_queue_factory_.get(); |
Ying Wang | cab77fd | 2019-04-16 11:12:49 +0200 | [diff] [blame] | 240 | sender_config.network_state_predictor_factory = |
| 241 | network_state_predictor_factory_.get(); |
Sebastian Jansson | 1391ed2 | 2019-04-30 14:23:51 +0200 | [diff] [blame] | 242 | sender_config.network_controller_factory = network_controller_factory_.get(); |
Ying Wang | cab77fd | 2019-04-16 11:12:49 +0200 | [diff] [blame] | 243 | sender_call_.reset(Call::Create(sender_config)); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | void CallTest::CreateReceiverCall(const Call::Config& config) { |
Danil Chapovalov | 53d45ba | 2019-07-03 14:56:33 +0200 | [diff] [blame] | 247 | auto receiver_config = config; |
| 248 | receiver_config.task_queue_factory = task_queue_factory_.get(); |
| 249 | receiver_call_.reset(Call::Create(receiver_config)); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 250 | } |
| 251 | |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 252 | void CallTest::DestroyCalls() { |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 253 | sender_call_.reset(); |
| 254 | receiver_call_.reset(); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 10:49:27 +0200 | [diff] [blame] | 255 | } |
| 256 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 257 | void CallTest::CreateVideoSendConfig(VideoSendStream::Config* video_config, |
| 258 | size_t num_video_streams, |
| 259 | size_t num_used_ssrcs, |
| 260 | Transport* send_transport) { |
| 261 | RTC_DCHECK_LE(num_video_streams + num_used_ssrcs, kNumSsrcs); |
| 262 | *video_config = VideoSendStream::Config(send_transport); |
Niels Möller | 4db138e | 2018-04-19 09:04:13 +0200 | [diff] [blame] | 263 | video_config->encoder_settings.encoder_factory = &fake_encoder_factory_; |
Jiawei Ou | c2ebe21 | 2018-11-08 10:02:56 -0800 | [diff] [blame] | 264 | video_config->encoder_settings.bitrate_allocator_factory = |
| 265 | bitrate_allocator_factory_.get(); |
Niels Möller | 259a497 | 2018-04-05 15:36:51 +0200 | [diff] [blame] | 266 | video_config->rtp.payload_name = "FAKE"; |
| 267 | video_config->rtp.payload_type = kFakeVideoSendPayloadType; |
Johannes Kron | f7f13e0 | 2018-12-12 11:17:43 +0100 | [diff] [blame] | 268 | video_config->rtp.extmap_allow_mixed = true; |
Elad Alon | d8d3248 | 2019-02-18 23:45:57 +0100 | [diff] [blame] | 269 | AddRtpExtensionByUri(RtpExtension::kTransportSequenceNumberUri, |
| 270 | &video_config->rtp.extensions); |
| 271 | AddRtpExtensionByUri(RtpExtension::kVideoContentTypeUri, |
| 272 | &video_config->rtp.extensions); |
Elad Alon | ccb9b75 | 2019-02-19 13:01:31 +0100 | [diff] [blame] | 273 | AddRtpExtensionByUri(RtpExtension::kGenericFrameDescriptorUri00, |
| 274 | &video_config->rtp.extensions); |
| 275 | AddRtpExtensionByUri(RtpExtension::kGenericFrameDescriptorUri01, |
Elad Alon | d8d3248 | 2019-02-18 23:45:57 +0100 | [diff] [blame] | 276 | &video_config->rtp.extensions); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 277 | if (video_encoder_configs_.empty()) { |
| 278 | video_encoder_configs_.emplace_back(); |
| 279 | FillEncoderConfiguration(kVideoCodecGeneric, num_video_streams, |
| 280 | &video_encoder_configs_.back()); |
| 281 | } |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 282 | for (size_t i = 0; i < num_video_streams; ++i) |
| 283 | video_config->rtp.ssrcs.push_back(kVideoSendSsrcs[num_used_ssrcs + i]); |
Elad Alon | d8d3248 | 2019-02-18 23:45:57 +0100 | [diff] [blame] | 284 | AddRtpExtensionByUri(RtpExtension::kVideoRotationUri, |
| 285 | &video_config->rtp.extensions); |
| 286 | AddRtpExtensionByUri(RtpExtension::kColorSpaceUri, |
| 287 | &video_config->rtp.extensions); |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 288 | } |
| 289 | |
| 290 | void CallTest::CreateAudioAndFecSendConfigs(size_t num_audio_streams, |
| 291 | size_t num_flexfec_streams, |
| 292 | Transport* send_transport) { |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame] | 293 | RTC_DCHECK_LE(num_audio_streams, 1); |
| 294 | RTC_DCHECK_LE(num_flexfec_streams, 1); |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 295 | if (num_audio_streams > 0) { |
Niels Möller | 7d76a31 | 2018-10-26 12:57:07 +0200 | [diff] [blame] | 296 | AudioSendStream::Config audio_send_config(send_transport, |
Anton Sukhanov | 4f08faa | 2019-05-21 11:12:57 -0700 | [diff] [blame] | 297 | MediaTransportConfig()); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 298 | audio_send_config.rtp.ssrc = kAudioSendSsrc; |
| 299 | audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec( |
Oskar Sundbom | 3f6804d | 2017-11-16 10:54:58 +0100 | [diff] [blame] | 300 | kAudioSendPayloadType, {"opus", 48000, 2, {{"stereo", "1"}}}); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 301 | audio_send_config.encoder_factory = audio_encoder_factory_; |
| 302 | SetAudioConfig(audio_send_config); |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 303 | } |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 304 | |
| 305 | // TODO(brandtr): Update this when we support multistream protection. |
| 306 | if (num_flexfec_streams > 0) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 307 | SetSendFecConfig({kVideoSendSsrcs[0]}); |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 308 | } |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 309 | } |
| 310 | |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 311 | void CallTest::SetAudioConfig(const AudioSendStream::Config& config) { |
| 312 | audio_send_config_ = config; |
| 313 | } |
| 314 | |
| 315 | void CallTest::SetSendFecConfig(std::vector<uint32_t> video_send_ssrcs) { |
| 316 | GetVideoSendConfig()->rtp.flexfec.payload_type = kFlexfecPayloadType; |
| 317 | GetVideoSendConfig()->rtp.flexfec.ssrc = kFlexfecSendSsrc; |
| 318 | GetVideoSendConfig()->rtp.flexfec.protected_media_ssrcs = video_send_ssrcs; |
| 319 | } |
| 320 | |
| 321 | void CallTest::SetSendUlpFecConfig(VideoSendStream::Config* send_config) { |
| 322 | send_config->rtp.ulpfec.red_payload_type = kRedPayloadType; |
| 323 | send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType; |
| 324 | send_config->rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType; |
| 325 | } |
| 326 | |
| 327 | void CallTest::SetReceiveUlpFecConfig( |
| 328 | VideoReceiveStream::Config* receive_config) { |
| 329 | receive_config->rtp.red_payload_type = kRedPayloadType; |
| 330 | receive_config->rtp.ulpfec_payload_type = kUlpfecPayloadType; |
| 331 | receive_config->rtp.rtx_associated_payload_types[kRtxRedPayloadType] = |
| 332 | kRedPayloadType; |
| 333 | } |
| 334 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 335 | void CallTest::CreateSendConfig(size_t num_video_streams, |
| 336 | size_t num_audio_streams, |
| 337 | size_t num_flexfec_streams, |
| 338 | Transport* send_transport) { |
| 339 | if (num_video_streams > 0) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 340 | video_send_configs_.clear(); |
| 341 | video_send_configs_.emplace_back(nullptr); |
| 342 | CreateVideoSendConfig(&video_send_configs_.back(), num_video_streams, 0, |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 343 | send_transport); |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 344 | } |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 345 | CreateAudioAndFecSendConfigs(num_audio_streams, num_flexfec_streams, |
| 346 | send_transport); |
| 347 | } |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 348 | |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 349 | void CallTest::CreateMatchingVideoReceiveConfigs( |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 350 | const VideoSendStream::Config& video_send_config, |
| 351 | Transport* rtcp_send_transport) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 352 | CreateMatchingVideoReceiveConfigs(video_send_config, rtcp_send_transport, |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 353 | true, &fake_decoder_factory_, absl::nullopt, |
| 354 | false, 0); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 355 | } |
| 356 | |
| 357 | void CallTest::CreateMatchingVideoReceiveConfigs( |
| 358 | const VideoSendStream::Config& video_send_config, |
| 359 | Transport* rtcp_send_transport, |
| 360 | bool send_side_bwe, |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 361 | VideoDecoderFactory* decoder_factory, |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 362 | absl::optional<size_t> decode_sub_stream, |
| 363 | bool receiver_reference_time_report, |
| 364 | int rtp_history_ms) { |
| 365 | AddMatchingVideoReceiveConfigs( |
| 366 | &video_receive_configs_, video_send_config, rtcp_send_transport, |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 367 | send_side_bwe, decoder_factory, decode_sub_stream, |
| 368 | receiver_reference_time_report, rtp_history_ms); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 369 | } |
| 370 | |
| 371 | void CallTest::AddMatchingVideoReceiveConfigs( |
| 372 | std::vector<VideoReceiveStream::Config>* receive_configs, |
| 373 | const VideoSendStream::Config& video_send_config, |
| 374 | Transport* rtcp_send_transport, |
| 375 | bool send_side_bwe, |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 376 | VideoDecoderFactory* decoder_factory, |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 377 | absl::optional<size_t> decode_sub_stream, |
| 378 | bool receiver_reference_time_report, |
| 379 | int rtp_history_ms) { |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 380 | RTC_DCHECK(!video_send_config.rtp.ssrcs.empty()); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 381 | VideoReceiveStream::Config default_config(rtcp_send_transport); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 382 | default_config.rtp.transport_cc = send_side_bwe; |
| 383 | default_config.rtp.local_ssrc = kReceiverLocalVideoSsrc; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 384 | for (const RtpExtension& extension : video_send_config.rtp.extensions) |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 385 | default_config.rtp.extensions.push_back(extension); |
| 386 | default_config.rtp.nack.rtp_history_ms = rtp_history_ms; |
| 387 | // Enable RTT calculation so NTP time estimator will work. |
| 388 | default_config.rtp.rtcp_xr.receiver_reference_time_report = |
| 389 | receiver_reference_time_report; |
| 390 | default_config.renderer = &fake_renderer_; |
| 391 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 392 | for (size_t i = 0; i < video_send_config.rtp.ssrcs.size(); ++i) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 393 | VideoReceiveStream::Config video_recv_config(default_config.Copy()); |
| 394 | video_recv_config.decoders.clear(); |
| 395 | if (!video_send_config.rtp.rtx.ssrcs.empty()) { |
| 396 | video_recv_config.rtp.rtx_ssrc = video_send_config.rtp.rtx.ssrcs[i]; |
| 397 | video_recv_config.rtp.rtx_associated_payload_types[kSendRtxPayloadType] = |
| 398 | video_send_config.rtp.payload_type; |
| 399 | } |
| 400 | video_recv_config.rtp.remote_ssrc = video_send_config.rtp.ssrcs[i]; |
| 401 | VideoReceiveStream::Decoder decoder; |
| 402 | |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 403 | decoder.payload_type = video_send_config.rtp.payload_type; |
| 404 | decoder.video_format = SdpVideoFormat(video_send_config.rtp.payload_name); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 405 | // Force fake decoders on non-selected simulcast streams. |
| 406 | if (!decode_sub_stream || i == *decode_sub_stream) { |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 407 | decoder.decoder_factory = decoder_factory; |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 408 | } else { |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 409 | decoder.decoder_factory = &fake_decoder_factory_; |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 410 | } |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 411 | video_recv_config.decoders.push_back(decoder); |
| 412 | receive_configs->emplace_back(std::move(video_recv_config)); |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 413 | } |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 414 | } |
| 415 | |
| 416 | void CallTest::CreateMatchingAudioAndFecConfigs( |
| 417 | Transport* rtcp_send_transport) { |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame] | 418 | RTC_DCHECK_GE(1, num_audio_streams_); |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 419 | if (num_audio_streams_ == 1) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 420 | CreateMatchingAudioConfigs(rtcp_send_transport, ""); |
pbos@webrtc.org | be9d2a4 | 2014-06-30 13:19:09 +0000 | [diff] [blame] | 421 | } |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 422 | |
| 423 | // TODO(brandtr): Update this when we support multistream protection. |
| 424 | RTC_DCHECK(num_flexfec_streams_ <= 1); |
| 425 | if (num_flexfec_streams_ == 1) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 426 | CreateMatchingFecConfig(rtcp_send_transport, *GetVideoSendConfig()); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 427 | for (const RtpExtension& extension : GetVideoSendConfig()->rtp.extensions) |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 428 | GetFlexFecConfig()->rtp_header_extensions.push_back(extension); |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 429 | } |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 430 | } |
| 431 | |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 432 | void CallTest::CreateMatchingAudioConfigs(Transport* transport, |
| 433 | std::string sync_group) { |
| 434 | audio_receive_configs_.push_back(CreateMatchingAudioConfig( |
| 435 | audio_send_config_, audio_decoder_factory_, transport, sync_group)); |
| 436 | } |
| 437 | |
| 438 | AudioReceiveStream::Config CallTest::CreateMatchingAudioConfig( |
| 439 | const AudioSendStream::Config& send_config, |
| 440 | rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory, |
| 441 | Transport* transport, |
| 442 | std::string sync_group) { |
| 443 | AudioReceiveStream::Config audio_config; |
| 444 | audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc; |
| 445 | audio_config.rtcp_send_transport = transport; |
| 446 | audio_config.rtp.remote_ssrc = send_config.rtp.ssrc; |
| 447 | audio_config.rtp.transport_cc = |
| 448 | send_config.send_codec_spec |
| 449 | ? send_config.send_codec_spec->transport_cc_enabled |
| 450 | : false; |
| 451 | audio_config.rtp.extensions = send_config.rtp.extensions; |
| 452 | audio_config.decoder_factory = audio_decoder_factory; |
| 453 | audio_config.decoder_map = {{kAudioSendPayloadType, {"opus", 48000, 2}}}; |
| 454 | audio_config.sync_group = sync_group; |
| 455 | return audio_config; |
| 456 | } |
| 457 | |
| 458 | void CallTest::CreateMatchingFecConfig( |
| 459 | Transport* transport, |
| 460 | const VideoSendStream::Config& send_config) { |
| 461 | FlexfecReceiveStream::Config config(transport); |
| 462 | config.payload_type = send_config.rtp.flexfec.payload_type; |
| 463 | config.remote_ssrc = send_config.rtp.flexfec.ssrc; |
| 464 | config.protected_media_ssrcs = send_config.rtp.flexfec.protected_media_ssrcs; |
| 465 | config.local_ssrc = kReceiverLocalVideoSsrc; |
| 466 | if (!video_receive_configs_.empty()) |
| 467 | video_receive_configs_[0].rtp.protected_by_flexfec = true; |
| 468 | flexfec_receive_configs_.push_back(config); |
| 469 | } |
| 470 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 471 | void CallTest::CreateMatchingReceiveConfigs(Transport* rtcp_send_transport) { |
| 472 | video_receive_configs_.clear(); |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 473 | for (VideoSendStream::Config& video_send_config : video_send_configs_) { |
| 474 | CreateMatchingVideoReceiveConfigs(video_send_config, rtcp_send_transport); |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 475 | } |
| 476 | CreateMatchingAudioAndFecConfigs(rtcp_send_transport); |
| 477 | } |
| 478 | |
danilchap | 9c6a0c7 | 2016-02-10 10:54:47 -0800 | [diff] [blame] | 479 | void CallTest::CreateFrameGeneratorCapturerWithDrift(Clock* clock, |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 480 | float speed, |
| 481 | int framerate, |
| 482 | int width, |
| 483 | int height) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 484 | video_sources_.clear(); |
Danil Chapovalov | a92e624 | 2019-04-18 10:58:56 +0200 | [diff] [blame] | 485 | auto frame_generator_capturer = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 486 | std::make_unique<test::FrameGeneratorCapturer>( |
Danil Chapovalov | a92e624 | 2019-04-18 10:58:56 +0200 | [diff] [blame] | 487 | clock, |
| 488 | test::FrameGenerator::CreateSquareGenerator( |
| 489 | width, height, absl::nullopt, absl::nullopt), |
| 490 | framerate * speed, *task_queue_factory_); |
| 491 | frame_generator_capturer_ = frame_generator_capturer.get(); |
| 492 | frame_generator_capturer->Init(); |
| 493 | video_sources_.push_back(std::move(frame_generator_capturer)); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 494 | ConnectVideoSourcesToStreams(); |
danilchap | 9c6a0c7 | 2016-02-10 10:54:47 -0800 | [diff] [blame] | 495 | } |
| 496 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 497 | void CallTest::CreateFrameGeneratorCapturer(int framerate, |
| 498 | int width, |
| 499 | int height) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 500 | video_sources_.clear(); |
Danil Chapovalov | a92e624 | 2019-04-18 10:58:56 +0200 | [diff] [blame] | 501 | auto frame_generator_capturer = |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 502 | std::make_unique<test::FrameGeneratorCapturer>( |
Danil Chapovalov | a92e624 | 2019-04-18 10:58:56 +0200 | [diff] [blame] | 503 | clock_, |
| 504 | test::FrameGenerator::CreateSquareGenerator( |
| 505 | width, height, absl::nullopt, absl::nullopt), |
| 506 | framerate, *task_queue_factory_); |
| 507 | frame_generator_capturer_ = frame_generator_capturer.get(); |
| 508 | frame_generator_capturer->Init(); |
| 509 | video_sources_.push_back(std::move(frame_generator_capturer)); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 510 | ConnectVideoSourcesToStreams(); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 511 | } |
pbos | f1828e8 | 2015-07-28 08:20:59 -0700 | [diff] [blame] | 512 | |
oprypin | 92220ff | 2017-03-23 03:40:03 -0700 | [diff] [blame] | 513 | void CallTest::CreateFakeAudioDevices( |
Artem Titov | 3faa832 | 2018-03-07 14:44:00 +0100 | [diff] [blame] | 514 | std::unique_ptr<TestAudioDeviceModule::Capturer> capturer, |
| 515 | std::unique_ptr<TestAudioDeviceModule::Renderer> renderer) { |
Danil Chapovalov | 08fa953 | 2019-06-12 11:49:17 +0000 | [diff] [blame] | 516 | fake_send_audio_device_ = TestAudioDeviceModule::Create( |
| 517 | task_queue_factory_.get(), std::move(capturer), nullptr, 1.f); |
| 518 | fake_recv_audio_device_ = TestAudioDeviceModule::Create( |
| 519 | task_queue_factory_.get(), nullptr, std::move(renderer), 1.f); |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 520 | } |
| 521 | |
| 522 | void CallTest::CreateVideoStreams() { |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 523 | RTC_DCHECK(video_receive_streams_.empty()); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 524 | CreateVideoSendStreams(); |
stefan | ff48361 | 2015-12-21 03:14:00 -0800 | [diff] [blame] | 525 | for (size_t i = 0; i < video_receive_configs_.size(); ++i) { |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 526 | video_receive_streams_.push_back(receiver_call_->CreateVideoReceiveStream( |
| 527 | video_receive_configs_[i].Copy())); |
pbos@webrtc.org | be9d2a4 | 2014-06-30 13:19:09 +0000 | [diff] [blame] | 528 | } |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 529 | |
| 530 | AssociateFlexfecStreamsWithVideoStreams(); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 531 | } |
| 532 | |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 533 | void CallTest::CreateVideoSendStreams() { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 534 | RTC_DCHECK(video_send_streams_.empty()); |
| 535 | |
| 536 | // We currently only support testing external fec controllers with a single |
| 537 | // VideoSendStream. |
| 538 | if (fec_controller_factory_.get()) { |
| 539 | RTC_DCHECK_LE(video_send_configs_.size(), 1); |
| 540 | } |
| 541 | |
| 542 | // TODO(http://crbug/818127): |
| 543 | // Remove this workaround when ALR is not screenshare-specific. |
| 544 | std::list<size_t> streams_creation_order; |
| 545 | for (size_t i = 0; i < video_send_configs_.size(); ++i) { |
| 546 | // If dual streams are created, add the screenshare stream last. |
| 547 | if (video_encoder_configs_[i].content_type == |
| 548 | VideoEncoderConfig::ContentType::kScreen) { |
| 549 | streams_creation_order.push_back(i); |
| 550 | } else { |
| 551 | streams_creation_order.push_front(i); |
| 552 | } |
| 553 | } |
| 554 | |
| 555 | video_send_streams_.resize(video_send_configs_.size(), nullptr); |
| 556 | |
| 557 | for (size_t i : streams_creation_order) { |
| 558 | if (fec_controller_factory_.get()) { |
| 559 | video_send_streams_[i] = sender_call_->CreateVideoSendStream( |
| 560 | video_send_configs_[i].Copy(), video_encoder_configs_[i].Copy(), |
| 561 | fec_controller_factory_->CreateFecController()); |
| 562 | } else { |
| 563 | video_send_streams_[i] = sender_call_->CreateVideoSendStream( |
| 564 | video_send_configs_[i].Copy(), video_encoder_configs_[i].Copy()); |
| 565 | } |
| 566 | } |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 567 | } |
| 568 | |
| 569 | void CallTest::CreateVideoSendStream(const VideoEncoderConfig& encoder_config) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 570 | RTC_DCHECK(video_send_streams_.empty()); |
| 571 | video_send_streams_.push_back(sender_call_->CreateVideoSendStream( |
| 572 | GetVideoSendConfig()->Copy(), encoder_config.Copy())); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 573 | } |
| 574 | |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 575 | void CallTest::CreateAudioStreams() { |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 576 | RTC_DCHECK(audio_send_stream_ == nullptr); |
| 577 | RTC_DCHECK(audio_receive_streams_.empty()); |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 578 | audio_send_stream_ = sender_call_->CreateAudioSendStream(audio_send_config_); |
| 579 | for (size_t i = 0; i < audio_receive_configs_.size(); ++i) { |
| 580 | audio_receive_streams_.push_back( |
| 581 | receiver_call_->CreateAudioReceiveStream(audio_receive_configs_[i])); |
| 582 | } |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 583 | } |
| 584 | |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 585 | void CallTest::CreateFlexfecStreams() { |
| 586 | for (size_t i = 0; i < flexfec_receive_configs_.size(); ++i) { |
| 587 | flexfec_receive_streams_.push_back( |
| 588 | receiver_call_->CreateFlexfecReceiveStream( |
| 589 | flexfec_receive_configs_[i])); |
| 590 | } |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 591 | |
| 592 | AssociateFlexfecStreamsWithVideoStreams(); |
| 593 | } |
| 594 | |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 595 | void CallTest::ConnectVideoSourcesToStreams() { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 596 | for (size_t i = 0; i < video_sources_.size(); ++i) |
Niels Möller | 1c931c4 | 2018-12-18 16:08:11 +0100 | [diff] [blame] | 597 | video_send_streams_[i]->SetSource(video_sources_[i].get(), |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 598 | degradation_preference_); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 599 | } |
| 600 | |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 601 | void CallTest::AssociateFlexfecStreamsWithVideoStreams() { |
| 602 | // All FlexFEC streams protect all of the video streams. |
| 603 | for (FlexfecReceiveStream* flexfec_recv_stream : flexfec_receive_streams_) { |
| 604 | for (VideoReceiveStream* video_recv_stream : video_receive_streams_) { |
| 605 | video_recv_stream->AddSecondarySink(flexfec_recv_stream); |
| 606 | } |
| 607 | } |
| 608 | } |
| 609 | |
| 610 | void CallTest::DissociateFlexfecStreamsFromVideoStreams() { |
| 611 | for (FlexfecReceiveStream* flexfec_recv_stream : flexfec_receive_streams_) { |
| 612 | for (VideoReceiveStream* video_recv_stream : video_receive_streams_) { |
| 613 | video_recv_stream->RemoveSecondarySink(flexfec_recv_stream); |
| 614 | } |
| 615 | } |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 616 | } |
| 617 | |
eladalon | 445f1a1 | 2017-08-09 01:52:36 -0700 | [diff] [blame] | 618 | void CallTest::Start() { |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 619 | StartVideoStreams(); |
eladalon | 445f1a1 | 2017-08-09 01:52:36 -0700 | [diff] [blame] | 620 | if (audio_send_stream_) { |
| 621 | audio_send_stream_->Start(); |
| 622 | } |
| 623 | for (AudioReceiveStream* audio_recv_stream : audio_receive_streams_) |
| 624 | audio_recv_stream->Start(); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 625 | } |
| 626 | |
| 627 | void CallTest::StartVideoStreams() { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 628 | for (VideoSendStream* video_send_stream : video_send_streams_) |
| 629 | video_send_stream->Start(); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 630 | for (VideoReceiveStream* video_recv_stream : video_receive_streams_) |
| 631 | video_recv_stream->Start(); |
| 632 | } |
| 633 | |
eladalon | 445f1a1 | 2017-08-09 01:52:36 -0700 | [diff] [blame] | 634 | void CallTest::Stop() { |
eladalon | 445f1a1 | 2017-08-09 01:52:36 -0700 | [diff] [blame] | 635 | for (AudioReceiveStream* audio_recv_stream : audio_receive_streams_) |
| 636 | audio_recv_stream->Stop(); |
| 637 | if (audio_send_stream_) { |
| 638 | audio_send_stream_->Stop(); |
| 639 | } |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 640 | StopVideoStreams(); |
| 641 | } |
| 642 | |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 643 | void CallTest::StopVideoStreams() { |
| 644 | for (VideoSendStream* video_send_stream : video_send_streams_) |
| 645 | video_send_stream->Stop(); |
eladalon | 445f1a1 | 2017-08-09 01:52:36 -0700 | [diff] [blame] | 646 | for (VideoReceiveStream* video_recv_stream : video_receive_streams_) |
| 647 | video_recv_stream->Stop(); |
eladalon | 445f1a1 | 2017-08-09 01:52:36 -0700 | [diff] [blame] | 648 | } |
| 649 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 650 | void CallTest::DestroyStreams() { |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 651 | DissociateFlexfecStreamsFromVideoStreams(); |
| 652 | |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 653 | if (audio_send_stream_) |
| 654 | sender_call_->DestroyAudioSendStream(audio_send_stream_); |
| 655 | audio_send_stream_ = nullptr; |
| 656 | for (AudioReceiveStream* audio_recv_stream : audio_receive_streams_) |
| 657 | receiver_call_->DestroyAudioReceiveStream(audio_recv_stream); |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 658 | |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 659 | DestroyVideoSendStreams(); |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 660 | |
brandtr | fb45c6c | 2017-01-27 06:47:55 -0800 | [diff] [blame] | 661 | for (VideoReceiveStream* video_recv_stream : video_receive_streams_) |
| 662 | receiver_call_->DestroyVideoReceiveStream(video_recv_stream); |
| 663 | |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 664 | for (FlexfecReceiveStream* flexfec_recv_stream : flexfec_receive_streams_) |
| 665 | receiver_call_->DestroyFlexfecReceiveStream(flexfec_recv_stream); |
| 666 | |
| 667 | video_receive_streams_.clear(); |
Niels Möller | 3b819f3 | 2019-10-10 12:42:41 +0200 | [diff] [blame] | 668 | video_sources_.clear(); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 669 | } |
| 670 | |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 671 | void CallTest::DestroyVideoSendStreams() { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 672 | for (VideoSendStream* video_send_stream : video_send_streams_) |
| 673 | sender_call_->DestroyVideoSendStream(video_send_stream); |
| 674 | video_send_streams_.clear(); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 675 | } |
| 676 | |
eladalon | 445f1a1 | 2017-08-09 01:52:36 -0700 | [diff] [blame] | 677 | void CallTest::SetFakeVideoCaptureRotation(VideoRotation rotation) { |
| 678 | frame_generator_capturer_->SetFakeRotation(rotation); |
| 679 | } |
| 680 | |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 681 | void CallTest::SetVideoDegradation(DegradationPreference preference) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 682 | GetVideoSendStream()->SetSource(frame_generator_capturer_, preference); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 683 | } |
| 684 | |
| 685 | VideoSendStream::Config* CallTest::GetVideoSendConfig() { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 686 | return &video_send_configs_[0]; |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 687 | } |
| 688 | |
| 689 | void CallTest::SetVideoSendConfig(const VideoSendStream::Config& config) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 690 | video_send_configs_.clear(); |
| 691 | video_send_configs_.push_back(config.Copy()); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 692 | } |
| 693 | |
| 694 | VideoEncoderConfig* CallTest::GetVideoEncoderConfig() { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 695 | return &video_encoder_configs_[0]; |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 696 | } |
| 697 | |
| 698 | void CallTest::SetVideoEncoderConfig(const VideoEncoderConfig& config) { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 699 | video_encoder_configs_.clear(); |
| 700 | video_encoder_configs_.push_back(config.Copy()); |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 701 | } |
| 702 | |
| 703 | VideoSendStream* CallTest::GetVideoSendStream() { |
Sebastian Jansson | 3bd2c79 | 2018-07-13 13:29:03 +0200 | [diff] [blame] | 704 | return video_send_streams_[0]; |
| 705 | } |
| 706 | FlexfecReceiveStream::Config* CallTest::GetFlexFecConfig() { |
| 707 | return &flexfec_receive_configs_[0]; |
Sebastian Jansson | f33905d | 2018-07-13 09:49:00 +0200 | [diff] [blame] | 708 | } |
| 709 | |
Elad Alon | d8d3248 | 2019-02-18 23:45:57 +0100 | [diff] [blame] | 710 | absl::optional<RtpExtension> CallTest::GetRtpExtensionByUri( |
| 711 | const std::string& uri) const { |
| 712 | for (const auto& extension : rtp_extensions_) { |
| 713 | if (extension.uri == uri) { |
| 714 | return extension; |
| 715 | } |
| 716 | } |
| 717 | return absl::nullopt; |
| 718 | } |
| 719 | |
| 720 | void CallTest::AddRtpExtensionByUri( |
| 721 | const std::string& uri, |
| 722 | std::vector<RtpExtension>* extensions) const { |
| 723 | const absl::optional<RtpExtension> extension = GetRtpExtensionByUri(uri); |
| 724 | if (extension) { |
| 725 | extensions->push_back(*extension); |
| 726 | } |
| 727 | } |
| 728 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 729 | constexpr size_t CallTest::kNumSsrcs; |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 730 | const int CallTest::kDefaultWidth; |
| 731 | const int CallTest::kDefaultHeight; |
| 732 | const int CallTest::kDefaultFramerate; |
Peter Boström | 5811a39 | 2015-12-10 13:02:50 +0100 | [diff] [blame] | 733 | const int CallTest::kDefaultTimeoutMs = 30 * 1000; |
| 734 | const int CallTest::kLongTimeoutMs = 120 * 1000; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 735 | const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = { |
| 736 | 0xBADCAFD, 0xBADCAFE, 0xBADCAFF, 0xBADCB00, 0xBADCB01, 0xBADCB02}; |
| 737 | const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = { |
| 738 | 0xC0FFED, 0xC0FFEE, 0xC0FFEF, 0xC0FFF0, 0xC0FFF1, 0xC0FFF2}; |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 739 | const uint32_t CallTest::kAudioSendSsrc = 0xDEADBEEF; |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 740 | const uint32_t CallTest::kFlexfecSendSsrc = 0xBADBEEF; |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 741 | const uint32_t CallTest::kReceiverLocalVideoSsrc = 0x123456; |
| 742 | const uint32_t CallTest::kReceiverLocalAudioSsrc = 0x1234567; |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 743 | const int CallTest::kNackRtpHistoryMs = 1000; |
| 744 | |
minyue | 20c84cc | 2017-04-10 16:57:57 -0700 | [diff] [blame] | 745 | const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = { |
| 746 | {CallTest::kVideoSendPayloadType, MediaType::VIDEO}, |
| 747 | {CallTest::kFakeVideoSendPayloadType, MediaType::VIDEO}, |
| 748 | {CallTest::kSendRtxPayloadType, MediaType::VIDEO}, |
| 749 | {CallTest::kRedPayloadType, MediaType::VIDEO}, |
| 750 | {CallTest::kRtxRedPayloadType, MediaType::VIDEO}, |
| 751 | {CallTest::kUlpfecPayloadType, MediaType::VIDEO}, |
| 752 | {CallTest::kFlexfecPayloadType, MediaType::VIDEO}, |
Sebastian Jansson | d155d68 | 2019-03-04 18:59:32 +0100 | [diff] [blame] | 753 | {CallTest::kAudioSendPayloadType, MediaType::AUDIO}}; |
minyue | 20c84cc | 2017-04-10 16:57:57 -0700 | [diff] [blame] | 754 | |
Sebastian Jansson | 7258224 | 2018-07-13 13:19:42 +0200 | [diff] [blame] | 755 | BaseTest::BaseTest() {} |
philipel | e828c96 | 2017-03-21 03:24:27 -0700 | [diff] [blame] | 756 | |
Sebastian Jansson | 7258224 | 2018-07-13 13:19:42 +0200 | [diff] [blame] | 757 | BaseTest::BaseTest(int timeout_ms) : RtpRtcpObserver(timeout_ms) {} |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 758 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 759 | BaseTest::~BaseTest() {} |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 760 | |
Artem Titov | 3faa832 | 2018-03-07 14:44:00 +0100 | [diff] [blame] | 761 | std::unique_ptr<TestAudioDeviceModule::Capturer> BaseTest::CreateCapturer() { |
| 762 | return TestAudioDeviceModule::CreatePulsedNoiseCapturer(256, 48000); |
oprypin | 92220ff | 2017-03-23 03:40:03 -0700 | [diff] [blame] | 763 | } |
| 764 | |
Artem Titov | 3faa832 | 2018-03-07 14:44:00 +0100 | [diff] [blame] | 765 | std::unique_ptr<TestAudioDeviceModule::Renderer> BaseTest::CreateRenderer() { |
| 766 | return TestAudioDeviceModule::CreateDiscardRenderer(48000); |
oprypin | 92220ff | 2017-03-23 03:40:03 -0700 | [diff] [blame] | 767 | } |
| 768 | |
Artem Titov | 3faa832 | 2018-03-07 14:44:00 +0100 | [diff] [blame] | 769 | void BaseTest::OnFakeAudioDevicesCreated( |
| 770 | TestAudioDeviceModule* send_audio_device, |
| 771 | TestAudioDeviceModule* recv_audio_device) {} |
oprypin | 92220ff | 2017-03-23 03:40:03 -0700 | [diff] [blame] | 772 | |
Niels Möller | de8e6e6 | 2018-11-13 15:10:33 +0100 | [diff] [blame] | 773 | void BaseTest::ModifySenderBitrateConfig(BitrateConstraints* bitrate_config) {} |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 774 | |
Niels Möller | de8e6e6 | 2018-11-13 15:10:33 +0100 | [diff] [blame] | 775 | void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) { |
| 776 | } |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 777 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 778 | void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {} |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 779 | |
Danil Chapovalov | 44db436 | 2019-09-30 04:16:28 +0200 | [diff] [blame] | 780 | std::unique_ptr<PacketTransport> BaseTest::CreateSendTransport( |
| 781 | TaskQueueBase* task_queue, |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 782 | Call* sender_call) { |
Danil Chapovalov | 44db436 | 2019-09-30 04:16:28 +0200 | [diff] [blame] | 783 | return std::make_unique<PacketTransport>( |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 784 | task_queue, sender_call, this, test::PacketTransport::kSender, |
Artem Titov | 4e199e9 | 2018-08-20 13:30:39 +0200 | [diff] [blame] | 785 | CallTest::payload_type_map_, |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 786 | std::make_unique<FakeNetworkPipe>( |
Artem Titov | 75e3647 | 2018-10-08 12:28:56 +0200 | [diff] [blame] | 787 | Clock::GetRealTimeClock(), |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 788 | std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig()))); |
stefan | e74eef1 | 2016-01-08 06:47:13 -0800 | [diff] [blame] | 789 | } |
| 790 | |
Danil Chapovalov | 44db436 | 2019-09-30 04:16:28 +0200 | [diff] [blame] | 791 | std::unique_ptr<PacketTransport> BaseTest::CreateReceiveTransport( |
| 792 | TaskQueueBase* task_queue) { |
| 793 | return std::make_unique<PacketTransport>( |
eladalon | 413ee9a | 2017-08-22 04:02:52 -0700 | [diff] [blame] | 794 | task_queue, nullptr, this, test::PacketTransport::kReceiver, |
Artem Titov | 4e199e9 | 2018-08-20 13:30:39 +0200 | [diff] [blame] | 795 | CallTest::payload_type_map_, |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 796 | std::make_unique<FakeNetworkPipe>( |
Artem Titov | 75e3647 | 2018-10-08 12:28:56 +0200 | [diff] [blame] | 797 | Clock::GetRealTimeClock(), |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 798 | std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig()))); |
stefan | e74eef1 | 2016-01-08 06:47:13 -0800 | [diff] [blame] | 799 | } |
stefan | f116bd0 | 2015-10-27 08:29:42 -0700 | [diff] [blame] | 800 | |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 801 | size_t BaseTest::GetNumVideoStreams() const { |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 802 | return 1; |
| 803 | } |
| 804 | |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 805 | size_t BaseTest::GetNumAudioStreams() const { |
| 806 | return 0; |
| 807 | } |
| 808 | |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 809 | size_t BaseTest::GetNumFlexfecStreams() const { |
| 810 | return 0; |
| 811 | } |
| 812 | |
stefan | ff48361 | 2015-12-21 03:14:00 -0800 | [diff] [blame] | 813 | void BaseTest::ModifyVideoConfigs( |
pbos@webrtc.org | be9d2a4 | 2014-06-30 13:19:09 +0000 | [diff] [blame] | 814 | VideoSendStream::Config* send_config, |
| 815 | std::vector<VideoReceiveStream::Config>* receive_configs, |
stefan | ff48361 | 2015-12-21 03:14:00 -0800 | [diff] [blame] | 816 | VideoEncoderConfig* encoder_config) {} |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 817 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 818 | void BaseTest::ModifyVideoCaptureStartResolution(int* width, |
| 819 | int* heigt, |
| 820 | int* frame_rate) {} |
| 821 | |
Åsa Persson | cb7eddb | 2018-11-05 14:11:44 +0100 | [diff] [blame] | 822 | void BaseTest::ModifyVideoDegradationPreference( |
| 823 | DegradationPreference* degradation_preference) {} |
| 824 | |
stefan | ff48361 | 2015-12-21 03:14:00 -0800 | [diff] [blame] | 825 | void BaseTest::OnVideoStreamsCreated( |
pbos@webrtc.org | be9d2a4 | 2014-06-30 13:19:09 +0000 | [diff] [blame] | 826 | VideoSendStream* send_stream, |
stefan | ff48361 | 2015-12-21 03:14:00 -0800 | [diff] [blame] | 827 | const std::vector<VideoReceiveStream*>& receive_streams) {} |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 828 | |
Stefan Holmer | 9fea80f | 2016-01-07 17:43:18 +0100 | [diff] [blame] | 829 | void BaseTest::ModifyAudioConfigs( |
| 830 | AudioSendStream::Config* send_config, |
| 831 | std::vector<AudioReceiveStream::Config>* receive_configs) {} |
| 832 | |
| 833 | void BaseTest::OnAudioStreamsCreated( |
| 834 | AudioSendStream* send_stream, |
| 835 | const std::vector<AudioReceiveStream*>& receive_streams) {} |
| 836 | |
brandtr | 841de6a | 2016-11-15 07:10:52 -0800 | [diff] [blame] | 837 | void BaseTest::ModifyFlexfecConfigs( |
| 838 | std::vector<FlexfecReceiveStream::Config>* receive_configs) {} |
| 839 | |
| 840 | void BaseTest::OnFlexfecStreamsCreated( |
| 841 | const std::vector<FlexfecReceiveStream*>& receive_streams) {} |
| 842 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 843 | void BaseTest::OnFrameGeneratorCapturerCreated( |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 844 | FrameGeneratorCapturer* frame_generator_capturer) {} |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 845 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 846 | void BaseTest::OnStreamsStopped() {} |
oprypin | 92220ff | 2017-03-23 03:40:03 -0700 | [diff] [blame] | 847 | |
Sebastian Jansson | 7258224 | 2018-07-13 13:19:42 +0200 | [diff] [blame] | 848 | SendTest::SendTest(int timeout_ms) : BaseTest(timeout_ms) {} |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 849 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 850 | bool SendTest::ShouldCreateReceivers() const { |
| 851 | return false; |
| 852 | } |
| 853 | |
philipel | e828c96 | 2017-03-21 03:24:27 -0700 | [diff] [blame] | 854 | EndToEndTest::EndToEndTest() {} |
| 855 | |
Sebastian Jansson | 7258224 | 2018-07-13 13:19:42 +0200 | [diff] [blame] | 856 | EndToEndTest::EndToEndTest(int timeout_ms) : BaseTest(timeout_ms) {} |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 857 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 858 | bool EndToEndTest::ShouldCreateReceivers() const { |
| 859 | return true; |
| 860 | } |
| 861 | |
| 862 | } // namespace test |
| 863 | } // namespace webrtc |