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/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/system_wrappers/interface/thread_annotations.h"
  21 #include "webrtc/test/direct_transport.h"
  22 #include "webrtc/test/encoder_settings.h"
  23 #include "webrtc/test/fake_decoder.h"
  24 #include "webrtc/test/fake_encoder.h"
  25 #include "webrtc/test/frame_generator_capturer.h"
  26
  27 namespace webrtc {
  28
  29 static const int kTOFExtensionId = 4;
  30 static const int kASTExtensionId = 5;
  31
  32 static unsigned int kDefaultTimeoutMs = 30 * 1000;
  33 static const uint32_t kSendSsrc = 0x654321;
  34 static const uint32_t kReceiverLocalSsrc = 0x123456;
  35 static const uint8_t kSendPayloadType = 125;
  36
  37 class BitrateEstimatorTest : public ::testing::Test {
  38  public:
  39   BitrateEstimatorTest()
  40       : receiver_trace_(),
  41         send_transport_(),
  42         receive_transport_(),
  43         sender_call_(),
  44         receiver_call_(),
  45         send_config_(),
  46         receive_config_(),
  47         streams_() {
  48   }
  49
  50   virtual ~BitrateEstimatorTest() {
  51     EXPECT_TRUE(streams_.empty());
  52   }
  53
  54   virtual void SetUp() {
  55     // Create receiver call first so that we are guaranteed to have a trace
  56     // callback when sender call is created.
  57     Call::Config receiver_call_config(&receive_transport_);
  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);
  68     // Encoders will be set separately per stream.
  69     send_config_.encoder_settings =
  70         test::CreateEncoderSettings(NULL, "FAKE", kSendPayloadType, 1);
  71
  72     receive_config_ = receiver_call_->GetDefaultReceiveConfig();
  73     assert(receive_config_.codecs.empty());
  74     VideoCodec codec =
  75         test::CreateDecoderVideoCodec(send_config_.encoder_settings);
  76     receive_config_.codecs.push_back(codec);
  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 lock(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 lock(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     const scoped_ptr<CriticalSectionWrapper> crit_sect_;
 152     Strings received_log_lines_ GUARDED_BY(crit_sect_);
 153     Strings expected_log_lines_ GUARDED_BY(crit_sect_);
 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]++;
 168       test_->send_config_.encoder_settings.encoder = &fake_encoder_;
 169       send_stream_ =
 170           test_->sender_call_->CreateVideoSendStream(test_->send_config_);
 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()));
 178       send_stream_->Start();
 179       frame_generator_capturer_->Start();
 180
 181       ExternalVideoDecoder decoder;
 182       decoder.decoder = &fake_decoder_;
 183       decoder.payload_type = test_->send_config_.encoder_settings.payload_type;
 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_->Start();
 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_->Stop();
 206         receive_stream_->Stop();
 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
 231 TEST_F(BitrateEstimatorTest, DISABLED_InstantiatesTOFPerDefault) {
 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
 242 TEST_F(BitrateEstimatorTest, DISABLED_ImmediatelySwitchToAST) {
 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
 256 TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToAST) {
 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
 275 TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOF) {
 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