pbos@webrtc.org | 46f7288 | 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> |
| 12 | #include <string> |
| 13 | |
| 14 | #include "testing/gtest/include/gtest/gtest.h" |
| 15 | |
| 16 | #include "webrtc/call.h" |
| 17 | #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" |
| 18 | #include "webrtc/system_wrappers/interface/event_wrapper.h" |
| 19 | #include "webrtc/system_wrappers/interface/scoped_ptr.h" |
| 20 | #include "webrtc/test/direct_transport.h" |
pbos@webrtc.org | e2a7a77 | 2014-03-19 08:43:57 +0000 | [diff] [blame] | 21 | #include "webrtc/test/encoder_settings.h" |
pbos@webrtc.org | 46f7288 | 2013-12-16 12:24:44 +0000 | [diff] [blame] | 22 | #include "webrtc/test/fake_decoder.h" |
| 23 | #include "webrtc/test/fake_encoder.h" |
| 24 | #include "webrtc/test/frame_generator_capturer.h" |
| 25 | |
| 26 | namespace webrtc { |
| 27 | |
| 28 | static const int kTOFExtensionId = 4; |
| 29 | static const int kASTExtensionId = 5; |
| 30 | |
| 31 | static unsigned int kDefaultTimeoutMs = 30 * 1000; |
| 32 | static const uint32_t kSendSsrc = 0x654321; |
| 33 | static const uint32_t kReceiverLocalSsrc = 0x123456; |
| 34 | static const uint8_t kSendPayloadType = 125; |
| 35 | |
| 36 | class BitrateEstimatorTest : public ::testing::Test { |
| 37 | public: |
| 38 | BitrateEstimatorTest() |
| 39 | : receiver_trace_(), |
| 40 | send_transport_(), |
| 41 | receive_transport_(), |
| 42 | sender_call_(), |
| 43 | receiver_call_(), |
| 44 | send_config_(), |
| 45 | receive_config_(), |
| 46 | streams_() { |
| 47 | } |
| 48 | |
| 49 | virtual ~BitrateEstimatorTest() { |
| 50 | EXPECT_TRUE(streams_.empty()); |
| 51 | } |
| 52 | |
| 53 | virtual void SetUp() { |
| 54 | // Create receiver call first so that we are guaranteed to have a trace |
| 55 | // callback when sender call is created. |
| 56 | Call::Config receiver_call_config(&receive_transport_); |
| 57 | receiver_call_config.trace_callback = &receiver_trace_; |
| 58 | receiver_call_.reset(Call::Create(receiver_call_config)); |
| 59 | |
| 60 | Call::Config sender_call_config(&send_transport_); |
| 61 | sender_call_.reset(Call::Create(sender_call_config)); |
| 62 | |
| 63 | send_transport_.SetReceiver(receiver_call_->Receiver()); |
| 64 | receive_transport_.SetReceiver(sender_call_->Receiver()); |
| 65 | |
| 66 | send_config_ = sender_call_->GetDefaultSendConfig(); |
| 67 | send_config_.rtp.ssrcs.push_back(kSendSsrc); |
pbos@webrtc.org | e2a7a77 | 2014-03-19 08:43:57 +0000 | [diff] [blame] | 68 | // Encoders will be set separately per stream. |
| 69 | send_config_.encoder_settings = |
| 70 | test::CreateEncoderSettings(NULL, "FAKE", kSendPayloadType, 1); |
pbos@webrtc.org | 46f7288 | 2013-12-16 12:24:44 +0000 | [diff] [blame] | 71 | |
| 72 | receive_config_ = receiver_call_->GetDefaultReceiveConfig(); |
pbos@webrtc.org | e2a7a77 | 2014-03-19 08:43:57 +0000 | [diff] [blame] | 73 | assert(receive_config_.codecs.empty()); |
| 74 | VideoCodec codec = |
| 75 | test::CreateDecoderVideoCodec(send_config_.encoder_settings); |
| 76 | receive_config_.codecs.push_back(codec); |
pbos@webrtc.org | 46f7288 | 2013-12-16 12:24:44 +0000 | [diff] [blame] | 77 | // receive_config_.external_decoders will be set by every stream separately. |
| 78 | receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0]; |
| 79 | receive_config_.rtp.local_ssrc = kReceiverLocalSsrc; |
| 80 | receive_config_.rtp.extensions.push_back( |
| 81 | RtpExtension(RtpExtension::kTOffset, kTOFExtensionId)); |
| 82 | receive_config_.rtp.extensions.push_back( |
| 83 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId)); |
| 84 | } |
| 85 | |
| 86 | virtual void TearDown() { |
| 87 | std::for_each(streams_.begin(), streams_.end(), |
| 88 | std::mem_fun(&Stream::StopSending)); |
| 89 | |
| 90 | send_transport_.StopSending(); |
| 91 | receive_transport_.StopSending(); |
| 92 | |
| 93 | while (!streams_.empty()) { |
| 94 | delete streams_.back(); |
| 95 | streams_.pop_back(); |
| 96 | } |
| 97 | |
| 98 | // The TraceCallback instance MUST outlive Calls, destroy Calls explicitly. |
| 99 | receiver_call_.reset(); |
| 100 | } |
| 101 | |
| 102 | protected: |
| 103 | friend class Stream; |
| 104 | |
| 105 | class TraceObserver : public TraceCallback { |
| 106 | public: |
| 107 | TraceObserver() |
| 108 | : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()), |
| 109 | received_log_lines_(), |
| 110 | expected_log_lines_(), |
| 111 | done_(EventWrapper::Create()) { |
| 112 | } |
| 113 | |
| 114 | void PushExpectedLogLine(const std::string& expected_log_line) { |
| 115 | CriticalSectionScoped cs(crit_sect_.get()); |
| 116 | expected_log_lines_.push_back(expected_log_line); |
| 117 | } |
| 118 | |
| 119 | virtual void Print(TraceLevel level, |
| 120 | const char* message, |
| 121 | int length) OVERRIDE { |
| 122 | CriticalSectionScoped cs(crit_sect_.get()); |
| 123 | if (!(level & kTraceStateInfo)) { |
| 124 | return; |
| 125 | } |
| 126 | std::string msg(message); |
| 127 | if (msg.find("BitrateEstimator") != std::string::npos) { |
| 128 | received_log_lines_.push_back(msg); |
| 129 | } |
| 130 | int num_popped = 0; |
| 131 | while (!received_log_lines_.empty() && !expected_log_lines_.empty()) { |
| 132 | std::string a = received_log_lines_.front(); |
| 133 | std::string b = expected_log_lines_.front(); |
| 134 | received_log_lines_.pop_front(); |
| 135 | expected_log_lines_.pop_front(); |
| 136 | num_popped++; |
| 137 | EXPECT_TRUE(a.find(b) != std::string::npos); |
| 138 | } |
| 139 | if (expected_log_lines_.size() <= 0) { |
| 140 | if (num_popped > 0) { |
| 141 | done_->Set(); |
| 142 | } |
| 143 | return; |
| 144 | } |
| 145 | } |
| 146 | |
| 147 | EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); } |
| 148 | |
| 149 | private: |
| 150 | typedef std::list<std::string> Strings; |
| 151 | scoped_ptr<CriticalSectionWrapper> crit_sect_; |
| 152 | Strings received_log_lines_; |
| 153 | Strings expected_log_lines_; |
| 154 | scoped_ptr<EventWrapper> done_; |
| 155 | }; |
| 156 | |
| 157 | class Stream { |
| 158 | public: |
| 159 | explicit Stream(BitrateEstimatorTest* test) |
| 160 | : test_(test), |
| 161 | is_sending_receiving_(false), |
| 162 | send_stream_(NULL), |
| 163 | receive_stream_(NULL), |
| 164 | frame_generator_capturer_(), |
| 165 | fake_encoder_(Clock::GetRealTimeClock()), |
| 166 | fake_decoder_() { |
| 167 | test_->send_config_.rtp.ssrcs[0]++; |
pbos@webrtc.org | e2a7a77 | 2014-03-19 08:43:57 +0000 | [diff] [blame] | 168 | test_->send_config_.encoder_settings.encoder = &fake_encoder_; |
pbos@webrtc.org | 46f7288 | 2013-12-16 12:24:44 +0000 | [diff] [blame] | 169 | send_stream_ = |
| 170 | test_->sender_call_->CreateVideoSendStream(test_->send_config_); |
pbos@webrtc.org | e2a7a77 | 2014-03-19 08:43:57 +0000 | [diff] [blame] | 171 | assert(test_->send_config_.encoder_settings.streams.size() == 1); |
| 172 | frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create( |
| 173 | send_stream_->Input(), |
| 174 | test_->send_config_.encoder_settings.streams[0].width, |
| 175 | test_->send_config_.encoder_settings.streams[0].height, |
| 176 | 30, |
| 177 | Clock::GetRealTimeClock())); |
pbos@webrtc.org | 46f7288 | 2013-12-16 12:24:44 +0000 | [diff] [blame] | 178 | send_stream_->StartSending(); |
| 179 | frame_generator_capturer_->Start(); |
| 180 | |
| 181 | ExternalVideoDecoder decoder; |
| 182 | decoder.decoder = &fake_decoder_; |
pbos@webrtc.org | e2a7a77 | 2014-03-19 08:43:57 +0000 | [diff] [blame] | 183 | decoder.payload_type = test_->send_config_.encoder_settings.payload_type; |
pbos@webrtc.org | 46f7288 | 2013-12-16 12:24:44 +0000 | [diff] [blame] | 184 | test_->receive_config_.rtp.remote_ssrc = test_->send_config_.rtp.ssrcs[0]; |
| 185 | test_->receive_config_.rtp.local_ssrc++; |
| 186 | test_->receive_config_.external_decoders.push_back(decoder); |
| 187 | receive_stream_ = test_->receiver_call_->CreateVideoReceiveStream( |
| 188 | test_->receive_config_); |
| 189 | receive_stream_->StartReceiving(); |
| 190 | |
| 191 | is_sending_receiving_ = true; |
| 192 | } |
| 193 | |
| 194 | ~Stream() { |
| 195 | frame_generator_capturer_.reset(NULL); |
| 196 | test_->sender_call_->DestroyVideoSendStream(send_stream_); |
| 197 | send_stream_ = NULL; |
| 198 | test_->receiver_call_->DestroyVideoReceiveStream(receive_stream_); |
| 199 | receive_stream_ = NULL; |
| 200 | } |
| 201 | |
| 202 | void StopSending() { |
| 203 | if (is_sending_receiving_) { |
| 204 | frame_generator_capturer_->Stop(); |
| 205 | send_stream_->StopSending(); |
| 206 | receive_stream_->StopReceiving(); |
| 207 | is_sending_receiving_ = false; |
| 208 | } |
| 209 | } |
| 210 | |
| 211 | private: |
| 212 | BitrateEstimatorTest* test_; |
| 213 | bool is_sending_receiving_; |
| 214 | VideoSendStream* send_stream_; |
| 215 | VideoReceiveStream* receive_stream_; |
| 216 | scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_; |
| 217 | test::FakeEncoder fake_encoder_; |
| 218 | test::FakeDecoder fake_decoder_; |
| 219 | }; |
| 220 | |
| 221 | TraceObserver receiver_trace_; |
| 222 | test::DirectTransport send_transport_; |
| 223 | test::DirectTransport receive_transport_; |
| 224 | scoped_ptr<Call> sender_call_; |
| 225 | scoped_ptr<Call> receiver_call_; |
| 226 | VideoSendStream::Config send_config_; |
| 227 | VideoReceiveStream::Config receive_config_; |
| 228 | std::vector<Stream*> streams_; |
| 229 | }; |
| 230 | |
stefan@webrtc.org | 8d93b11 | 2014-04-07 12:53:28 +0000 | [diff] [blame] | 231 | TEST_F(BitrateEstimatorTest, DISABLED_InstantiatesTOFPerDefault) { |
pbos@webrtc.org | 46f7288 | 2013-12-16 12:24:44 +0000 | [diff] [blame] | 232 | send_config_.rtp.extensions.push_back( |
| 233 | RtpExtension(RtpExtension::kTOffset, kTOFExtensionId)); |
| 234 | receiver_trace_.PushExpectedLogLine( |
| 235 | "RemoteBitrateEstimatorFactory: Instantiating."); |
| 236 | receiver_trace_.PushExpectedLogLine( |
| 237 | "RemoteBitrateEstimatorFactory: Instantiating."); |
| 238 | streams_.push_back(new Stream(this)); |
| 239 | EXPECT_EQ(kEventSignaled, receiver_trace_.Wait()); |
| 240 | } |
| 241 | |
stefan@webrtc.org | 8d93b11 | 2014-04-07 12:53:28 +0000 | [diff] [blame] | 242 | TEST_F(BitrateEstimatorTest, DISABLED_ImmediatelySwitchToAST) { |
solenberg@webrtc.org | 0b9d7ce | 2014-01-08 08:59:44 +0000 | [diff] [blame] | 243 | send_config_.rtp.extensions.push_back( |
| 244 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId)); |
| 245 | receiver_trace_.PushExpectedLogLine( |
| 246 | "RemoteBitrateEstimatorFactory: Instantiating."); |
| 247 | receiver_trace_.PushExpectedLogLine( |
| 248 | "RemoteBitrateEstimatorFactory: Instantiating."); |
| 249 | receiver_trace_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 250 | receiver_trace_.PushExpectedLogLine( |
| 251 | "AbsoluteSendTimeRemoteBitrateEstimatorFactory: Instantiating."); |
| 252 | streams_.push_back(new Stream(this)); |
| 253 | EXPECT_EQ(kEventSignaled, receiver_trace_.Wait()); |
| 254 | } |
| 255 | |
stefan@webrtc.org | 8d93b11 | 2014-04-07 12:53:28 +0000 | [diff] [blame] | 256 | TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToAST) { |
pbos@webrtc.org | 46f7288 | 2013-12-16 12:24:44 +0000 | [diff] [blame] | 257 | send_config_.rtp.extensions.push_back( |
| 258 | RtpExtension(RtpExtension::kTOffset, kTOFExtensionId)); |
| 259 | receiver_trace_.PushExpectedLogLine( |
| 260 | "RemoteBitrateEstimatorFactory: Instantiating."); |
| 261 | receiver_trace_.PushExpectedLogLine( |
| 262 | "RemoteBitrateEstimatorFactory: Instantiating."); |
| 263 | streams_.push_back(new Stream(this)); |
| 264 | EXPECT_EQ(kEventSignaled, receiver_trace_.Wait()); |
| 265 | |
| 266 | send_config_.rtp.extensions[0] = |
| 267 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId); |
| 268 | receiver_trace_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 269 | receiver_trace_.PushExpectedLogLine( |
| 270 | "AbsoluteSendTimeRemoteBitrateEstimatorFactory: Instantiating."); |
| 271 | streams_.push_back(new Stream(this)); |
| 272 | EXPECT_EQ(kEventSignaled, receiver_trace_.Wait()); |
| 273 | } |
| 274 | |
stefan@webrtc.org | 8d93b11 | 2014-04-07 12:53:28 +0000 | [diff] [blame] | 275 | TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOF) { |
pbos@webrtc.org | 46f7288 | 2013-12-16 12:24:44 +0000 | [diff] [blame] | 276 | send_config_.rtp.extensions.push_back( |
| 277 | RtpExtension(RtpExtension::kTOffset, kTOFExtensionId)); |
| 278 | receiver_trace_.PushExpectedLogLine( |
| 279 | "RemoteBitrateEstimatorFactory: Instantiating."); |
| 280 | receiver_trace_.PushExpectedLogLine( |
| 281 | "RemoteBitrateEstimatorFactory: Instantiating."); |
| 282 | streams_.push_back(new Stream(this)); |
| 283 | EXPECT_EQ(kEventSignaled, receiver_trace_.Wait()); |
| 284 | |
| 285 | send_config_.rtp.extensions[0] = |
| 286 | RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId); |
| 287 | receiver_trace_.PushExpectedLogLine("Switching to absolute send time RBE."); |
| 288 | receiver_trace_.PushExpectedLogLine( |
| 289 | "AbsoluteSendTimeRemoteBitrateEstimatorFactory: Instantiating."); |
| 290 | streams_.push_back(new Stream(this)); |
| 291 | EXPECT_EQ(kEventSignaled, receiver_trace_.Wait()); |
| 292 | |
| 293 | send_config_.rtp.extensions[0] = |
| 294 | RtpExtension(RtpExtension::kTOffset, kTOFExtensionId); |
| 295 | receiver_trace_.PushExpectedLogLine( |
| 296 | "WrappingBitrateEstimator: Switching to transmission time offset RBE."); |
| 297 | receiver_trace_.PushExpectedLogLine( |
| 298 | "RemoteBitrateEstimatorFactory: Instantiating."); |
| 299 | streams_.push_back(new Stream(this)); |
| 300 | streams_[0]->StopSending(); |
| 301 | streams_[1]->StopSending(); |
| 302 | EXPECT_EQ(kEventSignaled, receiver_trace_.Wait()); |
| 303 | } |
| 304 | } // namespace webrtc |