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