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 <memory>
12
13 #include "api/test/create_frame_generator.h"
14 #include "api/test/frame_generator_interface.h"
15 #include "api/test/simulated_network.h"
16 #include "call/fake_network_pipe.h"
17 #include "call/simulated_network.h"
18 #include "rtc_base/task_queue_for_test.h"
19 #include "system_wrappers/include/sleep.h"
20 #include "test/call_test.h"
21 #include "test/field_trial.h"
22 #include "test/frame_forwarder.h"
23 #include "test/gtest.h"
24 #include "test/null_transport.h"
25
26 namespace webrtc {
27
28 class CallOperationEndToEndTest : public test::CallTest {};
29
TEST_F(CallOperationEndToEndTest,ReceiverCanBeStartedTwice)30 TEST_F(CallOperationEndToEndTest, ReceiverCanBeStartedTwice) {
31 CreateCalls();
32
33 test::NullTransport transport;
34 CreateSendConfig(1, 0, 0, &transport);
35 CreateMatchingReceiveConfigs(&transport);
36
37 CreateVideoStreams();
38
39 video_receive_streams_[0]->Start();
40 video_receive_streams_[0]->Start();
41
42 DestroyStreams();
43 }
44
TEST_F(CallOperationEndToEndTest,ReceiverCanBeStoppedTwice)45 TEST_F(CallOperationEndToEndTest, ReceiverCanBeStoppedTwice) {
46 CreateCalls();
47
48 test::NullTransport transport;
49 CreateSendConfig(1, 0, 0, &transport);
50 CreateMatchingReceiveConfigs(&transport);
51
52 CreateVideoStreams();
53
54 video_receive_streams_[0]->Stop();
55 video_receive_streams_[0]->Stop();
56
57 DestroyStreams();
58 }
59
TEST_F(CallOperationEndToEndTest,ReceiverCanBeStoppedAndRestarted)60 TEST_F(CallOperationEndToEndTest, ReceiverCanBeStoppedAndRestarted) {
61 CreateCalls();
62
63 test::NullTransport transport;
64 CreateSendConfig(1, 0, 0, &transport);
65 CreateMatchingReceiveConfigs(&transport);
66
67 CreateVideoStreams();
68
69 video_receive_streams_[0]->Stop();
70 video_receive_streams_[0]->Start();
71 video_receive_streams_[0]->Stop();
72
73 DestroyStreams();
74 }
75
TEST_F(CallOperationEndToEndTest,RendersSingleDelayedFrame)76 TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
77 static const int kWidth = 320;
78 static const int kHeight = 240;
79 // This constant is chosen to be higher than the timeout in the video_render
80 // module. This makes sure that frames aren't dropped if there are no other
81 // frames in the queue.
82 static const int kRenderDelayMs = 1000;
83
84 class Renderer : public rtc::VideoSinkInterface<VideoFrame> {
85 public:
86 void OnFrame(const VideoFrame& video_frame) override {
87 SleepMs(kRenderDelayMs);
88 event_.Set();
89 }
90
91 bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
92
93 rtc::Event event_;
94 } renderer;
95
96 test::FrameForwarder frame_forwarder;
97 std::unique_ptr<test::DirectTransport> sender_transport;
98 std::unique_ptr<test::DirectTransport> receiver_transport;
99
100 SendTask(
101 RTC_FROM_HERE, task_queue(),
102 [this, &renderer, &frame_forwarder, &sender_transport,
103 &receiver_transport]() {
104 CreateCalls();
105
106 sender_transport = std::make_unique<test::DirectTransport>(
107 task_queue(),
108 std::make_unique<FakeNetworkPipe>(
109 Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
110 BuiltInNetworkBehaviorConfig())),
111 sender_call_.get(), payload_type_map_);
112 receiver_transport = std::make_unique<test::DirectTransport>(
113 task_queue(),
114 std::make_unique<FakeNetworkPipe>(
115 Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
116 BuiltInNetworkBehaviorConfig())),
117 receiver_call_.get(), payload_type_map_);
118 sender_transport->SetReceiver(receiver_call_->Receiver());
119 receiver_transport->SetReceiver(sender_call_->Receiver());
120
121 CreateSendConfig(1, 0, 0, sender_transport.get());
122 CreateMatchingReceiveConfigs(receiver_transport.get());
123
124 video_receive_configs_[0].renderer = &renderer;
125
126 CreateVideoStreams();
127 Start();
128
129 // Create frames that are smaller than the send width/height, this is
130 // done to check that the callbacks are done after processing video.
131 std::unique_ptr<test::FrameGeneratorInterface> frame_generator(
132 test::CreateSquareFrameGenerator(kWidth, kHeight, absl::nullopt,
133 absl::nullopt));
134 GetVideoSendStream()->SetSource(
135 &frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE);
136
137 test::FrameGeneratorInterface::VideoFrameData frame_data =
138 frame_generator->NextFrame();
139 VideoFrame frame = VideoFrame::Builder()
140 .set_video_frame_buffer(frame_data.buffer)
141 .set_update_rect(frame_data.update_rect)
142 .build();
143 frame_forwarder.IncomingCapturedFrame(frame);
144 });
145
146 EXPECT_TRUE(renderer.Wait())
147 << "Timed out while waiting for the frame to render.";
148
149 SendTask(RTC_FROM_HERE, task_queue(),
150 [this, &sender_transport, &receiver_transport]() {
151 Stop();
152 DestroyStreams();
153 sender_transport.reset();
154 receiver_transport.reset();
155 DestroyCalls();
156 });
157 }
158
TEST_F(CallOperationEndToEndTest,TransmitsFirstFrame)159 TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
160 class Renderer : public rtc::VideoSinkInterface<VideoFrame> {
161 public:
162 void OnFrame(const VideoFrame& video_frame) override { event_.Set(); }
163
164 bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
165
166 rtc::Event event_;
167 } renderer;
168
169 std::unique_ptr<test::FrameGeneratorInterface> frame_generator;
170 test::FrameForwarder frame_forwarder;
171
172 std::unique_ptr<test::DirectTransport> sender_transport;
173 std::unique_ptr<test::DirectTransport> receiver_transport;
174
175 SendTask(
176 RTC_FROM_HERE, task_queue(),
177 [this, &renderer, &frame_generator, &frame_forwarder, &sender_transport,
178 &receiver_transport]() {
179 CreateCalls();
180
181 sender_transport = std::make_unique<test::DirectTransport>(
182 task_queue(),
183 std::make_unique<FakeNetworkPipe>(
184 Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
185 BuiltInNetworkBehaviorConfig())),
186 sender_call_.get(), payload_type_map_);
187 receiver_transport = std::make_unique<test::DirectTransport>(
188 task_queue(),
189 std::make_unique<FakeNetworkPipe>(
190 Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
191 BuiltInNetworkBehaviorConfig())),
192 receiver_call_.get(), payload_type_map_);
193 sender_transport->SetReceiver(receiver_call_->Receiver());
194 receiver_transport->SetReceiver(sender_call_->Receiver());
195
196 CreateSendConfig(1, 0, 0, sender_transport.get());
197 CreateMatchingReceiveConfigs(receiver_transport.get());
198 video_receive_configs_[0].renderer = &renderer;
199
200 CreateVideoStreams();
201 Start();
202
203 frame_generator = test::CreateSquareFrameGenerator(
204 kDefaultWidth, kDefaultHeight, absl::nullopt, absl::nullopt);
205 GetVideoSendStream()->SetSource(
206 &frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE);
207 test::FrameGeneratorInterface::VideoFrameData frame_data =
208 frame_generator->NextFrame();
209 VideoFrame frame = VideoFrame::Builder()
210 .set_video_frame_buffer(frame_data.buffer)
211 .set_update_rect(frame_data.update_rect)
212 .build();
213 frame_forwarder.IncomingCapturedFrame(frame);
214 });
215
216 EXPECT_TRUE(renderer.Wait())
217 << "Timed out while waiting for the frame to render.";
218
219 SendTask(RTC_FROM_HERE, task_queue(),
220 [this, &sender_transport, &receiver_transport]() {
221 Stop();
222 DestroyStreams();
223 sender_transport.reset();
224 receiver_transport.reset();
225 DestroyCalls();
226 });
227 }
228
229 } // namespace webrtc
230