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.
  */
 
 #include <memory>
 #include <vector>
 
 #include "vpx/vp8cx.h"
 #include "vpx/vpx_encoder.h"
 #include "webrtc/modules/video_coding/codecs/vp8/screenshare_layers.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/utility/mock/mock_frame_dropper.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/metrics_default.h"
 #include "webrtc/test/gtest.h"
 
 using ::testing::_;
+using ::testing::ElementsAre;
 using ::testing::NiceMock;
 using ::testing::Return;
 
 namespace webrtc {
 
 // 5 frames per second at 90 kHz.
 const uint32_t kTimestampDelta5Fps = 90000 / 5;
 const int kDefaultQp = 54;
 const int kDefaultTl0BitrateKbps = 200;
 const int kDefaultTl1BitrateKbps = 2000;
@@ skipping 19 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));
+    EXPECT_THAT(layers_->OnRatesUpdated(kDefaultTl0BitrateKbps,
+                                        kDefaultTl1BitrateKbps, kFrameRate),
+                ElementsAre(kDefaultTl0BitrateKbps,
+                            kDefaultTl1BitrateKbps - kDefaultTl0BitrateKbps));
+    EXPECT_TRUE(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);
+  const int kTl0_kbps = 100;
+  const int kTl1_kbps = 1000;
+  layers_->OnRatesUpdated(kTl0_kbps, kTl1_kbps, 5);
+
+  EXPECT_THAT(layers_->OnRatesUpdated(kTl0_kbps, kTl1_kbps, 5),
+              ElementsAre(kTl0_kbps, kTl1_kbps - kTl0_kbps));
+  EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
 
   EXPECT_EQ(static_cast<unsigned int>(
-                ScreenshareLayers::kMaxTL0FpsReduction * 100 + 0.5),
+                ScreenshareLayers::kMaxTL0FpsReduction * kTl0_kbps + 0.5),
             cfg.rc_target_bitrate);
 }
 
 TEST_F(ScreenshareLayerTest, TargetBitrateCappedByTL1) {
   vpx_codec_enc_cfg_t cfg = GetConfig();
-  layers_->ConfigureBitrates(100, 450, 5, &cfg);
+  const int kTl0_kbps = 100;
+  const int kTl1_kbps = 450;
+  EXPECT_THAT(layers_->OnRatesUpdated(kTl0_kbps, kTl1_kbps, 5),
+              ElementsAre(kTl0_kbps, kTl1_kbps - kTl0_kbps));
+  EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
 
   EXPECT_EQ(static_cast<unsigned int>(
-                450 / ScreenshareLayers::kAcceptableTargetOvershoot),
+                kTl1_kbps / ScreenshareLayers::kAcceptableTargetOvershoot),
             cfg.rc_target_bitrate);
 }
 
 TEST_F(ScreenshareLayerTest, TargetBitrateBelowTL0) {
   vpx_codec_enc_cfg_t cfg = GetConfig();
-  layers_->ConfigureBitrates(100, 100, 5, &cfg);
+  const int kTl0_kbps = 100;
+  const int kTl1_kbps = 100;
+  EXPECT_THAT(layers_->OnRatesUpdated(kTl0_kbps, kTl1_kbps, 5),
+              ElementsAre(kTl0_kbps));
+  EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
 
-  EXPECT_EQ(100U, cfg.rc_target_bitrate);
+  EXPECT_EQ(static_cast<uint32_t>(kTl1_kbps), cfg.rc_target_bitrate);
 }
 
 TEST_F(ScreenshareLayerTest, EncoderDrop) {
   ConfigureBitrates();
   CodecSpecificInfoVP8 vp8_info;
   vpx_codec_enc_cfg_t cfg = GetConfig();
 
   uint32_t timestamp = RunGracePeriod();
   timestamp = SkipUntilTl(0, timestamp);
 
@@ skipping 39 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