pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | #include <functional> |
| 11 | #include <list> |
kwiberg | b25345e | 2016-03-12 14:10:44 | [diff] [blame] | 12 | #include <memory> |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 13 | #include <string> |
| 14 | |
Ali Tofigh | 6364d08 | 2022-03-14 12:32:04 | [diff] [blame] | 15 | #include "absl/strings/string_view.h" |
Artem Titov | 33f9d2b | 2019-12-05 14:59:00 | [diff] [blame] | 16 | #include "api/test/create_frame_generator.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 17 | #include "call/call.h" |
Artem Titov | dd2eebe | 2018-08-20 11:27:45 | [diff] [blame] | 18 | #include "call/fake_network_pipe.h" |
| 19 | #include "call/simulated_network.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 20 | #include "rtc_base/checks.h" |
| 21 | #include "rtc_base/event.h" |
| 22 | #include "rtc_base/logging.h" |
Markus Handell | 8fe932a | 2020-07-06 15:41:35 | [diff] [blame] | 23 | #include "rtc_base/synchronization/mutex.h" |
Danil Chapovalov | 82a3f0a | 2019-10-21 07:24:27 | [diff] [blame] | 24 | #include "rtc_base/task_queue_for_test.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 25 | #include "rtc_base/thread_annotations.h" |
| 26 | #include "test/call_test.h" |
| 27 | #include "test/direct_transport.h" |
| 28 | #include "test/encoder_settings.h" |
| 29 | #include "test/fake_decoder.h" |
| 30 | #include "test/fake_encoder.h" |
| 31 | #include "test/frame_generator_capturer.h" |
| 32 | #include "test/gtest.h" |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 33 | |
| 34 | namespace webrtc { |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 35 | namespace { |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 36 | // Note: If you consider to re-use this class, think twice and instead consider |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 37 | // writing tests that don't depend on the logging system. |
| 38 | class LogObserver { |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 39 | public: |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 40 | LogObserver() { rtc::LogMessage::AddLogToStream(&callback_, rtc::LS_INFO); } |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 41 | |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 42 | ~LogObserver() { rtc::LogMessage::RemoveLogToStream(&callback_); } |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 43 | |
Ali Tofigh | 641a1b1 | 2022-05-17 09:48:46 | [diff] [blame] | 44 | void PushExpectedLogLine(absl::string_view expected_log_line) { |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 45 | callback_.PushExpectedLogLine(expected_log_line); |
| 46 | } |
| 47 | |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame] | 48 | bool Wait() { return callback_.Wait(); } |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 49 | |
| 50 | private: |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 51 | class Callback : public rtc::LogSink { |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 52 | public: |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 53 | void OnLogMessage(const std::string& message) override { |
Ali Tofigh | 6364d08 | 2022-03-14 12:32:04 | [diff] [blame] | 54 | OnLogMessage(absl::string_view(message)); |
| 55 | } |
| 56 | |
| 57 | void OnLogMessage(absl::string_view message) override { |
Markus Handell | 8fe932a | 2020-07-06 15:41:35 | [diff] [blame] | 58 | MutexLock lock(&mutex_); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 59 | // Ignore log lines that are due to missing AST extensions, these are |
| 60 | // logged when we switch back from AST to TOF until the wrapping bitrate |
| 61 | // estimator gives up on using AST. |
Ali Tofigh | 6364d08 | 2022-03-14 12:32:04 | [diff] [blame] | 62 | if (message.find("BitrateEstimator") != absl::string_view::npos && |
| 63 | message.find("packet is missing") == absl::string_view::npos) { |
| 64 | received_log_lines_.push_back(std::string(message)); |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 65 | } |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 66 | |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 67 | int num_popped = 0; |
| 68 | while (!received_log_lines_.empty() && !expected_log_lines_.empty()) { |
| 69 | std::string a = received_log_lines_.front(); |
| 70 | std::string b = expected_log_lines_.front(); |
| 71 | received_log_lines_.pop_front(); |
| 72 | expected_log_lines_.pop_front(); |
| 73 | num_popped++; |
Ali Tofigh | 6364d08 | 2022-03-14 12:32:04 | [diff] [blame] | 74 | EXPECT_TRUE(a.find(b) != absl::string_view::npos) << a << " != " << b; |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 75 | } |
Benjamin Wright | 41f9f2c | 2019-03-14 01:03:29 | [diff] [blame] | 76 | if (expected_log_lines_.empty()) { |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 77 | if (num_popped > 0) { |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame] | 78 | done_.Set(); |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 79 | } |
| 80 | return; |
| 81 | } |
| 82 | } |
| 83 | |
Markus Handell | 2cfc1af | 2022-08-19 08:16:48 | [diff] [blame] | 84 | bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeout); } |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 85 | |
Ali Tofigh | 641a1b1 | 2022-05-17 09:48:46 | [diff] [blame] | 86 | void PushExpectedLogLine(absl::string_view expected_log_line) { |
Markus Handell | 8fe932a | 2020-07-06 15:41:35 | [diff] [blame] | 87 | MutexLock lock(&mutex_); |
Ali Tofigh | 641a1b1 | 2022-05-17 09:48:46 | [diff] [blame] | 88 | expected_log_lines_.emplace_back(expected_log_line); |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | private: |
| 92 | typedef std::list<std::string> Strings; |
Markus Handell | 8fe932a | 2020-07-06 15:41:35 | [diff] [blame] | 93 | Mutex mutex_; |
| 94 | Strings received_log_lines_ RTC_GUARDED_BY(mutex_); |
| 95 | Strings expected_log_lines_ RTC_GUARDED_BY(mutex_); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame] | 96 | rtc::Event done_; |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 97 | }; |
| 98 | |
| 99 | Callback callback_; |
| 100 | }; |
| 101 | } // namespace |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 102 | |
| 103 | static const int kTOFExtensionId = 4; |
| 104 | static const int kASTExtensionId = 5; |
| 105 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 | [diff] [blame] | 106 | class BitrateEstimatorTest : public test::CallTest { |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 107 | public: |
aleloi | 5d78e8d | 2016-11-08 11:44:54 | [diff] [blame] | 108 | BitrateEstimatorTest() : receive_config_(nullptr) {} |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 109 | |
Fredrik Solenberg | 0ccae13 | 2015-11-03 09:15:49 | [diff] [blame] | 110 | virtual ~BitrateEstimatorTest() { EXPECT_TRUE(streams_.empty()); } |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 111 | |
| 112 | virtual void SetUp() { |
Danil Chapovalov | e519f38 | 2022-08-11 10:26:09 | [diff] [blame] | 113 | SendTask(task_queue(), [this]() { |
Sebastian Jansson | 8e6602f | 2018-07-13 08:43:20 | [diff] [blame] | 114 | CreateCalls(); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 115 | |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 116 | send_transport_.reset(new test::DirectTransport( |
Danil Chapovalov | d15a028 | 2019-10-22 08:48:17 | [diff] [blame] | 117 | task_queue(), |
Mirko Bonadei | 317a1f0 | 2019-09-17 15:06:18 | [diff] [blame] | 118 | std::make_unique<FakeNetworkPipe>( |
| 119 | Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>( |
Artem Titov | 75e3647 | 2018-10-08 10:28:56 | [diff] [blame] | 120 | BuiltInNetworkBehaviorConfig())), |
Artem Titov | dd2eebe | 2018-08-20 11:27:45 | [diff] [blame] | 121 | sender_call_.get(), payload_type_map_)); |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 122 | send_transport_->SetReceiver(receiver_call_->Receiver()); |
| 123 | receive_transport_.reset(new test::DirectTransport( |
Danil Chapovalov | d15a028 | 2019-10-22 08:48:17 | [diff] [blame] | 124 | task_queue(), |
Mirko Bonadei | 317a1f0 | 2019-09-17 15:06:18 | [diff] [blame] | 125 | std::make_unique<FakeNetworkPipe>( |
| 126 | Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>( |
Artem Titov | 75e3647 | 2018-10-08 10:28:56 | [diff] [blame] | 127 | BuiltInNetworkBehaviorConfig())), |
Artem Titov | dd2eebe | 2018-08-20 11:27:45 | [diff] [blame] | 128 | receiver_call_.get(), payload_type_map_)); |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 129 | receive_transport_->SetReceiver(sender_call_->Receiver()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 130 | |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 131 | VideoSendStream::Config video_send_config(send_transport_.get()); |
| 132 | video_send_config.rtp.ssrcs.push_back(kVideoSendSsrcs[0]); |
| 133 | video_send_config.encoder_settings.encoder_factory = |
Niels Möller | 4db138e | 2018-04-19 07:04:13 | [diff] [blame] | 134 | &fake_encoder_factory_; |
Jiawei Ou | c2ebe21 | 2018-11-08 18:02:56 | [diff] [blame] | 135 | video_send_config.encoder_settings.bitrate_allocator_factory = |
| 136 | bitrate_allocator_factory_.get(); |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 137 | video_send_config.rtp.payload_name = "FAKE"; |
| 138 | video_send_config.rtp.payload_type = kFakeVideoSendPayloadType; |
| 139 | SetVideoSendConfig(video_send_config); |
| 140 | VideoEncoderConfig video_encoder_config; |
| 141 | test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); |
| 142 | SetVideoEncoderConfig(video_encoder_config); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 143 | |
Tommi | f6f4543 | 2022-05-20 13:21:20 | [diff] [blame] | 144 | receive_config_ = |
| 145 | VideoReceiveStreamInterface::Config(receive_transport_.get()); |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 146 | // receive_config_.decoders will be set by every stream separately. |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 147 | receive_config_.rtp.remote_ssrc = GetVideoSendConfig()->rtp.ssrcs[0]; |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 148 | receive_config_.rtp.local_ssrc = kReceiverLocalVideoSsrc; |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 149 | receive_config_.rtp.extensions.push_back( |
| 150 | RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId)); |
| 151 | receive_config_.rtp.extensions.push_back( |
| 152 | RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId)); |
| 153 | }); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | virtual void TearDown() { |
Danil Chapovalov | e519f38 | 2022-08-11 10:26:09 | [diff] [blame] | 157 | SendTask(task_queue(), [this]() { |
Yusuke Suzuki | f8d8d6d | 2018-05-17 13:01:13 | [diff] [blame] | 158 | for (auto* stream : streams_) { |
| 159 | stream->StopSending(); |
| 160 | delete stream; |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 161 | } |
Yusuke Suzuki | f8d8d6d | 2018-05-17 13:01:13 | [diff] [blame] | 162 | streams_.clear(); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 163 | |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 164 | send_transport_.reset(); |
| 165 | receive_transport_.reset(); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 166 | |
Sebastian Jansson | 8e6602f | 2018-07-13 08:43:20 | [diff] [blame] | 167 | DestroyCalls(); |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 168 | }); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 169 | } |
| 170 | |
| 171 | protected: |
| 172 | friend class Stream; |
| 173 | |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 174 | class Stream { |
| 175 | public: |
aleloi | 5d78e8d | 2016-11-08 11:44:54 | [diff] [blame] | 176 | explicit Stream(BitrateEstimatorTest* test) |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 177 | : test_(test), |
| 178 | is_sending_receiving_(false), |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 | [diff] [blame] | 179 | send_stream_(nullptr), |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 180 | frame_generator_capturer_(), |
Niels Möller | cbcbc22 | 2018-09-28 07:07:24 | [diff] [blame] | 181 | decoder_factory_( |
Mirko Bonadei | 317a1f0 | 2019-09-17 15:06:18 | [diff] [blame] | 182 | []() { return std::make_unique<test::FakeDecoder>(); }) { |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 183 | test_->GetVideoSendConfig()->rtp.ssrcs[0]++; |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 | [diff] [blame] | 184 | send_stream_ = test_->sender_call_->CreateVideoSendStream( |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 185 | test_->GetVideoSendConfig()->Copy(), |
| 186 | test_->GetVideoEncoderConfig()->Copy()); |
| 187 | RTC_DCHECK_EQ(1, test_->GetVideoEncoderConfig()->number_of_streams); |
Danil Chapovalov | 81687b3 | 2019-04-18 13:39:53 | [diff] [blame] | 188 | frame_generator_capturer_ = |
Mirko Bonadei | 317a1f0 | 2019-09-17 15:06:18 | [diff] [blame] | 189 | std::make_unique<test::FrameGeneratorCapturer>( |
Danil Chapovalov | 81687b3 | 2019-04-18 13:39:53 | [diff] [blame] | 190 | test->clock_, |
Artem Titov | 33f9d2b | 2019-12-05 14:59:00 | [diff] [blame] | 191 | test::CreateSquareFrameGenerator(kDefaultWidth, kDefaultHeight, |
| 192 | absl::nullopt, absl::nullopt), |
Danil Chapovalov | 81687b3 | 2019-04-18 13:39:53 | [diff] [blame] | 193 | kDefaultFramerate, *test->task_queue_factory_); |
| 194 | frame_generator_capturer_->Init(); |
Taylor Brandstetter | 49fcc10 | 2018-05-16 21:20:41 | [diff] [blame] | 195 | send_stream_->SetSource(frame_generator_capturer_.get(), |
| 196 | DegradationPreference::MAINTAIN_FRAMERATE); |
pbos@webrtc.org | a5c8d2c | 2014-04-24 11:13:21 | [diff] [blame] | 197 | send_stream_->Start(); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 198 | |
Tommi | f6f4543 | 2022-05-20 13:21:20 | [diff] [blame] | 199 | VideoReceiveStreamInterface::Decoder decoder; |
Philip Eliasson | 2b068ce | 2020-08-03 15:55:10 | [diff] [blame] | 200 | test_->receive_config_.decoder_factory = &decoder_factory_; |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 201 | decoder.payload_type = test_->GetVideoSendConfig()->rtp.payload_type; |
Niels Möller | cb7e1d2 | 2018-09-11 13:56:04 | [diff] [blame] | 202 | decoder.video_format = |
| 203 | SdpVideoFormat(test_->GetVideoSendConfig()->rtp.payload_name); |
aleloi | 5d78e8d | 2016-11-08 11:44:54 | [diff] [blame] | 204 | test_->receive_config_.decoders.clear(); |
| 205 | test_->receive_config_.decoders.push_back(decoder); |
| 206 | test_->receive_config_.rtp.remote_ssrc = |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 207 | test_->GetVideoSendConfig()->rtp.ssrcs[0]; |
aleloi | 5d78e8d | 2016-11-08 11:44:54 | [diff] [blame] | 208 | test_->receive_config_.rtp.local_ssrc++; |
| 209 | test_->receive_config_.renderer = &test->fake_renderer_; |
| 210 | video_receive_stream_ = test_->receiver_call_->CreateVideoReceiveStream( |
| 211 | test_->receive_config_.Copy()); |
| 212 | video_receive_stream_->Start(); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 213 | is_sending_receiving_ = true; |
| 214 | } |
| 215 | |
| 216 | ~Stream() { |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 217 | EXPECT_FALSE(is_sending_receiving_); |
perkj | 9fdbda6 | 2016-09-15 16:19:20 | [diff] [blame] | 218 | test_->sender_call_->DestroyVideoSendStream(send_stream_); |
perkj | a49cbd3 | 2016-09-16 14:53:41 | [diff] [blame] | 219 | frame_generator_capturer_.reset(nullptr); |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 | [diff] [blame] | 220 | send_stream_ = nullptr; |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 221 | if (video_receive_stream_) { |
| 222 | test_->receiver_call_->DestroyVideoReceiveStream(video_receive_stream_); |
| 223 | video_receive_stream_ = nullptr; |
| 224 | } |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 225 | } |
| 226 | |
| 227 | void StopSending() { |
| 228 | if (is_sending_receiving_) { |
pbos@webrtc.org | a5c8d2c | 2014-04-24 11:13:21 | [diff] [blame] | 229 | send_stream_->Stop(); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 230 | if (video_receive_stream_) { |
| 231 | video_receive_stream_->Stop(); |
| 232 | } |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 233 | is_sending_receiving_ = false; |
| 234 | } |
| 235 | } |
| 236 | |
| 237 | private: |
| 238 | BitrateEstimatorTest* test_; |
| 239 | bool is_sending_receiving_; |
| 240 | VideoSendStream* send_stream_; |
Tommi | f6f4543 | 2022-05-20 13:21:20 | [diff] [blame] | 241 | VideoReceiveStreamInterface* video_receive_stream_; |
kwiberg | b25345e | 2016-03-12 14:10:44 | [diff] [blame] | 242 | std::unique_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_; |
Niels Möller | cbcbc22 | 2018-09-28 07:07:24 | [diff] [blame] | 243 | |
| 244 | test::FunctionVideoDecoderFactory decoder_factory_; |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 245 | }; |
| 246 | |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 247 | LogObserver receiver_log_; |
kwiberg | b25345e | 2016-03-12 14:10:44 | [diff] [blame] | 248 | std::unique_ptr<test::DirectTransport> send_transport_; |
| 249 | std::unique_ptr<test::DirectTransport> receive_transport_; |
Tommi | f6f4543 | 2022-05-20 13:21:20 | [diff] [blame] | 250 | VideoReceiveStreamInterface::Config receive_config_; |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 251 | std::vector<Stream*> streams_; |
| 252 | }; |
| 253 | |
Erik Språng | 468e62a | 2015-07-06 08:50:47 | [diff] [blame] | 254 | static const char* kAbsSendTimeLog = |
| 255 | "RemoteBitrateEstimatorAbsSendTime: Instantiating."; |
| 256 | static const char* kSingleStreamLog = |
| 257 | "RemoteBitrateEstimatorSingleStream: Instantiating."; |
| 258 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 259 | TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefaultForVideo) { |
Danil Chapovalov | e519f38 | 2022-08-11 10:26:09 | [diff] [blame] | 260 | SendTask(task_queue(), [this]() { |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 261 | GetVideoSendConfig()->rtp.extensions.push_back( |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 262 | RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId)); |
| 263 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 264 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 265 | streams_.push_back(new Stream(this)); |
| 266 | }); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame] | 267 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 268 | } |
| 269 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 270 | TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) { |
Danil Chapovalov | e519f38 | 2022-08-11 10:26:09 | [diff] [blame] | 271 | SendTask(task_queue(), [this]() { |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 272 | GetVideoSendConfig()->rtp.extensions.push_back( |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 273 | RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId)); |
| 274 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 275 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 276 | receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 277 | receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); |
| 278 | streams_.push_back(new Stream(this)); |
| 279 | }); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame] | 280 | EXPECT_TRUE(receiver_log_.Wait()); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 281 | } |
| 282 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 283 | TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) { |
Danil Chapovalov | e519f38 | 2022-08-11 10:26:09 | [diff] [blame] | 284 | SendTask(task_queue(), [this]() { |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 285 | GetVideoSendConfig()->rtp.extensions.push_back( |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 286 | RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId)); |
| 287 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 288 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 289 | streams_.push_back(new Stream(this)); |
| 290 | }); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame] | 291 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 292 | |
Danil Chapovalov | e519f38 | 2022-08-11 10:26:09 | [diff] [blame] | 293 | SendTask(task_queue(), [this]() { |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 294 | GetVideoSendConfig()->rtp.extensions[0] = |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 295 | RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId); |
| 296 | receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 297 | receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); |
| 298 | streams_.push_back(new Stream(this)); |
| 299 | }); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame] | 300 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 301 | } |
| 302 | |
deadbeef | 1086ed6 | 2016-04-22 17:52:40 | [diff] [blame] | 303 | // This test is flaky. See webrtc:5790. |
| 304 | TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOFForVideo) { |
Danil Chapovalov | e519f38 | 2022-08-11 10:26:09 | [diff] [blame] | 305 | SendTask(task_queue(), [this]() { |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 306 | GetVideoSendConfig()->rtp.extensions.push_back( |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 307 | RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId)); |
| 308 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 309 | receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); |
| 310 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 311 | streams_.push_back(new Stream(this)); |
| 312 | }); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame] | 313 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 314 | |
Danil Chapovalov | e519f38 | 2022-08-11 10:26:09 | [diff] [blame] | 315 | SendTask(task_queue(), [this]() { |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 316 | GetVideoSendConfig()->rtp.extensions[0] = |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 317 | RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId); |
| 318 | receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); |
| 319 | receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 320 | streams_.push_back(new Stream(this)); |
| 321 | }); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame] | 322 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 323 | |
Danil Chapovalov | e519f38 | 2022-08-11 10:26:09 | [diff] [blame] | 324 | SendTask(task_queue(), [this]() { |
Sebastian Jansson | f33905d | 2018-07-13 07:49:00 | [diff] [blame] | 325 | GetVideoSendConfig()->rtp.extensions[0] = |
eladalon | 413ee9a | 2017-08-22 11:02:52 | [diff] [blame] | 326 | RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId); |
| 327 | receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); |
| 328 | receiver_log_.PushExpectedLogLine( |
| 329 | "WrappingBitrateEstimator: Switching to transmission time offset RBE."); |
| 330 | streams_.push_back(new Stream(this)); |
| 331 | streams_[0]->StopSending(); |
| 332 | streams_[1]->StopSending(); |
| 333 | }); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame] | 334 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 335 | } |
| 336 | } // namespace webrtc |