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/base/checks.h"
11#include "webrtc/common.h"
12#include "webrtc/config.h"
13#include "webrtc/test/call_test.h"
14#include "webrtc/test/encoder_settings.h"
15#include "webrtc/test/testsupport/fileutils.h"
16#include "webrtc/voice_engine/include/voe_base.h"
17#include "webrtc/voice_engine/include/voe_codec.h"
18#include "webrtc/voice_engine/include/voe_network.h"
19
20namespace webrtc {
21namespace test {
22
23namespace {
24const int kVideoRotationRtpExtensionId = 4;
25}
26
27CallTest::CallTest()
28    : clock_(Clock::GetRealTimeClock()),
29      video_send_config_(nullptr),
30      video_send_stream_(nullptr),
31      audio_send_config_(nullptr),
32      audio_send_stream_(nullptr),
33      fake_encoder_(clock_),
34      num_video_streams_(1),
35      num_audio_streams_(0),
36      fake_send_audio_device_(nullptr),
37      fake_recv_audio_device_(nullptr) {}
38
39CallTest::~CallTest() {
40}
41
42void CallTest::RunBaseTest(BaseTest* test) {
43  num_video_streams_ = test->GetNumVideoStreams();
44  num_audio_streams_ = test->GetNumAudioStreams();
45  RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0);
46  Call::Config send_config(test->GetSenderCallConfig());
47  if (num_audio_streams_ > 0) {
48    CreateVoiceEngines();
49    AudioState::Config audio_state_config;
50    audio_state_config.voice_engine = voe_send_.voice_engine;
51    send_config.audio_state = AudioState::Create(audio_state_config);
52  }
53  CreateSenderCall(send_config);
54  if (test->ShouldCreateReceivers()) {
55    Call::Config recv_config(test->GetReceiverCallConfig());
56    if (num_audio_streams_ > 0) {
57      AudioState::Config audio_state_config;
58      audio_state_config.voice_engine = voe_recv_.voice_engine;
59      recv_config.audio_state = AudioState::Create(audio_state_config);
60    }
61    CreateReceiverCall(recv_config);
62  }
63  test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
64  send_transport_.reset(test->CreateSendTransport(sender_call_.get()));
65  receive_transport_.reset(test->CreateReceiveTransport());
66
67  if (test->ShouldCreateReceivers()) {
68    send_transport_->SetReceiver(receiver_call_->Receiver());
69    receive_transport_->SetReceiver(sender_call_->Receiver());
70  } else {
71    // Sender-only call delivers to itself.
72    send_transport_->SetReceiver(sender_call_->Receiver());
73    receive_transport_->SetReceiver(nullptr);
74  }
75
76  CreateSendConfig(num_video_streams_, num_audio_streams_,
77                   send_transport_.get());
78  if (test->ShouldCreateReceivers()) {
79    CreateMatchingReceiveConfigs(receive_transport_.get());
80  }
81  if (num_audio_streams_ > 0)
82    SetupVoiceEngineTransports(send_transport_.get(), receive_transport_.get());
83
84  if (num_video_streams_ > 0) {
85    test->ModifyVideoConfigs(&video_send_config_, &video_receive_configs_,
86                             &video_encoder_config_);
87  }
88  if (num_audio_streams_ > 0)
89    test->ModifyAudioConfigs(&audio_send_config_, &audio_receive_configs_);
90
91  if (num_video_streams_ > 0) {
92    CreateVideoStreams();
93    test->OnVideoStreamsCreated(video_send_stream_, video_receive_streams_);
94  }
95  if (num_audio_streams_ > 0) {
96    CreateAudioStreams();
97    test->OnAudioStreamsCreated(audio_send_stream_, audio_receive_streams_);
98  }
99
100  if (num_video_streams_ > 0) {
101    CreateFrameGeneratorCapturer();
102    test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get());
103  }
104
105  Start();
106  test->PerformTest();
107  send_transport_->StopSending();
108  receive_transport_->StopSending();
109  Stop();
110
111  DestroyStreams();
112  DestroyCalls();
113  if (num_audio_streams_ > 0)
114    DestroyVoiceEngines();
115}
116
117void CallTest::Start() {
118  if (video_send_stream_)
119    video_send_stream_->Start();
120  for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
121    video_recv_stream->Start();
122  if (audio_send_stream_) {
123    fake_send_audio_device_->Start();
124    audio_send_stream_->Start();
125    EXPECT_EQ(0, voe_send_.base->StartSend(voe_send_.channel_id));
126  }
127  for (AudioReceiveStream* audio_recv_stream : audio_receive_streams_)
128    audio_recv_stream->Start();
129  if (!audio_receive_streams_.empty()) {
130    fake_recv_audio_device_->Start();
131    EXPECT_EQ(0, voe_recv_.base->StartPlayout(voe_recv_.channel_id));
132    EXPECT_EQ(0, voe_recv_.base->StartReceive(voe_recv_.channel_id));
133  }
134  if (frame_generator_capturer_.get() != NULL)
135    frame_generator_capturer_->Start();
136}
137
138void CallTest::Stop() {
139  if (frame_generator_capturer_.get() != NULL)
140    frame_generator_capturer_->Stop();
141  if (!audio_receive_streams_.empty()) {
142    fake_recv_audio_device_->Stop();
143    EXPECT_EQ(0, voe_recv_.base->StopReceive(voe_recv_.channel_id));
144    EXPECT_EQ(0, voe_recv_.base->StopPlayout(voe_recv_.channel_id));
145  }
146  for (AudioReceiveStream* audio_recv_stream : audio_receive_streams_)
147    audio_recv_stream->Stop();
148  if (audio_send_stream_) {
149    fake_send_audio_device_->Stop();
150    EXPECT_EQ(0, voe_send_.base->StopSend(voe_send_.channel_id));
151    audio_send_stream_->Stop();
152  }
153  for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
154    video_recv_stream->Stop();
155  if (video_send_stream_)
156    video_send_stream_->Stop();
157}
158
159void CallTest::CreateCalls(const Call::Config& sender_config,
160                           const Call::Config& receiver_config) {
161  CreateSenderCall(sender_config);
162  CreateReceiverCall(receiver_config);
163}
164
165void CallTest::CreateSenderCall(const Call::Config& config) {
166  sender_call_.reset(Call::Create(config));
167}
168
169void CallTest::CreateReceiverCall(const Call::Config& config) {
170  receiver_call_.reset(Call::Create(config));
171}
172
173void CallTest::DestroyCalls() {
174  sender_call_.reset();
175  receiver_call_.reset();
176}
177
178void CallTest::CreateSendConfig(size_t num_video_streams,
179                                size_t num_audio_streams,
180                                Transport* send_transport) {
181  RTC_DCHECK(num_video_streams <= kNumSsrcs);
182  RTC_DCHECK_LE(num_audio_streams, 1u);
183  RTC_DCHECK(num_audio_streams == 0 || voe_send_.channel_id >= 0);
184  if (num_video_streams > 0) {
185    video_send_config_ = VideoSendStream::Config(send_transport);
186    video_send_config_.encoder_settings.encoder = &fake_encoder_;
187    video_send_config_.encoder_settings.payload_name = "FAKE";
188    video_send_config_.encoder_settings.payload_type =
189        kFakeVideoSendPayloadType;
190    video_send_config_.rtp.extensions.push_back(
191        RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
192    video_encoder_config_.streams = test::CreateVideoStreams(num_video_streams);
193    for (size_t i = 0; i < num_video_streams; ++i)
194      video_send_config_.rtp.ssrcs.push_back(kVideoSendSsrcs[i]);
195    video_send_config_.rtp.extensions.push_back(RtpExtension(
196        RtpExtension::kVideoRotation, kVideoRotationRtpExtensionId));
197  }
198
199  if (num_audio_streams > 0) {
200    audio_send_config_ = AudioSendStream::Config(send_transport);
201    audio_send_config_.voe_channel_id = voe_send_.channel_id;
202    audio_send_config_.rtp.ssrc = kAudioSendSsrc;
203  }
204}
205
206void CallTest::CreateMatchingReceiveConfigs(Transport* rtcp_send_transport) {
207  RTC_DCHECK(video_receive_configs_.empty());
208  RTC_DCHECK(allocated_decoders_.empty());
209  if (num_video_streams_ > 0) {
210    RTC_DCHECK(!video_send_config_.rtp.ssrcs.empty());
211    VideoReceiveStream::Config video_config(rtcp_send_transport);
212    video_config.rtp.remb = true;
213    video_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
214    for (const RtpExtension& extension : video_send_config_.rtp.extensions)
215      video_config.rtp.extensions.push_back(extension);
216    for (size_t i = 0; i < video_send_config_.rtp.ssrcs.size(); ++i) {
217      VideoReceiveStream::Decoder decoder =
218          test::CreateMatchingDecoder(video_send_config_.encoder_settings);
219      allocated_decoders_.push_back(decoder.decoder);
220      video_config.decoders.clear();
221      video_config.decoders.push_back(decoder);
222      video_config.rtp.remote_ssrc = video_send_config_.rtp.ssrcs[i];
223      video_receive_configs_.push_back(video_config);
224    }
225  }
226
227  RTC_DCHECK(num_audio_streams_ <= 1);
228  if (num_audio_streams_ == 1) {
229    RTC_DCHECK(voe_send_.channel_id >= 0);
230    AudioReceiveStream::Config audio_config;
231    audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
232    audio_config.rtcp_send_transport = rtcp_send_transport;
233    audio_config.voe_channel_id = voe_recv_.channel_id;
234    audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc;
235    audio_receive_configs_.push_back(audio_config);
236  }
237}
238
239void CallTest::CreateFrameGeneratorCapturer() {
240  VideoStream stream = video_encoder_config_.streams.back();
241  frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
242      video_send_stream_->Input(), stream.width, stream.height,
243      stream.max_framerate, clock_));
244}
245
246void CallTest::CreateFakeAudioDevices() {
247  fake_send_audio_device_.reset(new FakeAudioDevice(
248      clock_, test::ResourcePath("voice_engine/audio_long16", "pcm")));
249  fake_recv_audio_device_.reset(new FakeAudioDevice(
250      clock_, test::ResourcePath("voice_engine/audio_long16", "pcm")));
251}
252
253void CallTest::CreateVideoStreams() {
254  RTC_DCHECK(video_send_stream_ == nullptr);
255  RTC_DCHECK(video_receive_streams_.empty());
256  RTC_DCHECK(audio_send_stream_ == nullptr);
257  RTC_DCHECK(audio_receive_streams_.empty());
258
259  video_send_stream_ = sender_call_->CreateVideoSendStream(
260      video_send_config_, video_encoder_config_);
261  for (size_t i = 0; i < video_receive_configs_.size(); ++i) {
262    video_receive_streams_.push_back(
263        receiver_call_->CreateVideoReceiveStream(video_receive_configs_[i]));
264  }
265}
266
267void CallTest::CreateAudioStreams() {
268  audio_send_stream_ = sender_call_->CreateAudioSendStream(audio_send_config_);
269  for (size_t i = 0; i < audio_receive_configs_.size(); ++i) {
270    audio_receive_streams_.push_back(
271        receiver_call_->CreateAudioReceiveStream(audio_receive_configs_[i]));
272  }
273  CodecInst isac = {kAudioSendPayloadType, "ISAC", 16000, 480, 1, 32000};
274  EXPECT_EQ(0, voe_send_.codec->SetSendCodec(voe_send_.channel_id, isac));
275}
276
277void CallTest::DestroyStreams() {
278  if (video_send_stream_)
279    sender_call_->DestroyVideoSendStream(video_send_stream_);
280  video_send_stream_ = nullptr;
281  for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
282    receiver_call_->DestroyVideoReceiveStream(video_recv_stream);
283
284  if (audio_send_stream_)
285    sender_call_->DestroyAudioSendStream(audio_send_stream_);
286  audio_send_stream_ = nullptr;
287  for (AudioReceiveStream* audio_recv_stream : audio_receive_streams_)
288    receiver_call_->DestroyAudioReceiveStream(audio_recv_stream);
289  video_receive_streams_.clear();
290
291  allocated_decoders_.clear();
292}
293
294void CallTest::CreateVoiceEngines() {
295  CreateFakeAudioDevices();
296  voe_send_.voice_engine = VoiceEngine::Create();
297  voe_send_.base = VoEBase::GetInterface(voe_send_.voice_engine);
298  voe_send_.network = VoENetwork::GetInterface(voe_send_.voice_engine);
299  voe_send_.codec = VoECodec::GetInterface(voe_send_.voice_engine);
300  EXPECT_EQ(0, voe_send_.base->Init(fake_send_audio_device_.get(), nullptr));
301  Config voe_config;
302  voe_config.Set<VoicePacing>(new VoicePacing(true));
303  voe_send_.channel_id = voe_send_.base->CreateChannel(voe_config);
304  EXPECT_GE(voe_send_.channel_id, 0);
305
306  voe_recv_.voice_engine = VoiceEngine::Create();
307  voe_recv_.base = VoEBase::GetInterface(voe_recv_.voice_engine);
308  voe_recv_.network = VoENetwork::GetInterface(voe_recv_.voice_engine);
309  voe_recv_.codec = VoECodec::GetInterface(voe_recv_.voice_engine);
310  EXPECT_EQ(0, voe_recv_.base->Init(fake_recv_audio_device_.get(), nullptr));
311  voe_recv_.channel_id = voe_recv_.base->CreateChannel();
312  EXPECT_GE(voe_recv_.channel_id, 0);
313}
314
315void CallTest::SetupVoiceEngineTransports(PacketTransport* send_transport,
316                                          PacketTransport* recv_transport) {
317  voe_send_.transport_adapter.reset(
318      new internal::TransportAdapter(send_transport));
319  voe_send_.transport_adapter->Enable();
320  EXPECT_EQ(0, voe_send_.network->RegisterExternalTransport(
321                   voe_send_.channel_id, *voe_send_.transport_adapter.get()));
322
323  voe_recv_.transport_adapter.reset(
324      new internal::TransportAdapter(recv_transport));
325  voe_recv_.transport_adapter->Enable();
326  EXPECT_EQ(0, voe_recv_.network->RegisterExternalTransport(
327                   voe_recv_.channel_id, *voe_recv_.transport_adapter.get()));
328}
329
330void CallTest::DestroyVoiceEngines() {
331  voe_recv_.base->DeleteChannel(voe_recv_.channel_id);
332  voe_recv_.channel_id = -1;
333  voe_recv_.base->Release();
334  voe_recv_.base = nullptr;
335  voe_recv_.network->Release();
336  voe_recv_.network = nullptr;
337  voe_recv_.codec->Release();
338  voe_recv_.codec = nullptr;
339
340  voe_send_.base->DeleteChannel(voe_send_.channel_id);
341  voe_send_.channel_id = -1;
342  voe_send_.base->Release();
343  voe_send_.base = nullptr;
344  voe_send_.network->Release();
345  voe_send_.network = nullptr;
346  voe_send_.codec->Release();
347  voe_send_.codec = nullptr;
348
349  VoiceEngine::Delete(voe_send_.voice_engine);
350  voe_send_.voice_engine = nullptr;
351  VoiceEngine::Delete(voe_recv_.voice_engine);
352  voe_recv_.voice_engine = nullptr;
353}
354
355const int CallTest::kDefaultTimeoutMs = 30 * 1000;
356const int CallTest::kLongTimeoutMs = 120 * 1000;
357const uint8_t CallTest::kVideoSendPayloadType = 100;
358const uint8_t CallTest::kFakeVideoSendPayloadType = 125;
359const uint8_t CallTest::kSendRtxPayloadType = 98;
360const uint8_t CallTest::kRedPayloadType = 118;
361const uint8_t CallTest::kRtxRedPayloadType = 99;
362const uint8_t CallTest::kUlpfecPayloadType = 119;
363const uint8_t CallTest::kAudioSendPayloadType = 103;
364const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE,
365                                                     0xBADCAFF};
366const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE,
367                                                       0xC0FFEF};
368const uint32_t CallTest::kAudioSendSsrc = 0xDEADBEEF;
369const uint32_t CallTest::kReceiverLocalVideoSsrc = 0x123456;
370const uint32_t CallTest::kReceiverLocalAudioSsrc = 0x1234567;
371const int CallTest::kNackRtpHistoryMs = 1000;
372
373BaseTest::BaseTest(unsigned int timeout_ms) : RtpRtcpObserver(timeout_ms) {
374}
375
376BaseTest::~BaseTest() {
377}
378
379Call::Config BaseTest::GetSenderCallConfig() {
380  return Call::Config();
381}
382
383Call::Config BaseTest::GetReceiverCallConfig() {
384  return Call::Config();
385}
386
387void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {
388}
389
390test::PacketTransport* BaseTest::CreateSendTransport(Call* sender_call) {
391  return new PacketTransport(sender_call, this, test::PacketTransport::kSender,
392                             FakeNetworkPipe::Config());
393}
394
395test::PacketTransport* BaseTest::CreateReceiveTransport() {
396  return new PacketTransport(nullptr, this, test::PacketTransport::kReceiver,
397                             FakeNetworkPipe::Config());
398}
399
400size_t BaseTest::GetNumVideoStreams() const {
401  return 1;
402}
403
404size_t BaseTest::GetNumAudioStreams() const {
405  return 0;
406}
407
408void BaseTest::ModifyVideoConfigs(
409    VideoSendStream::Config* send_config,
410    std::vector<VideoReceiveStream::Config>* receive_configs,
411    VideoEncoderConfig* encoder_config) {}
412
413void BaseTest::OnVideoStreamsCreated(
414    VideoSendStream* send_stream,
415    const std::vector<VideoReceiveStream*>& receive_streams) {}
416
417void BaseTest::ModifyAudioConfigs(
418    AudioSendStream::Config* send_config,
419    std::vector<AudioReceiveStream::Config>* receive_configs) {}
420
421void BaseTest::OnAudioStreamsCreated(
422    AudioSendStream* send_stream,
423    const std::vector<AudioReceiveStream*>& receive_streams) {}
424
425void BaseTest::OnFrameGeneratorCapturerCreated(
426    FrameGeneratorCapturer* frame_generator_capturer) {
427}
428
429SendTest::SendTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
430}
431
432bool SendTest::ShouldCreateReceivers() const {
433  return false;
434}
435
436EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
437}
438
439bool EndToEndTest::ShouldCreateReceivers() const {
440  return true;
441}
442
443}  // namespace test
444}  // namespace webrtc
445