xref: /external/chromium_org/third_party/webrtc/video/bitrate_estimator_tests.cc

/*
 *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */
#include <functional>
#include <list>
#include <string>

#include "testing/gtest/include/gtest/gtest.h"

#include "webrtc/call.h"
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
#include "webrtc/system_wrappers/interface/event_wrapper.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
#include "webrtc/system_wrappers/interface/thread_annotations.h"
#include "webrtc/system_wrappers/interface/trace.h"
#include "webrtc/test/direct_transport.h"
#include "webrtc/test/encoder_settings.h"
#include "webrtc/test/fake_decoder.h"
#include "webrtc/test/fake_encoder.h"
#include "webrtc/test/frame_generator_capturer.h"

namespace webrtc {

static const int kTOFExtensionId = 4;
static const int kASTExtensionId = 5;

static unsigned int kDefaultTimeoutMs = 30 * 1000;
static const uint32_t kSendSsrc = 0x654321;
static const uint32_t kReceiverLocalSsrc = 0x123456;
static const uint8_t kSendPayloadType = 125;

class BitrateEstimatorTest : public ::testing::Test {
 public:
  BitrateEstimatorTest()
      : receiver_trace_(),
        send_transport_(),
        receive_transport_(),
        sender_call_(),
        receiver_call_(),
        send_config_(),
        receive_config_(),
        streams_() {
  }

  virtual ~BitrateEstimatorTest() {
    EXPECT_TRUE(streams_.empty());
  }

  virtual void SetUp() {
    Trace::CreateTrace();
    Trace::SetTraceCallback(&receiver_trace_);
    // Reduce the chance that spurious traces will ruin the test.
    Trace::set_level_filter(kTraceTerseInfo);

    Call::Config receiver_call_config(&receive_transport_);
    receiver_call_.reset(Call::Create(receiver_call_config));

    Call::Config sender_call_config(&send_transport_);
    sender_call_.reset(Call::Create(sender_call_config));

    send_transport_.SetReceiver(receiver_call_->Receiver());
    receive_transport_.SetReceiver(sender_call_->Receiver());

    send_config_ = sender_call_->GetDefaultSendConfig();
    send_config_.rtp.ssrcs.push_back(kSendSsrc);
    // Encoders will be set separately per stream.
    send_config_.encoder_settings.encoder = NULL;
    send_config_.encoder_settings.payload_name = "FAKE";
    send_config_.encoder_settings.payload_type = kSendPayloadType;
    video_streams_ = test::CreateVideoStreams(1);

    receive_config_ = receiver_call_->GetDefaultReceiveConfig();
    assert(receive_config_.codecs.empty());
    VideoCodec codec =
        test::CreateDecoderVideoCodec(send_config_.encoder_settings);
    receive_config_.codecs.push_back(codec);
    // receive_config_.external_decoders will be set by every stream separately.
    receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
    receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;
    receive_config_.rtp.extensions.push_back(
        RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
    receive_config_.rtp.extensions.push_back(
        RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
  }

  virtual void TearDown() {
    std::for_each(streams_.begin(), streams_.end(),
        std::mem_fun(&Stream::StopSending));

    send_transport_.StopSending();
    receive_transport_.StopSending();

    while (!streams_.empty()) {
      delete streams_.back();
      streams_.pop_back();
    }

    receiver_call_.reset();

    Trace::SetTraceCallback(NULL);
    Trace::ReturnTrace();
  }

 protected:
  friend class Stream;

  class TraceObserver : public TraceCallback {
   public:
    TraceObserver()
        : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
          received_log_lines_(),
          expected_log_lines_(),
          done_(EventWrapper::Create()) {
    }

    void PushExpectedLogLine(const std::string& expected_log_line) {
      CriticalSectionScoped lock(crit_sect_.get());
      expected_log_lines_.push_back(expected_log_line);
    }

    virtual void Print(TraceLevel level,
                       const char* message,
                       int length) OVERRIDE {
      CriticalSectionScoped lock(crit_sect_.get());
      std::string msg(message);
      if (msg.find("BitrateEstimator") != std::string::npos) {
        received_log_lines_.push_back(msg);
      }
      int num_popped = 0;
      while (!received_log_lines_.empty() && !expected_log_lines_.empty()) {
        std::string a = received_log_lines_.front();
        std::string b = expected_log_lines_.front();
        received_log_lines_.pop_front();
        expected_log_lines_.pop_front();
        num_popped++;
        EXPECT_TRUE(a.find(b) != std::string::npos);
      }
      if (expected_log_lines_.size() <= 0) {
        if (num_popped > 0) {
          done_->Set();
        }
        return;
      }
    }

    EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); }

   private:
    typedef std::list<std::string> Strings;
    const scoped_ptr<CriticalSectionWrapper> crit_sect_;
    Strings received_log_lines_ GUARDED_BY(crit_sect_);
    Strings expected_log_lines_ GUARDED_BY(crit_sect_);
    scoped_ptr<EventWrapper> done_;
  };

  class Stream {
   public:
    explicit Stream(BitrateEstimatorTest* test)
        : test_(test),
          is_sending_receiving_(false),
          send_stream_(NULL),
          receive_stream_(NULL),
          frame_generator_capturer_(),
          fake_encoder_(Clock::GetRealTimeClock()),
          fake_decoder_() {
      test_->send_config_.rtp.ssrcs[0]++;
      test_->send_config_.encoder_settings.encoder = &fake_encoder_;
      send_stream_ = test_->sender_call_->CreateVideoSendStream(
          test_->send_config_, test_->video_streams_, NULL);
      assert(test_->video_streams_.size() == 1);
      frame_generator_capturer_.reset(
          test::FrameGeneratorCapturer::Create(send_stream_->Input(),
                                               test_->video_streams_[0].width,
                                               test_->video_streams_[0].height,
                                               30,
                                               Clock::GetRealTimeClock()));
      send_stream_->Start();
      frame_generator_capturer_->Start();

      ExternalVideoDecoder decoder;
      decoder.decoder = &fake_decoder_;
      decoder.payload_type = test_->send_config_.encoder_settings.payload_type;
      test_->receive_config_.rtp.remote_ssrc = test_->send_config_.rtp.ssrcs[0];
      test_->receive_config_.rtp.local_ssrc++;
      test_->receive_config_.external_decoders.push_back(decoder);
      receive_stream_ = test_->receiver_call_->CreateVideoReceiveStream(
          test_->receive_config_);
      receive_stream_->Start();

      is_sending_receiving_ = true;
    }

    ~Stream() {
      frame_generator_capturer_.reset(NULL);
      test_->sender_call_->DestroyVideoSendStream(send_stream_);
      send_stream_ = NULL;
      test_->receiver_call_->DestroyVideoReceiveStream(receive_stream_);
      receive_stream_ = NULL;
    }

    void StopSending() {
      if (is_sending_receiving_) {
        frame_generator_capturer_->Stop();
        send_stream_->Stop();
        receive_stream_->Stop();
        is_sending_receiving_ = false;
      }
    }

   private:
    BitrateEstimatorTest* test_;
    bool is_sending_receiving_;
    VideoSendStream* send_stream_;
    VideoReceiveStream* receive_stream_;
    scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
    test::FakeEncoder fake_encoder_;
    test::FakeDecoder fake_decoder_;
  };

  TraceObserver receiver_trace_;
  test::DirectTransport send_transport_;
  test::DirectTransport receive_transport_;
  scoped_ptr<Call> sender_call_;
  scoped_ptr<Call> receiver_call_;
  VideoSendStream::Config send_config_;
  std::vector<VideoStream> video_streams_;
  VideoReceiveStream::Config receive_config_;
  std::vector<Stream*> streams_;
};

TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefault) {
  send_config_.rtp.extensions.push_back(
      RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
  receiver_trace_.PushExpectedLogLine(
      "RemoteBitrateEstimatorFactory: Instantiating.");
  receiver_trace_.PushExpectedLogLine(
      "RemoteBitrateEstimatorFactory: Instantiating.");
  streams_.push_back(new Stream(this));
  EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
}

TEST_F(BitrateEstimatorTest, ImmediatelySwitchToAST) {
  send_config_.rtp.extensions.push_back(
      RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
  receiver_trace_.PushExpectedLogLine(
      "RemoteBitrateEstimatorFactory: Instantiating.");
  receiver_trace_.PushExpectedLogLine(
      "RemoteBitrateEstimatorFactory: Instantiating.");
  receiver_trace_.PushExpectedLogLine("Switching to absolute send time RBE.");
  receiver_trace_.PushExpectedLogLine(
      "AbsoluteSendTimeRemoteBitrateEstimatorFactory: Instantiating.");
  streams_.push_back(new Stream(this));
  EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
}

TEST_F(BitrateEstimatorTest, SwitchesToAST) {
  send_config_.rtp.extensions.push_back(
      RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
  receiver_trace_.PushExpectedLogLine(
      "RemoteBitrateEstimatorFactory: Instantiating.");
  receiver_trace_.PushExpectedLogLine(
      "RemoteBitrateEstimatorFactory: Instantiating.");
  streams_.push_back(new Stream(this));
  EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());

  send_config_.rtp.extensions[0] =
      RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId);
  receiver_trace_.PushExpectedLogLine("Switching to absolute send time RBE.");
  receiver_trace_.PushExpectedLogLine(
      "AbsoluteSendTimeRemoteBitrateEstimatorFactory: Instantiating.");
  streams_.push_back(new Stream(this));
  EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
}

TEST_F(BitrateEstimatorTest, SwitchesToASTThenBackToTOF) {
  send_config_.rtp.extensions.push_back(
      RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
  receiver_trace_.PushExpectedLogLine(
      "RemoteBitrateEstimatorFactory: Instantiating.");
  receiver_trace_.PushExpectedLogLine(
      "RemoteBitrateEstimatorFactory: Instantiating.");
  streams_.push_back(new Stream(this));
  EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());

  send_config_.rtp.extensions[0] =
      RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId);
  receiver_trace_.PushExpectedLogLine("Switching to absolute send time RBE.");
  receiver_trace_.PushExpectedLogLine(
      "AbsoluteSendTimeRemoteBitrateEstimatorFactory: Instantiating.");
  streams_.push_back(new Stream(this));
  EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());

  send_config_.rtp.extensions[0] =
      RtpExtension(RtpExtension::kTOffset, kTOFExtensionId);
  receiver_trace_.PushExpectedLogLine(
      "WrappingBitrateEstimator: Switching to transmission time offset RBE.");
  receiver_trace_.PushExpectedLogLine(
      "RemoteBitrateEstimatorFactory: Instantiating.");
  streams_.push_back(new Stream(this));
  streams_[0]->StopSending();
  streams_[1]->StopSending();
  EXPECT_EQ(kEventSignaled, receiver_trace_.Wait());
}
}  // namespace webrtc