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 324
