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