1 /*
2 * Copyright (c) 2015 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 <limits>
12
13 #include "testing/gtest/include/gtest/gtest.h"
14 #include "vpx/vp8cx.h"
15 #include "webrtc/base/logging.h"
16 #include "webrtc/modules/video_coding/codecs/vp9/screenshare_layers.h"
17 #include "webrtc/modules/video_coding/codecs/vp9/vp9_impl.h"
18 #include "webrtc/system_wrappers/include/clock.h"
19
20 namespace webrtc {
21
22 typedef VP9EncoderImpl::SuperFrameRefSettings Settings;
23
24 const uint32_t kTickFrequency = 90000;
25
26 class ScreenshareLayerTestVP9 : public ::testing::Test {
27 protected:
ScreenshareLayerTestVP9()28 ScreenshareLayerTestVP9() : clock_(0) {}
~ScreenshareLayerTestVP9()29 virtual ~ScreenshareLayerTestVP9() {}
30
InitScreenshareLayers(int layers)31 void InitScreenshareLayers(int layers) {
32 layers_.reset(new ScreenshareLayersVP9(layers));
33 }
34
ConfigureBitrateForLayer(int kbps,uint8_t layer_id)35 void ConfigureBitrateForLayer(int kbps, uint8_t layer_id) {
36 layers_->ConfigureBitrate(kbps, layer_id);
37 }
38
AdvanceTime(int64_t milliseconds)39 void AdvanceTime(int64_t milliseconds) {
40 clock_.AdvanceTimeMilliseconds(milliseconds);
41 }
42
AddKilobitsToLayer(int kilobits,uint8_t layer_id)43 void AddKilobitsToLayer(int kilobits, uint8_t layer_id) {
44 layers_->LayerFrameEncoded(kilobits * 1000 / 8, layer_id);
45 }
46
EqualRefsForLayer(const Settings & actual,uint8_t layer_id)47 void EqualRefsForLayer(const Settings& actual, uint8_t layer_id) {
48 EXPECT_EQ(expected_.layer[layer_id].upd_buf,
49 actual.layer[layer_id].upd_buf);
50 EXPECT_EQ(expected_.layer[layer_id].ref_buf1,
51 actual.layer[layer_id].ref_buf1);
52 EXPECT_EQ(expected_.layer[layer_id].ref_buf2,
53 actual.layer[layer_id].ref_buf2);
54 EXPECT_EQ(expected_.layer[layer_id].ref_buf3,
55 actual.layer[layer_id].ref_buf3);
56 }
57
EqualRefs(const Settings & actual)58 void EqualRefs(const Settings& actual) {
59 for (unsigned int layer_id = 0; layer_id < kMaxVp9NumberOfSpatialLayers;
60 ++layer_id) {
61 EqualRefsForLayer(actual, layer_id);
62 }
63 }
64
EqualStartStopKeyframe(const Settings & actual)65 void EqualStartStopKeyframe(const Settings& actual) {
66 EXPECT_EQ(expected_.start_layer, actual.start_layer);
67 EXPECT_EQ(expected_.stop_layer, actual.stop_layer);
68 EXPECT_EQ(expected_.is_keyframe, actual.is_keyframe);
69 }
70
71 // Check that the settings returned by GetSuperFrameSettings() is
72 // equal to the expected_ settings.
EqualToExpected()73 void EqualToExpected() {
74 uint32_t frame_timestamp_ =
75 clock_.TimeInMilliseconds() * (kTickFrequency / 1000);
76 Settings actual =
77 layers_->GetSuperFrameSettings(frame_timestamp_, expected_.is_keyframe);
78 EqualRefs(actual);
79 EqualStartStopKeyframe(actual);
80 }
81
82 Settings expected_;
83 SimulatedClock clock_;
84 rtc::scoped_ptr<ScreenshareLayersVP9> layers_;
85 };
86
TEST_F(ScreenshareLayerTestVP9,NoRefsOnKeyFrame)87 TEST_F(ScreenshareLayerTestVP9, NoRefsOnKeyFrame) {
88 const int kNumLayers = kMaxVp9NumberOfSpatialLayers;
89 InitScreenshareLayers(kNumLayers);
90 expected_.start_layer = 0;
91 expected_.stop_layer = kNumLayers - 1;
92
93 for (int l = 0; l < kNumLayers; ++l) {
94 expected_.layer[l].upd_buf = l;
95 }
96 expected_.is_keyframe = true;
97 EqualToExpected();
98
99 for (int l = 0; l < kNumLayers; ++l) {
100 expected_.layer[l].ref_buf1 = l;
101 }
102 expected_.is_keyframe = false;
103 EqualToExpected();
104 }
105
106 // Test if it is possible to send at a high bitrate (over the threshold)
107 // after a longer period of low bitrate. This should not be possible.
TEST_F(ScreenshareLayerTestVP9,DontAccumelateAvailableBitsOverTime)108 TEST_F(ScreenshareLayerTestVP9, DontAccumelateAvailableBitsOverTime) {
109 InitScreenshareLayers(2);
110 ConfigureBitrateForLayer(100, 0);
111
112 expected_.layer[0].upd_buf = 0;
113 expected_.layer[0].ref_buf1 = 0;
114 expected_.layer[1].upd_buf = 1;
115 expected_.layer[1].ref_buf1 = 1;
116 expected_.start_layer = 0;
117 expected_.stop_layer = 1;
118
119 // Send 10 frames at a low bitrate (50 kbps)
120 for (int i = 0; i < 10; ++i) {
121 AdvanceTime(200);
122 EqualToExpected();
123 AddKilobitsToLayer(10, 0);
124 }
125
126 AdvanceTime(200);
127 EqualToExpected();
128 AddKilobitsToLayer(301, 0);
129
130 // Send 10 frames at a high bitrate (200 kbps)
131 expected_.start_layer = 1;
132 for (int i = 0; i < 10; ++i) {
133 AdvanceTime(200);
134 EqualToExpected();
135 AddKilobitsToLayer(40, 1);
136 }
137 }
138
139 // Test if used bits are accumelated over layers, as they should;
TEST_F(ScreenshareLayerTestVP9,AccumelateUsedBitsOverLayers)140 TEST_F(ScreenshareLayerTestVP9, AccumelateUsedBitsOverLayers) {
141 const int kNumLayers = kMaxVp9NumberOfSpatialLayers;
142 InitScreenshareLayers(kNumLayers);
143 for (int l = 0; l < kNumLayers - 1; ++l)
144 ConfigureBitrateForLayer(100, l);
145 for (int l = 0; l < kNumLayers; ++l) {
146 expected_.layer[l].upd_buf = l;
147 expected_.layer[l].ref_buf1 = l;
148 }
149
150 expected_.start_layer = 0;
151 expected_.stop_layer = kNumLayers - 1;
152 EqualToExpected();
153
154 for (int layer = 0; layer < kNumLayers - 1; ++layer) {
155 expected_.start_layer = layer;
156 EqualToExpected();
157 AddKilobitsToLayer(101, layer);
158 }
159 }
160
161 // General testing of the bitrate controller.
162 TEST_F(ScreenshareLayerTestVP9, 2LayerBitrate) {
163 InitScreenshareLayers(2);
164 ConfigureBitrateForLayer(100, 0);
165
166 expected_.layer[0].upd_buf = 0;
167 expected_.layer[1].upd_buf = 1;
168 expected_.layer[0].ref_buf1 = -1;
169 expected_.layer[1].ref_buf1 = -1;
170 expected_.start_layer = 0;
171 expected_.stop_layer = 1;
172
173 expected_.is_keyframe = true;
174 EqualToExpected();
175 AddKilobitsToLayer(100, 0);
176
177 expected_.layer[0].ref_buf1 = 0;
178 expected_.layer[1].ref_buf1 = 1;
179 expected_.is_keyframe = false;
180 AdvanceTime(199);
181 EqualToExpected();
182 AddKilobitsToLayer(100, 0);
183
184 expected_.start_layer = 1;
185 for (int frame = 0; frame < 3; ++frame) {
186 AdvanceTime(200);
187 EqualToExpected();
188 AddKilobitsToLayer(100, 1);
189 }
190
191 // Just before enough bits become available for L0 @0.999 seconds.
192 AdvanceTime(199);
193 EqualToExpected();
194 AddKilobitsToLayer(100, 1);
195
196 // Just after enough bits become available for L0 @1.0001 seconds.
197 expected_.start_layer = 0;
198 AdvanceTime(2);
199 EqualToExpected();
200 AddKilobitsToLayer(100, 0);
201
202 // Keyframes always encode all layers, even if it is over budget.
203 expected_.layer[0].ref_buf1 = -1;
204 expected_.layer[1].ref_buf1 = -1;
205 expected_.is_keyframe = true;
206 AdvanceTime(499);
207 EqualToExpected();
208 expected_.layer[0].ref_buf1 = 0;
209 expected_.layer[1].ref_buf1 = 1;
210 expected_.start_layer = 1;
211 expected_.is_keyframe = false;
212 EqualToExpected();
213 AddKilobitsToLayer(100, 0);
214
215 // 400 kb in L0 --> @3 second mark to fall below the threshold..
216 // just before @2.999 seconds.
217 expected_.is_keyframe = false;
218 AdvanceTime(1499);
219 EqualToExpected();
220 AddKilobitsToLayer(100, 1);
221
222 // just after @3.001 seconds.
223 expected_.start_layer = 0;
224 AdvanceTime(2);
225 EqualToExpected();
226 AddKilobitsToLayer(100, 0);
227 }
228
229 // General testing of the bitrate controller.
230 TEST_F(ScreenshareLayerTestVP9, 3LayerBitrate) {
231 InitScreenshareLayers(3);
232 ConfigureBitrateForLayer(100, 0);
233 ConfigureBitrateForLayer(100, 1);
234
235 for (int l = 0; l < 3; ++l) {
236 expected_.layer[l].upd_buf = l;
237 expected_.layer[l].ref_buf1 = l;
238 }
239 expected_.start_layer = 0;
240 expected_.stop_layer = 2;
241
242 EqualToExpected();
243 AddKilobitsToLayer(105, 0);
244 AddKilobitsToLayer(30, 1);
245
246 AdvanceTime(199);
247 EqualToExpected();
248 AddKilobitsToLayer(105, 0);
249 AddKilobitsToLayer(30, 1);
250
251 expected_.start_layer = 1;
252 AdvanceTime(200);
253 EqualToExpected();
254 AddKilobitsToLayer(130, 1);
255
256 expected_.start_layer = 2;
257 AdvanceTime(200);
258 EqualToExpected();
259
260 // 400 kb in L1 --> @1.0 second mark to fall below threshold.
261 // 210 kb in L0 --> @1.1 second mark to fall below threshold.
262 // Just before L1 @0.999 seconds.
263 AdvanceTime(399);
264 EqualToExpected();
265
266 // Just after L1 @1.001 seconds.
267 expected_.start_layer = 1;
268 AdvanceTime(2);
269 EqualToExpected();
270
271 // Just before L0 @1.099 seconds.
272 AdvanceTime(99);
273 EqualToExpected();
274
275 // Just after L0 @1.101 seconds.
276 expected_.start_layer = 0;
277 AdvanceTime(2);
278 EqualToExpected();
279
280 // @1.1 seconds
281 AdvanceTime(99);
282 EqualToExpected();
283 AddKilobitsToLayer(200, 1);
284
285 expected_.is_keyframe = true;
286 for (int l = 0; l < 3; ++l)
287 expected_.layer[l].ref_buf1 = -1;
288 AdvanceTime(200);
289 EqualToExpected();
290
291 expected_.is_keyframe = false;
292 expected_.start_layer = 2;
293 for (int l = 0; l < 3; ++l)
294 expected_.layer[l].ref_buf1 = l;
295 AdvanceTime(200);
296 EqualToExpected();
297 }
298
299 // Test that the bitrate calculations are
300 // correct when the timestamp wrap.
TEST_F(ScreenshareLayerTestVP9,TimestampWrap)301 TEST_F(ScreenshareLayerTestVP9, TimestampWrap) {
302 InitScreenshareLayers(2);
303 ConfigureBitrateForLayer(100, 0);
304
305 expected_.layer[0].upd_buf = 0;
306 expected_.layer[0].ref_buf1 = 0;
307 expected_.layer[1].upd_buf = 1;
308 expected_.layer[1].ref_buf1 = 1;
309 expected_.start_layer = 0;
310 expected_.stop_layer = 1;
311
312 // Advance time to just before the timestamp wraps.
313 AdvanceTime(std::numeric_limits<uint32_t>::max() / (kTickFrequency / 1000));
314 EqualToExpected();
315 AddKilobitsToLayer(200, 0);
316
317 // Wrap
318 expected_.start_layer = 1;
319 AdvanceTime(1);
320 EqualToExpected();
321 }
322
323 } // namespace webrtc
324