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
20namespace webrtc {
21
22typedef VP9EncoderImpl::SuperFrameRefSettings Settings;
23
24const uint32_t kTickFrequency = 90000;
25
26class 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
87TEST_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.
108TEST_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;
140TEST_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.
162TEST_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.
230TEST_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.
301TEST_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