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> |
| 12 | #include <string> |
| 13 | |
| 14 | #include "testing/gtest/include/gtest/gtest.h" |
| 15 | |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 16 | #include "webrtc/audio_state.h" |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 | [diff] [blame] | 17 | #include "webrtc/base/checks.h" |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 18 | #include "webrtc/base/event.h" |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 19 | #include "webrtc/base/logging.h" |
kwiberg@webrtc.org | 00b8f6b | 2015-02-26 14:34:55 | [diff] [blame] | 20 | #include "webrtc/base/scoped_ptr.h" |
pbos@webrtc.org | 38344ed | 2014-09-24 06:05:00 | [diff] [blame] | 21 | #include "webrtc/base/thread_annotations.h" |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 22 | #include "webrtc/call.h" |
Henrik Kjellander | 98f5351 | 2015-10-28 17:17:40 | [diff] [blame] | 23 | #include "webrtc/system_wrappers/include/critical_section_wrapper.h" |
Henrik Kjellander | 98f5351 | 2015-10-28 17:17:40 | [diff] [blame] | 24 | #include "webrtc/system_wrappers/include/trace.h" |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 | [diff] [blame] | 25 | #include "webrtc/test/call_test.h" |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 26 | #include "webrtc/test/direct_transport.h" |
pbos@webrtc.org | f577ae9 | 2014-03-19 08:43:57 | [diff] [blame] | 27 | #include "webrtc/test/encoder_settings.h" |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 28 | #include "webrtc/test/fake_decoder.h" |
| 29 | #include "webrtc/test/fake_encoder.h" |
Fredrik Solenberg | 0ccae13 | 2015-11-03 09:15:49 | [diff] [blame] | 30 | #include "webrtc/test/mock_voice_engine.h" |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 31 | #include "webrtc/test/frame_generator_capturer.h" |
| 32 | |
| 33 | namespace webrtc { |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 34 | namespace { |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 35 | // 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] | 36 | // writing tests that don't depend on the logging system. |
| 37 | class LogObserver { |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 38 | public: |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 39 | LogObserver() { rtc::LogMessage::AddLogToStream(&callback_, rtc::LS_INFO); } |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 40 | |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 41 | ~LogObserver() { rtc::LogMessage::RemoveLogToStream(&callback_); } |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 42 | |
| 43 | void PushExpectedLogLine(const std::string& expected_log_line) { |
| 44 | callback_.PushExpectedLogLine(expected_log_line); |
| 45 | } |
| 46 | |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 47 | bool Wait() { return callback_.Wait(); } |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 48 | |
| 49 | private: |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 50 | class Callback : public rtc::LogSink { |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 51 | public: |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 52 | Callback() : done_(false, false) {} |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 53 | |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 54 | void OnLogMessage(const std::string& message) override { |
Peter Boström | f2f8283 | 2015-05-01 11:00:41 | [diff] [blame] | 55 | rtc::CritScope lock(&crit_sect_); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 56 | // Ignore log lines that are due to missing AST extensions, these are |
| 57 | // logged when we switch back from AST to TOF until the wrapping bitrate |
| 58 | // estimator gives up on using AST. |
| 59 | if (message.find("BitrateEstimator") != std::string::npos && |
| 60 | message.find("packet is missing") == std::string::npos) { |
| 61 | received_log_lines_.push_back(message); |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 62 | } |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 63 | |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 64 | int num_popped = 0; |
| 65 | while (!received_log_lines_.empty() && !expected_log_lines_.empty()) { |
| 66 | std::string a = received_log_lines_.front(); |
| 67 | std::string b = expected_log_lines_.front(); |
| 68 | received_log_lines_.pop_front(); |
| 69 | expected_log_lines_.pop_front(); |
| 70 | num_popped++; |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 71 | EXPECT_TRUE(a.find(b) != std::string::npos) << a << " != " << b; |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 72 | } |
| 73 | if (expected_log_lines_.size() <= 0) { |
| 74 | if (num_popped > 0) { |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 75 | done_.Set(); |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 76 | } |
| 77 | return; |
| 78 | } |
| 79 | } |
| 80 | |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 81 | bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeoutMs); } |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 82 | |
| 83 | void PushExpectedLogLine(const std::string& expected_log_line) { |
Peter Boström | f2f8283 | 2015-05-01 11:00:41 | [diff] [blame] | 84 | rtc::CritScope lock(&crit_sect_); |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 85 | expected_log_lines_.push_back(expected_log_line); |
| 86 | } |
| 87 | |
| 88 | private: |
| 89 | typedef std::list<std::string> Strings; |
Peter Boström | f2f8283 | 2015-05-01 11:00:41 | [diff] [blame] | 90 | rtc::CriticalSection crit_sect_; |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 91 | Strings received_log_lines_ GUARDED_BY(crit_sect_); |
| 92 | Strings expected_log_lines_ GUARDED_BY(crit_sect_); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 93 | rtc::Event done_; |
andresp@webrtc.org | b941fe8 | 2014-07-07 08:50:48 | [diff] [blame] | 94 | }; |
| 95 | |
| 96 | Callback callback_; |
| 97 | }; |
| 98 | } // namespace |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 99 | |
| 100 | static const int kTOFExtensionId = 4; |
| 101 | static const int kASTExtensionId = 5; |
| 102 | |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 | [diff] [blame] | 103 | class BitrateEstimatorTest : public test::CallTest { |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 104 | public: |
stefan | f116bd0 | 2015-10-27 15:29:42 | [diff] [blame] | 105 | BitrateEstimatorTest() : receive_config_(nullptr) {} |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 106 | |
Fredrik Solenberg | 0ccae13 | 2015-11-03 09:15:49 | [diff] [blame] | 107 | virtual ~BitrateEstimatorTest() { EXPECT_TRUE(streams_.empty()); } |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 108 | |
| 109 | virtual void SetUp() { |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 110 | AudioState::Config audio_state_config; |
| 111 | audio_state_config.voice_engine = &mock_voice_engine_; |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 112 | Call::Config config; |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 113 | config.audio_state = AudioState::Create(audio_state_config); |
Fredrik Solenberg | 4f4ec0a | 2015-10-22 08:49:27 | [diff] [blame] | 114 | receiver_call_.reset(Call::Create(config)); |
| 115 | sender_call_.reset(Call::Create(config)); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 116 | |
stefan | f116bd0 | 2015-10-27 15:29:42 | [diff] [blame] | 117 | send_transport_.reset(new test::DirectTransport(sender_call_.get())); |
| 118 | send_transport_->SetReceiver(receiver_call_->Receiver()); |
| 119 | receive_transport_.reset(new test::DirectTransport(receiver_call_.get())); |
| 120 | receive_transport_->SetReceiver(sender_call_->Receiver()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 121 | |
stefan | f116bd0 | 2015-10-27 15:29:42 | [diff] [blame] | 122 | send_config_ = VideoSendStream::Config(send_transport_.get()); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 | [diff] [blame] | 123 | send_config_.rtp.ssrcs.push_back(kSendSsrcs[0]); |
pbos@webrtc.org | f577ae9 | 2014-03-19 08:43:57 | [diff] [blame] | 124 | // Encoders will be set separately per stream. |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 | [diff] [blame] | 125 | send_config_.encoder_settings.encoder = nullptr; |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 | [diff] [blame] | 126 | send_config_.encoder_settings.payload_name = "FAKE"; |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 | [diff] [blame] | 127 | send_config_.encoder_settings.payload_type = kFakeSendPayloadType; |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 | [diff] [blame] | 128 | encoder_config_.streams = test::CreateVideoStreams(1); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 129 | |
stefan | f116bd0 | 2015-10-27 15:29:42 | [diff] [blame] | 130 | receive_config_ = VideoReceiveStream::Config(receive_transport_.get()); |
pbos@webrtc.org | 776e6f2 | 2014-10-29 15:28:39 | [diff] [blame] | 131 | // receive_config_.decoders will be set by every stream separately. |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 132 | receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0]; |
| 133 | receive_config_.rtp.local_ssrc = kReceiverLocalSsrc; |
Peter Boström | d7da120 | 2015-06-05 12:09:38 | [diff] [blame] | 134 | receive_config_.rtp.remb = true; |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 135 | receive_config_.rtp.extensions.push_back( |
| 136 | RtpExtension(RtpExtension::kTOffset, kTOFExtensionId)); |
| 137 | receive_config_.rtp.extensions.push_back( |
| 138 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId)); |
| 139 | } |
| 140 | |
| 141 | virtual void TearDown() { |
| 142 | std::for_each(streams_.begin(), streams_.end(), |
Fredrik Solenberg | 0ccae13 | 2015-11-03 09:15:49 | [diff] [blame] | 143 | std::mem_fun(&Stream::StopSending)); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 144 | |
stefan | f116bd0 | 2015-10-27 15:29:42 | [diff] [blame] | 145 | send_transport_->StopSending(); |
| 146 | receive_transport_->StopSending(); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 147 | |
| 148 | while (!streams_.empty()) { |
| 149 | delete streams_.back(); |
| 150 | streams_.pop_back(); |
| 151 | } |
| 152 | |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 153 | receiver_call_.reset(); |
solenberg | 566ef24 | 2015-11-06 23:34:49 | [diff] [blame] | 154 | sender_call_.reset(); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 155 | } |
| 156 | |
| 157 | protected: |
| 158 | friend class Stream; |
| 159 | |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 160 | class Stream { |
| 161 | public: |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 162 | Stream(BitrateEstimatorTest* test, bool receive_audio) |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 163 | : test_(test), |
| 164 | is_sending_receiving_(false), |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 | [diff] [blame] | 165 | send_stream_(nullptr), |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 166 | audio_receive_stream_(nullptr), |
| 167 | video_receive_stream_(nullptr), |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 168 | frame_generator_capturer_(), |
| 169 | fake_encoder_(Clock::GetRealTimeClock()), |
| 170 | fake_decoder_() { |
| 171 | test_->send_config_.rtp.ssrcs[0]++; |
pbos@webrtc.org | f577ae9 | 2014-03-19 08:43:57 | [diff] [blame] | 172 | test_->send_config_.encoder_settings.encoder = &fake_encoder_; |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 | [diff] [blame] | 173 | send_stream_ = test_->sender_call_->CreateVideoSendStream( |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 | [diff] [blame] | 174 | test_->send_config_, test_->encoder_config_); |
henrikg | 91d6ede | 2015-09-17 07:24:34 | [diff] [blame] | 175 | RTC_DCHECK_EQ(1u, test_->encoder_config_.streams.size()); |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 | [diff] [blame] | 176 | frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create( |
Fredrik Solenberg | 0ccae13 | 2015-11-03 09:15:49 | [diff] [blame] | 177 | send_stream_->Input(), test_->encoder_config_.streams[0].width, |
| 178 | test_->encoder_config_.streams[0].height, 30, |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 | [diff] [blame] | 179 | Clock::GetRealTimeClock())); |
pbos@webrtc.org | a5c8d2c | 2014-04-24 11:13:21 | [diff] [blame] | 180 | send_stream_->Start(); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 181 | frame_generator_capturer_->Start(); |
| 182 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 183 | if (receive_audio) { |
| 184 | AudioReceiveStream::Config receive_config; |
| 185 | receive_config.rtp.remote_ssrc = test_->send_config_.rtp.ssrcs[0]; |
henrikg | 91d6ede | 2015-09-17 07:24:34 | [diff] [blame] | 186 | // Bogus non-default id to prevent hitting a RTC_DCHECK when creating |
| 187 | // the AudioReceiveStream. Every receive stream has to correspond to |
| 188 | // an underlying channel id. |
pbos | 8fc7fa7 | 2015-07-15 15:02:58 | [diff] [blame] | 189 | receive_config.voe_channel_id = 0; |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 190 | receive_config.rtp.extensions.push_back( |
| 191 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId)); |
pbos | 6bb1b6e | 2015-07-24 14:10:18 | [diff] [blame] | 192 | receive_config.combined_audio_video_bwe = true; |
stefan | f116bd0 | 2015-10-27 15:29:42 | [diff] [blame] | 193 | audio_receive_stream_ = |
| 194 | test_->receiver_call_->CreateAudioReceiveStream(receive_config); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 195 | } else { |
| 196 | VideoReceiveStream::Decoder decoder; |
| 197 | decoder.decoder = &fake_decoder_; |
| 198 | decoder.payload_type = |
| 199 | test_->send_config_.encoder_settings.payload_type; |
| 200 | decoder.payload_name = |
| 201 | test_->send_config_.encoder_settings.payload_name; |
Peter Boström | 521af4e | 2015-11-27 15:35:04 | [diff] [blame] | 202 | test_->receive_config_.decoders.clear(); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 203 | test_->receive_config_.decoders.push_back(decoder); |
| 204 | test_->receive_config_.rtp.remote_ssrc = |
| 205 | test_->send_config_.rtp.ssrcs[0]; |
| 206 | test_->receive_config_.rtp.local_ssrc++; |
| 207 | video_receive_stream_ = test_->receiver_call_->CreateVideoReceiveStream( |
| 208 | test_->receive_config_); |
| 209 | video_receive_stream_->Start(); |
| 210 | } |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 211 | is_sending_receiving_ = true; |
| 212 | } |
| 213 | |
| 214 | ~Stream() { |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 215 | EXPECT_FALSE(is_sending_receiving_); |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 | [diff] [blame] | 216 | frame_generator_capturer_.reset(nullptr); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 217 | test_->sender_call_->DestroyVideoSendStream(send_stream_); |
pbos@webrtc.org | 2b4ce3a | 2015-03-23 13:12:24 | [diff] [blame] | 218 | send_stream_ = nullptr; |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 219 | if (audio_receive_stream_) { |
| 220 | test_->receiver_call_->DestroyAudioReceiveStream(audio_receive_stream_); |
| 221 | audio_receive_stream_ = nullptr; |
| 222 | } |
| 223 | if (video_receive_stream_) { |
| 224 | test_->receiver_call_->DestroyVideoReceiveStream(video_receive_stream_); |
| 225 | video_receive_stream_ = nullptr; |
| 226 | } |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 227 | } |
| 228 | |
| 229 | void StopSending() { |
| 230 | if (is_sending_receiving_) { |
| 231 | frame_generator_capturer_->Stop(); |
pbos@webrtc.org | a5c8d2c | 2014-04-24 11:13:21 | [diff] [blame] | 232 | send_stream_->Stop(); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 233 | if (video_receive_stream_) { |
| 234 | video_receive_stream_->Stop(); |
| 235 | } |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 236 | is_sending_receiving_ = false; |
| 237 | } |
| 238 | } |
| 239 | |
| 240 | private: |
| 241 | BitrateEstimatorTest* test_; |
| 242 | bool is_sending_receiving_; |
| 243 | VideoSendStream* send_stream_; |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 244 | AudioReceiveStream* audio_receive_stream_; |
| 245 | VideoReceiveStream* video_receive_stream_; |
kwiberg@webrtc.org | 00b8f6b | 2015-02-26 14:34:55 | [diff] [blame] | 246 | rtc::scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_; |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 247 | test::FakeEncoder fake_encoder_; |
| 248 | test::FakeDecoder fake_decoder_; |
| 249 | }; |
| 250 | |
solenberg | 3a94154 | 2015-11-16 15:34:50 | [diff] [blame] | 251 | testing::NiceMock<test::MockVoiceEngine> mock_voice_engine_; |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 252 | LogObserver receiver_log_; |
stefan | f116bd0 | 2015-10-27 15:29:42 | [diff] [blame] | 253 | rtc::scoped_ptr<test::DirectTransport> send_transport_; |
| 254 | rtc::scoped_ptr<test::DirectTransport> receive_transport_; |
kwiberg@webrtc.org | 00b8f6b | 2015-02-26 14:34:55 | [diff] [blame] | 255 | rtc::scoped_ptr<Call> sender_call_; |
| 256 | rtc::scoped_ptr<Call> receiver_call_; |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 257 | VideoReceiveStream::Config receive_config_; |
| 258 | std::vector<Stream*> streams_; |
| 259 | }; |
| 260 | |
Erik Språng | 468e62a | 2015-07-06 08:50:47 | [diff] [blame] | 261 | static const char* kAbsSendTimeLog = |
| 262 | "RemoteBitrateEstimatorAbsSendTime: Instantiating."; |
| 263 | static const char* kSingleStreamLog = |
| 264 | "RemoteBitrateEstimatorSingleStream: Instantiating."; |
| 265 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 266 | TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefaultForVideo) { |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 267 | send_config_.rtp.extensions.push_back( |
| 268 | RtpExtension(RtpExtension::kTOffset, kTOFExtensionId)); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 269 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 270 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 271 | streams_.push_back(new Stream(this, false)); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 272 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 273 | } |
| 274 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 275 | TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForAudio) { |
solenberg@webrtc.org | ab24051 | 2014-01-08 08:59:44 | [diff] [blame] | 276 | send_config_.rtp.extensions.push_back( |
| 277 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId)); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 278 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 279 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 280 | receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 281 | receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 282 | streams_.push_back(new Stream(this, true)); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 283 | EXPECT_TRUE(receiver_log_.Wait()); |
solenberg@webrtc.org | ab24051 | 2014-01-08 08:59:44 | [diff] [blame] | 284 | } |
| 285 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 286 | TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) { |
| 287 | send_config_.rtp.extensions.push_back( |
| 288 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId)); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 289 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 290 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 291 | receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 292 | receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 293 | streams_.push_back(new Stream(this, false)); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 294 | EXPECT_TRUE(receiver_log_.Wait()); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 295 | } |
| 296 | |
| 297 | TEST_F(BitrateEstimatorTest, SwitchesToASTForAudio) { |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 298 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 299 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 300 | streams_.push_back(new Stream(this, true)); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 301 | EXPECT_TRUE(receiver_log_.Wait()); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 302 | |
| 303 | send_config_.rtp.extensions.push_back( |
| 304 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId)); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 305 | receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 306 | receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 307 | streams_.push_back(new Stream(this, true)); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 308 | EXPECT_TRUE(receiver_log_.Wait()); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 309 | } |
| 310 | |
| 311 | TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) { |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 312 | send_config_.rtp.extensions.push_back( |
| 313 | RtpExtension(RtpExtension::kTOffset, kTOFExtensionId)); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 314 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 315 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 316 | streams_.push_back(new Stream(this, false)); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 317 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 318 | |
| 319 | send_config_.rtp.extensions[0] = |
| 320 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 321 | receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 322 | receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 323 | streams_.push_back(new Stream(this, false)); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 324 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 325 | } |
| 326 | |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 327 | TEST_F(BitrateEstimatorTest, SwitchesToASTThenBackToTOFForVideo) { |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 328 | send_config_.rtp.extensions.push_back( |
| 329 | RtpExtension(RtpExtension::kTOffset, kTOFExtensionId)); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 330 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
| 331 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 332 | streams_.push_back(new Stream(this, false)); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 333 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 334 | |
| 335 | send_config_.rtp.extensions[0] = |
| 336 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 337 | receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 338 | receiver_log_.PushExpectedLogLine(kAbsSendTimeLog); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 339 | streams_.push_back(new Stream(this, false)); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 340 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 341 | |
| 342 | send_config_.rtp.extensions[0] = |
| 343 | RtpExtension(RtpExtension::kTOffset, kTOFExtensionId); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 344 | receiver_log_.PushExpectedLogLine( |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 345 | "WrappingBitrateEstimator: Switching to transmission time offset RBE."); |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 346 | receiver_log_.PushExpectedLogLine(kSingleStreamLog); |
Fredrik Solenberg | 23fba1f | 2015-04-29 13:24:01 | [diff] [blame] | 347 | streams_.push_back(new Stream(this, false)); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 348 | streams_[0]->StopSending(); |
| 349 | streams_[1]->StopSending(); |
Peter Boström | 5811a39 | 2015-12-10 12:02:50 | [diff] [blame^] | 350 | EXPECT_TRUE(receiver_log_.Wait()); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 351 | } |
| 352 | } // namespace webrtc |