Extract bitrate allocation of spatial/temporal layers out of codec impl.

webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 43 matching lines @@
     layers_->PopulateCodecSpecific(base_sync, vp8_info, timestamp);
     ASSERT_NE(-1, frame_size_);
     layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
   }
 
   void ConfigureBitrates() {
     vpx_codec_enc_cfg_t vpx_cfg;
     memset(&vpx_cfg, 0, sizeof(vpx_codec_enc_cfg_t));
     vpx_cfg.rc_min_quantizer = min_qp_;
     vpx_cfg.rc_max_quantizer = max_qp_;
-    EXPECT_TRUE(layers_->ConfigureBitrates(
-        kDefaultTl0BitrateKbps, kDefaultTl1BitrateKbps, kFrameRate, &vpx_cfg));
+    layers_->OnRatesUpdated(kDefaultTl0BitrateKbps, kDefaultTl1BitrateKbps,
+                            kFrameRate);
+    layers_->UpdateConfiguration(&vpx_cfg);
     frame_size_ = ((vpx_cfg.rc_target_bitrate * 1000) / 8) / kFrameRate;
   }
 
   void WithQpLimits(int min_qp, int max_qp) {
     min_qp_ = min_qp;
     max_qp_ = max_qp;
   }
 
   int RunGracePeriod() {
     int flags = 0;
@@ skipping 290 matching lines @@
       }
     }
   }
 
   EXPECT_EQ(50, tl0_frames + tl1_frames);
   EXPECT_EQ(50, dropped_frames);
 }
 
 TEST_F(ScreenshareLayerTest, TargetBitrateCappedByTL0) {
   vpx_codec_enc_cfg_t cfg = GetConfig();
-  layers_->ConfigureBitrates(100, 1000, 5, &cfg);
+  layers_->OnRatesUpdated(100, 1000, 5);
+  layers_->UpdateConfiguration(&cfg);
 
   EXPECT_EQ(static_cast<unsigned int>(
                 ScreenshareLayers::kMaxTL0FpsReduction * 100 + 0.5),
             cfg.rc_target_bitrate);
 }
 
 TEST_F(ScreenshareLayerTest, TargetBitrateCappedByTL1) {
   vpx_codec_enc_cfg_t cfg = GetConfig();
-  layers_->ConfigureBitrates(100, 450, 5, &cfg);
+  layers_->OnRatesUpdated(100, 450, 5);
+  layers_->UpdateConfiguration(&cfg);
 
   EXPECT_EQ(static_cast<unsigned int>(
                 450 / ScreenshareLayers::kAcceptableTargetOvershoot),
             cfg.rc_target_bitrate);
 }
 
 TEST_F(ScreenshareLayerTest, TargetBitrateBelowTL0) {
   vpx_codec_enc_cfg_t cfg = GetConfig();
-  layers_->ConfigureBitrates(100, 100, 5, &cfg);
+  layers_->OnRatesUpdated(100, 100, 5);
+  layers_->UpdateConfiguration(&cfg);
 
   EXPECT_EQ(100U, cfg.rc_target_bitrate);
 }
 
 TEST_F(ScreenshareLayerTest, EncoderDrop) {
   ConfigureBitrates();
   CodecSpecificInfoVP8 vp8_info;
   vpx_codec_enc_cfg_t cfg = GetConfig();
 
   uint32_t timestamp = RunGracePeriod();
@@ skipping 41 matching lines @@
   EXPECT_EQ(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
   layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
 }
 
 TEST_F(ScreenshareLayerTest, RespectsMaxIntervalBetweenFrames) {
   const int kLowBitrateKbps = 50;
   const int kLargeFrameSizeBytes = 100000;
   const uint32_t kStartTimestamp = 1234;
 
   vpx_codec_enc_cfg_t cfg = GetConfig();
-  layers_->ConfigureBitrates(kLowBitrateKbps, kLowBitrateKbps, 5, &cfg);
+  layers_->OnRatesUpdated(kLowBitrateKbps, kLowBitrateKbps, 5);
+  layers_->UpdateConfiguration(&cfg);
 
   EXPECT_EQ(ScreenshareLayers::kTl0Flags,
             layers_->EncodeFlags(kStartTimestamp));
   layers_->FrameEncoded(kLargeFrameSizeBytes, kStartTimestamp, kDefaultQp);
 
   const uint32_t kTwoSecondsLater =
       kStartTimestamp + (ScreenshareLayers::kMaxFrameIntervalMs * 90);
 
   // Sanity check, repayment time should exceed kMaxFrameIntervalMs.
   ASSERT_GT(kStartTimestamp + 90 * (kLargeFrameSizeBytes * 8) / kLowBitrateKbps,
@@ skipping 78 matching lines @@
             metrics::NumEvents("WebRTC.Video.Screenshare.Layer1.Qp", kTl1Qp));
   EXPECT_EQ(1,
             metrics::NumEvents("WebRTC.Video.Screenshare.Layer0.TargetBitrate",
                                kDefaultTl0BitrateKbps));
   EXPECT_EQ(1,
             metrics::NumEvents("WebRTC.Video.Screenshare.Layer1.TargetBitrate",
                                kDefaultTl1BitrateKbps));
 }
 
 }  // namespace webrtc