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