1 /*
2 * Copyright 2018 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
11 #include "video/end_to_end_tests/multi_stream_tester.h"
12
13 #include <memory>
14 #include <utility>
15 #include <vector>
16
17 #include "absl/memory/memory.h"
18 #include "api/rtc_event_log/rtc_event_log.h"
19 #include "api/task_queue/default_task_queue_factory.h"
20 #include "api/task_queue/task_queue_base.h"
21 #include "api/test/create_frame_generator.h"
22 #include "api/test/simulated_network.h"
23 #include "api/test/video/function_video_encoder_factory.h"
24 #include "api/video/builtin_video_bitrate_allocator_factory.h"
25 #include "call/fake_network_pipe.h"
26 #include "call/simulated_network.h"
27 #include "media/engine/internal_decoder_factory.h"
28 #include "modules/video_coding/codecs/vp8/include/vp8.h"
29 #include "rtc_base/task_queue_for_test.h"
30 #include "test/call_test.h"
31 #include "test/encoder_settings.h"
32
33 namespace webrtc {
34
MultiStreamTester()35 MultiStreamTester::MultiStreamTester() {
36 // TODO(sprang): Cleanup when msvc supports explicit initializers for array.
37 codec_settings[0] = {1, 640, 480};
38 codec_settings[1] = {2, 320, 240};
39 codec_settings[2] = {3, 240, 160};
40 }
41
42 MultiStreamTester::~MultiStreamTester() = default;
43
RunTest()44 void MultiStreamTester::RunTest() {
45 webrtc::RtcEventLogNull event_log;
46 auto task_queue_factory = CreateDefaultTaskQueueFactory();
47 // Use high prioirity since this task_queue used for fake network delivering
48 // at correct time. Those test tasks should be prefered over code under test
49 // to make test more stable.
50 auto task_queue = task_queue_factory->CreateTaskQueue(
51 "TaskQueue", TaskQueueFactory::Priority::HIGH);
52 Call::Config config(&event_log);
53 FieldTrialBasedConfig field_trials;
54 config.trials = &field_trials;
55 config.task_queue_factory = task_queue_factory.get();
56 std::unique_ptr<Call> sender_call;
57 std::unique_ptr<Call> receiver_call;
58 std::unique_ptr<test::DirectTransport> sender_transport;
59 std::unique_ptr<test::DirectTransport> receiver_transport;
60
61 VideoSendStream* send_streams[kNumStreams];
62 VideoReceiveStream* receive_streams[kNumStreams];
63 test::FrameGeneratorCapturer* frame_generators[kNumStreams];
64 test::FunctionVideoEncoderFactory encoder_factory(
65 []() { return VP8Encoder::Create(); });
66 std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory =
67 CreateBuiltinVideoBitrateAllocatorFactory();
68 InternalDecoderFactory decoder_factory;
69
70 SendTask(RTC_FROM_HERE, task_queue.get(), [&]() {
71 sender_call = absl::WrapUnique(Call::Create(config));
72 receiver_call = absl::WrapUnique(Call::Create(config));
73 sender_transport = CreateSendTransport(task_queue.get(), sender_call.get());
74 receiver_transport =
75 CreateReceiveTransport(task_queue.get(), receiver_call.get());
76
77 sender_transport->SetReceiver(receiver_call->Receiver());
78 receiver_transport->SetReceiver(sender_call->Receiver());
79
80 for (size_t i = 0; i < kNumStreams; ++i) {
81 uint32_t ssrc = codec_settings[i].ssrc;
82 int width = codec_settings[i].width;
83 int height = codec_settings[i].height;
84
85 VideoSendStream::Config send_config(sender_transport.get());
86 send_config.rtp.ssrcs.push_back(ssrc);
87 send_config.encoder_settings.encoder_factory = &encoder_factory;
88 send_config.encoder_settings.bitrate_allocator_factory =
89 bitrate_allocator_factory.get();
90 send_config.rtp.payload_name = "VP8";
91 send_config.rtp.payload_type = kVideoPayloadType;
92 VideoEncoderConfig encoder_config;
93 test::FillEncoderConfiguration(kVideoCodecVP8, 1, &encoder_config);
94 encoder_config.max_bitrate_bps = 100000;
95
96 UpdateSendConfig(i, &send_config, &encoder_config, &frame_generators[i]);
97
98 send_streams[i] = sender_call->CreateVideoSendStream(
99 send_config.Copy(), encoder_config.Copy());
100 send_streams[i]->Start();
101
102 VideoReceiveStream::Config receive_config(receiver_transport.get());
103 receive_config.rtp.remote_ssrc = ssrc;
104 receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc;
105 VideoReceiveStream::Decoder decoder =
106 test::CreateMatchingDecoder(send_config);
107 decoder.decoder_factory = &decoder_factory;
108 receive_config.decoders.push_back(decoder);
109
110 UpdateReceiveConfig(i, &receive_config);
111
112 receive_streams[i] =
113 receiver_call->CreateVideoReceiveStream(std::move(receive_config));
114 receive_streams[i]->Start();
115
116 auto* frame_generator = new test::FrameGeneratorCapturer(
117 Clock::GetRealTimeClock(),
118 test::CreateSquareFrameGenerator(width, height, absl::nullopt,
119 absl::nullopt),
120 30, *task_queue_factory);
121 frame_generators[i] = frame_generator;
122 send_streams[i]->SetSource(frame_generator,
123 DegradationPreference::MAINTAIN_FRAMERATE);
124 frame_generator->Init();
125 frame_generator->Start();
126 }
127 });
128
129 Wait();
130
131 SendTask(RTC_FROM_HERE, task_queue.get(), [&]() {
132 for (size_t i = 0; i < kNumStreams; ++i) {
133 frame_generators[i]->Stop();
134 sender_call->DestroyVideoSendStream(send_streams[i]);
135 receiver_call->DestroyVideoReceiveStream(receive_streams[i]);
136 delete frame_generators[i];
137 }
138
139 sender_transport.reset();
140 receiver_transport.reset();
141
142 sender_call.reset();
143 receiver_call.reset();
144 });
145 }
146
UpdateSendConfig(size_t stream_index,VideoSendStream::Config * send_config,VideoEncoderConfig * encoder_config,test::FrameGeneratorCapturer ** frame_generator)147 void MultiStreamTester::UpdateSendConfig(
148 size_t stream_index,
149 VideoSendStream::Config* send_config,
150 VideoEncoderConfig* encoder_config,
151 test::FrameGeneratorCapturer** frame_generator) {}
152
UpdateReceiveConfig(size_t stream_index,VideoReceiveStream::Config * receive_config)153 void MultiStreamTester::UpdateReceiveConfig(
154 size_t stream_index,
155 VideoReceiveStream::Config* receive_config) {}
156
CreateSendTransport(TaskQueueBase * task_queue,Call * sender_call)157 std::unique_ptr<test::DirectTransport> MultiStreamTester::CreateSendTransport(
158 TaskQueueBase* task_queue,
159 Call* sender_call) {
160 return std::make_unique<test::DirectTransport>(
161 task_queue,
162 std::make_unique<FakeNetworkPipe>(
163 Clock::GetRealTimeClock(),
164 std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
165 sender_call, payload_type_map_);
166 }
167
168 std::unique_ptr<test::DirectTransport>
CreateReceiveTransport(TaskQueueBase * task_queue,Call * receiver_call)169 MultiStreamTester::CreateReceiveTransport(TaskQueueBase* task_queue,
170 Call* receiver_call) {
171 return std::make_unique<test::DirectTransport>(
172 task_queue,
173 std::make_unique<FakeNetworkPipe>(
174 Clock::GetRealTimeClock(),
175 std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
176 receiver_call, payload_type_map_);
177 }
178 } // namespace webrtc
179