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