src/third_party/webrtc/video/bitrate_estimator_tests.cc

   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/base/thread_annotations.h"
  17 #include "webrtc/call.h"
  18 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
  19 #include "webrtc/system_wrappers/interface/event_wrapper.h"
  20 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  21 #include "webrtc/system_wrappers/interface/trace.h"
  22 #include "webrtc/test/call_test.h"
  23 #include "webrtc/test/direct_transport.h"
  24 #include "webrtc/test/encoder_settings.h"
  25 #include "webrtc/test/fake_decoder.h"
  26 #include "webrtc/test/fake_encoder.h"
  27 #include "webrtc/test/frame_generator_capturer.h"
  28
  29 namespace webrtc {
  30 namespace {
  31 // Note: consider to write tests that don't depend on the trace system instead
  32 // of re-using this class.
  33 class TraceObserver {
  34  public:
  35   TraceObserver() {
  36     Trace::set_level_filter(kTraceTerseInfo);
  37
  38     Trace::CreateTrace();
  39     Trace::SetTraceCallback(&callback_);
  40
  41     // Call webrtc trace to initialize the tracer that would otherwise trigger a
  42     // data-race if left to be initialized by multiple threads (i.e. threads
  43     // spawned by test::DirectTransport members in BitrateEstimatorTest).
  44     WEBRTC_TRACE(kTraceStateInfo,
  45                  kTraceUtility,
  46                  -1,
  47                  "Instantiate without data races.");
  48   }
  49
  50   ~TraceObserver() {
  51     Trace::SetTraceCallback(NULL);
  52     Trace::ReturnTrace();
  53   }
  54
  55   void PushExpectedLogLine(const std::string& expected_log_line) {
  56     callback_.PushExpectedLogLine(expected_log_line);
  57   }
  58
  59   EventTypeWrapper Wait() {
  60     return callback_.Wait();
  61   }
  62
  63  private:
  64   class Callback : public TraceCallback {
  65    public:
  66     Callback()
  67         : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
  68           done_(EventWrapper::Create()) {}
  69
  70     virtual void Print(TraceLevel level,
  71                        const char* message,
  72                        int length) OVERRIDE {
  73       CriticalSectionScoped lock(crit_sect_.get());
  74       std::string msg(message);
  75       if (msg.find("BitrateEstimator") != std::string::npos) {
  76         received_log_lines_.push_back(msg);
  77       }
  78       int num_popped = 0;
  79       while (!received_log_lines_.empty() && !expected_log_lines_.empty()) {
  80         std::string a = received_log_lines_.front();
  81         std::string b = expected_log_lines_.front();
  82         received_log_lines_.pop_front();
  83         expected_log_lines_.pop_front();
  84         num_popped++;
  85         EXPECT_TRUE(a.find(b) != std::string::npos);
  86       }
  87       if (expected_log_lines_.size() <= 0) {
  88         if (num_popped > 0) {
  89           done_->Set();
  90         }
  91         return;
  92       }
  93     }
  94
  95     EventTypeWrapper Wait() {
  96       return done_->Wait(test::CallTest::kDefaultTimeoutMs);
  97     }
  98
  99     void PushExpectedLogLine(const std::string& expected_log_line) {
 100       CriticalSectionScoped lock(crit_sect_.get());
 101       expected_log_lines_.push_back(expected_log_line);
 102     }
 103
 104    private:
 105     typedef std::list<std::string> Strings;
 106     const scoped_ptr<CriticalSectionWrapper> crit_sect_;
 107     Strings received_log_lines_ GUARDED_BY(crit_sect_);
 108     Strings expected_log_lines_ GUARDED_BY(crit_sect_);
 109     scoped_ptr<EventWrapper> done_;
 110   };
 111
 112   Callback callback_;
 113 };
 114 }  // namespace
 115
 116 static const int kTOFExtensionId = 4;
 117 static const int kASTExtensionId = 5;
 118
 119 class BitrateEstimatorTest : public test::CallTest {
 120  public:
 121   BitrateEstimatorTest()
 122       : receiver_trace_(),
 123         send_transport_(),
 124         receive_transport_(),
 125         sender_call_(),
 126         receiver_call_(),
 127         receive_config_(),
 128         streams_() {
 129   }
 130
 131   virtual ~BitrateEstimatorTest() {
 132     EXPECT_TRUE(streams_.empty());
 133   }
 134
 135   virtual void SetUp() {
 136     Call::Config receiver_call_config(&receive_transport_);
 137     receiver_call_.reset(Call::Create(receiver_call_config));
 138
 139     Call::Config sender_call_config(&send_transport_);
 140     sender_call_.reset(Call::Create(sender_call_config));
 141
 142     send_transport_.SetReceiver(receiver_call_->Receiver());
 143     receive_transport_.SetReceiver(sender_call_->Receiver());
 144
 145     send_config_ = VideoSendStream::Config();
 146     send_config_.rtp.ssrcs.push_back(kSendSsrcs[0]);
 147     // Encoders will be set separately per stream.
 148     send_config_.encoder_settings.encoder = NULL;
 149     send_config_.encoder_settings.payload_name = "FAKE";
 150     send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
 151     encoder_config_.streams = test::CreateVideoStreams(1);
 152
 153     receive_config_ = VideoReceiveStream::Config();
 154     // receive_config_.decoders will be set by every stream separately.
 155     receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
 156     receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;
 157     receive_config_.rtp.extensions.push_back(
 158         RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
 159     receive_config_.rtp.extensions.push_back(
 160         RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
 161   }
 162
 163   virtual void TearDown() {
 164     std::for_each(streams_.begin(), streams_.end(),
 165         std::mem_fun(&Stream::StopSending));
 166
 167     send_transport_.StopSending();
 168     receive_transport_.StopSending();
 169
 170     while (!streams_.empty()) {
 171       delete streams_.back();
 172       streams_.pop_back();
 173     }
 174
 175     receiver_call_.reset();
 176   }
 177
 178  protected:
 179   friend class Stream;
 180
 181   class Stream {
 182    public:
 183     explicit Stream(BitrateEstimatorTest* test)
 184         : test_(test),
 185           is_sending_receiving_(false),
 186           send_stream_(NULL),
 187           receive_stream_(NULL),
 188           frame_generator_capturer_(),
 189           fake_encoder_(Clock::GetRealTimeClock()),
 190           fake_decoder_() {
 191       test_->send_config_.rtp.ssrcs[0]++;
 192       test_->send_config_.encoder_settings.encoder = &fake_encoder_;
 193       send_stream_ = test_->sender_call_->CreateVideoSendStream(
 194           test_->send_config_, test_->encoder_config_);
 195       assert(test_->encoder_config_.streams.size() == 1);
 196       frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
 197           send_stream_->Input(),
 198           test_->encoder_config_.streams[0].width,
 199           test_->encoder_config_.streams[0].height,
 200           30,
 201           Clock::GetRealTimeClock()));
 202       send_stream_->Start();
 203       frame_generator_capturer_->Start();
 204
 205       VideoReceiveStream::Decoder decoder;
 206       decoder.decoder = &fake_decoder_;
 207       decoder.payload_type = test_->send_config_.encoder_settings.payload_type;
 208       decoder.payload_name = test_->send_config_.encoder_settings.payload_name;
 209       test_->receive_config_.decoders.push_back(decoder);
 210       test_->receive_config_.rtp.remote_ssrc = test_->send_config_.rtp.ssrcs[0];
 211       test_->receive_config_.rtp.local_ssrc++;
 212       receive_stream_ = test_->receiver_call_->CreateVideoReceiveStream(
 213           test_->receive_config_);
 214       receive_stream_->Start();
 215
 216       is_sending_receiving_ = true;
 217     }
 218
 219     ~Stream() {
 220       frame_generator_capturer_.reset(NULL);
 221       test_->sender_call_->DestroyVideoSendStream(send_stream_);
 222       send_stream_ = NULL;
 223       test_->receiver_call_->DestroyVideoReceiveStream(receive_stream_);
 224       receive_stream_ = NULL;
 225     }
 226
 227     void StopSending() {
 228       if (is_sending_receiving_) {
 229         frame_generator_capturer_->Stop();
 230         send_stream_->Stop();
 231         receive_stream_->Stop();
 232         is_sending_receiving_ = false;
 233       }
 234     }
 235
 236    private:
 237     BitrateEstimatorTest* test_;
 238     bool is_sending_receiving_;
 239     VideoSendStream* send_stream_;
 240     VideoReceiveStream* receive_stream_;
 241     scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
 242     test::FakeEncoder fake_encoder_;
 243     test::FakeDecoder fake_decoder_;
 244   };
 245
 246   TraceObserver receiver_trace_;
 247   test::DirectTransport send_transport_;
 248   test::DirectTransport receive_transport_;
 249   scoped_ptr<Call> sender_call_;
 250   scoped_ptr<Call> receiver_call_;
 251   VideoReceiveStream::Config receive_config_;
 252   std::vector<Stream*> streams_;
 253 };
 254
 255 TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefault) {
 256   send_config_.rtp.extensions.push_back(
 257       RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
 258   receiver_trace_.PushExpectedLogLine(
 259       "RemoteBitrateEstimatorFactory: Instantiating.");
 260   receiver_trace_.PushExpectedLogLine(
 261       "RemoteBitrateEstimatorFactory: Instantiating.");
 262   streams_.push_back(new Stream(this));
 263   EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
 264 }
 265
 266 TEST_F(BitrateEstimatorTest, ImmediatelySwitchToAST) {
 267   send_config_.rtp.extensions.push_back(
 268       RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
 269   receiver_trace_.PushExpectedLogLine(
 270       "RemoteBitrateEstimatorFactory: Instantiating.");
 271   receiver_trace_.PushExpectedLogLine(
 272       "RemoteBitrateEstimatorFactory: Instantiating.");
 273   receiver_trace_.PushExpectedLogLine("Switching to absolute send time RBE.");
 274   receiver_trace_.PushExpectedLogLine(
 275       "AbsoluteSendTimeRemoteBitrateEstimatorFactory: Instantiating.");
 276   streams_.push_back(new Stream(this));
 277   EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
 278 }
 279
 280 TEST_F(BitrateEstimatorTest, SwitchesToAST) {
 281   send_config_.rtp.extensions.push_back(
 282       RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
 283   receiver_trace_.PushExpectedLogLine(
 284       "RemoteBitrateEstimatorFactory: Instantiating.");
 285   receiver_trace_.PushExpectedLogLine(
 286       "RemoteBitrateEstimatorFactory: Instantiating.");
 287   streams_.push_back(new Stream(this));
 288   EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
 289
 290   send_config_.rtp.extensions[0] =
 291       RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId);
 292   receiver_trace_.PushExpectedLogLine("Switching to absolute send time RBE.");
 293   receiver_trace_.PushExpectedLogLine(
 294       "AbsoluteSendTimeRemoteBitrateEstimatorFactory: Instantiating.");
 295   streams_.push_back(new Stream(this));
 296   EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
 297 }
 298
 299 TEST_F(BitrateEstimatorTest, SwitchesToASTThenBackToTOF) {
 300   send_config_.rtp.extensions.push_back(
 301       RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
 302   receiver_trace_.PushExpectedLogLine(
 303       "RemoteBitrateEstimatorFactory: Instantiating.");
 304   receiver_trace_.PushExpectedLogLine(
 305       "RemoteBitrateEstimatorFactory: Instantiating.");
 306   streams_.push_back(new Stream(this));
 307   EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
 308
 309   send_config_.rtp.extensions[0] =
 310       RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId);
 311   receiver_trace_.PushExpectedLogLine("Switching to absolute send time RBE.");
 312   receiver_trace_.PushExpectedLogLine(
 313       "AbsoluteSendTimeRemoteBitrateEstimatorFactory: Instantiating.");
 314   streams_.push_back(new Stream(this));
 315   EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
 316
 317   send_config_.rtp.extensions[0] =
 318       RtpExtension(RtpExtension::kTOffset, kTOFExtensionId);
 319   receiver_trace_.PushExpectedLogLine(
 320       "WrappingBitrateEstimator: Switching to transmission time offset RBE.");
 321   receiver_trace_.PushExpectedLogLine(
 322       "RemoteBitrateEstimatorFactory: Instantiating.");
 323   streams_.push_back(new Stream(this));
 324   streams_[0]->StopSending();
 325   streams_[1]->StopSending();
 326   EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
 327 }
 328 }  // namespace webrtc