src/third_party/webrtc/test/call_test.cc

   1 /*
   2  *  Copyright (c) 2014 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 "webrtc/test/call_test.h"
  11
  12 #include "webrtc/test/encoder_settings.h"
  13
  14 namespace webrtc {
  15 namespace test {
  16
  17 CallTest::CallTest()
  18     : clock_(Clock::GetRealTimeClock()),
  19       send_stream_(NULL),
  20       fake_encoder_(clock_) {
  21 }
  22
  23 CallTest::~CallTest() {
  24 }
  25
  26 void CallTest::RunBaseTest(BaseTest* test) {
  27   CreateSenderCall(test->GetSenderCallConfig());
  28   if (test->ShouldCreateReceivers())
  29     CreateReceiverCall(test->GetReceiverCallConfig());
  30   test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
  31
  32   if (test->ShouldCreateReceivers()) {
  33     test->SetReceivers(receiver_call_->Receiver(), sender_call_->Receiver());
  34   } else {
  35     // Sender-only call delivers to itself.
  36     test->SetReceivers(sender_call_->Receiver(), NULL);
  37   }
  38
  39   CreateSendConfig(test->GetNumStreams());
  40   if (test->ShouldCreateReceivers()) {
  41     CreateMatchingReceiveConfigs();
  42   }
  43   test->ModifyConfigs(&send_config_, &receive_configs_, &encoder_config_);
  44   CreateStreams();
  45   test->OnStreamsCreated(send_stream_, receive_streams_);
  46
  47   CreateFrameGeneratorCapturer();
  48   test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get());
  49
  50   Start();
  51   test->PerformTest();
  52   test->StopSending();
  53   Stop();
  54
  55   DestroyStreams();
  56 }
  57
  58 void CallTest::Start() {
  59   send_stream_->Start();
  60   for (size_t i = 0; i < receive_streams_.size(); ++i)
  61     receive_streams_[i]->Start();
  62   if (frame_generator_capturer_.get() != NULL)
  63     frame_generator_capturer_->Start();
  64 }
  65
  66 void CallTest::Stop() {
  67   if (frame_generator_capturer_.get() != NULL)
  68     frame_generator_capturer_->Stop();
  69   for (size_t i = 0; i < receive_streams_.size(); ++i)
  70     receive_streams_[i]->Stop();
  71   send_stream_->Stop();
  72 }
  73
  74 void CallTest::CreateCalls(const Call::Config& sender_config,
  75                            const Call::Config& receiver_config) {
  76   CreateSenderCall(sender_config);
  77   CreateReceiverCall(receiver_config);
  78 }
  79
  80 void CallTest::CreateSenderCall(const Call::Config& config) {
  81   sender_call_.reset(Call::Create(config));
  82 }
  83
  84 void CallTest::CreateReceiverCall(const Call::Config& config) {
  85   receiver_call_.reset(Call::Create(config));
  86 }
  87
  88 void CallTest::CreateSendConfig(size_t num_streams) {
  89   assert(num_streams <= kNumSsrcs);
  90   send_config_ = VideoSendStream::Config();
  91   send_config_.encoder_settings.encoder = &fake_encoder_;
  92   send_config_.encoder_settings.payload_name = "FAKE";
  93   send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
  94   encoder_config_.streams = test::CreateVideoStreams(num_streams);
  95   for (size_t i = 0; i < num_streams; ++i)
  96     send_config_.rtp.ssrcs.push_back(kSendSsrcs[i]);
  97 }
  98
  99 void CallTest::CreateMatchingReceiveConfigs() {
 100   assert(!send_config_.rtp.ssrcs.empty());
 101   assert(receive_configs_.empty());
 102   assert(allocated_decoders_.empty());
 103   VideoReceiveStream::Config config;
 104   config.rtp.local_ssrc = kReceiverLocalSsrc;
 105   for (size_t i = 0; i < send_config_.rtp.ssrcs.size(); ++i) {
 106     VideoReceiveStream::Decoder decoder =
 107         test::CreateMatchingDecoder(send_config_.encoder_settings);
 108     allocated_decoders_.push_back(decoder.decoder);
 109     config.decoders.clear();
 110     config.decoders.push_back(decoder);
 111     config.rtp.remote_ssrc = send_config_.rtp.ssrcs[i];
 112     receive_configs_.push_back(config);
 113   }
 114 }
 115
 116 void CallTest::CreateFrameGeneratorCapturer() {
 117   VideoStream stream = encoder_config_.streams.back();
 118   frame_generator_capturer_.reset(
 119       test::FrameGeneratorCapturer::Create(send_stream_->Input(),
 120                                            stream.width,
 121                                            stream.height,
 122                                            stream.max_framerate,
 123                                            clock_));
 124 }
 125 void CallTest::CreateStreams() {
 126   assert(send_stream_ == NULL);
 127   assert(receive_streams_.empty());
 128
 129   send_stream_ =
 130       sender_call_->CreateVideoSendStream(send_config_, encoder_config_);
 131
 132   for (size_t i = 0; i < receive_configs_.size(); ++i) {
 133     receive_streams_.push_back(
 134         receiver_call_->CreateVideoReceiveStream(receive_configs_[i]));
 135   }
 136 }
 137
 138 void CallTest::DestroyStreams() {
 139   if (send_stream_ != NULL)
 140     sender_call_->DestroyVideoSendStream(send_stream_);
 141   send_stream_ = NULL;
 142   for (size_t i = 0; i < receive_streams_.size(); ++i)
 143     receiver_call_->DestroyVideoReceiveStream(receive_streams_[i]);
 144   receive_streams_.clear();
 145   allocated_decoders_.clear();
 146 }
 147
 148 const unsigned int CallTest::kDefaultTimeoutMs = 30 * 1000;
 149 const unsigned int CallTest::kLongTimeoutMs = 120 * 1000;
 150 const uint8_t CallTest::kSendPayloadType = 100;
 151 const uint8_t CallTest::kFakeSendPayloadType = 125;
 152 const uint8_t CallTest::kSendRtxPayloadType = 98;
 153 const uint8_t CallTest::kRedPayloadType = 118;
 154 const uint8_t CallTest::kUlpfecPayloadType = 119;
 155 const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE,
 156                                                      0xBADCAFF};
 157 const uint32_t CallTest::kSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE, 0xC0FFEF};
 158 const uint32_t CallTest::kReceiverLocalSsrc = 0x123456;
 159 const int CallTest::kNackRtpHistoryMs = 1000;
 160
 161 BaseTest::BaseTest(unsigned int timeout_ms) : RtpRtcpObserver(timeout_ms) {
 162 }
 163
 164 BaseTest::BaseTest(unsigned int timeout_ms,
 165                    const FakeNetworkPipe::Config& config)
 166     : RtpRtcpObserver(timeout_ms, config) {
 167 }
 168
 169 BaseTest::~BaseTest() {
 170 }
 171
 172 Call::Config BaseTest::GetSenderCallConfig() {
 173   return Call::Config(SendTransport());
 174 }
 175
 176 Call::Config BaseTest::GetReceiverCallConfig() {
 177   return Call::Config(ReceiveTransport());
 178 }
 179
 180 void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {
 181 }
 182
 183 size_t BaseTest::GetNumStreams() const {
 184   return 1;
 185 }
 186
 187 void BaseTest::ModifyConfigs(
 188     VideoSendStream::Config* send_config,
 189     std::vector<VideoReceiveStream::Config>* receive_configs,
 190     VideoEncoderConfig* encoder_config) {
 191 }
 192
 193 void BaseTest::OnStreamsCreated(
 194     VideoSendStream* send_stream,
 195     const std::vector<VideoReceiveStream*>& receive_streams) {
 196 }
 197
 198 void BaseTest::OnFrameGeneratorCapturerCreated(
 199     FrameGeneratorCapturer* frame_generator_capturer) {
 200 }
 201
 202 SendTest::SendTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
 203 }
 204
 205 SendTest::SendTest(unsigned int timeout_ms,
 206                    const FakeNetworkPipe::Config& config)
 207     : BaseTest(timeout_ms, config) {
 208 }
 209
 210 bool SendTest::ShouldCreateReceivers() const {
 211   return false;
 212 }
 213
 214 EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
 215 }
 216
 217 EndToEndTest::EndToEndTest(unsigned int timeout_ms,
 218                            const FakeNetworkPipe::Config& config)
 219     : BaseTest(timeout_ms, config) {
 220 }
 221
 222 bool EndToEndTest::ShouldCreateReceivers() const {
 223   return true;
 224 }
 225
 226 }  // namespace test
 227 }  // namespace webrtc