OLD | NEW |
| (Empty) |
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: | |
28 ScreenshareLayerTestVP9() : clock_(0) {} | |
29 virtual ~ScreenshareLayerTestVP9() {} | |
30 | |
31 void InitScreenshareLayers(int layers) { | |
32 layers_.reset(new ScreenshareLayersVP9(layers)); | |
33 } | |
34 | |
35 void ConfigureBitrateForLayer(int kbps, uint8_t layer_id) { | |
36 layers_->ConfigureBitrate(kbps, layer_id); | |
37 } | |
38 | |
39 void AdvanceTime(int64_t milliseconds) { | |
40 clock_.AdvanceTimeMilliseconds(milliseconds); | |
41 } | |
42 | |
43 void AddKilobitsToLayer(int kilobits, uint8_t layer_id) { | |
44 layers_->LayerFrameEncoded(kilobits * 1000 / 8, layer_id); | |
45 } | |
46 | |
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 | |
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 | |
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. | |
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 | |
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. | |
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; | |
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. | |
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 | |
OLD | NEW |