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

webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc

 /*
  *  Copyright (c) 2014 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 59 matching lines @@
       cpu_speed_(3),
       rc_max_intra_target_(0),
       encoder_(NULL),
       config_(NULL),
       raw_(NULL),
       input_image_(NULL),
       tl0_pic_idx_(0),
       frames_since_kf_(0),
       num_temporal_layers_(0),
       num_spatial_layers_(0),
+      is_flexible_mode_(false),
       frames_encoded_(0),
       // Use two spatial when screensharing with flexible mode.
       spatial_layer_(new ScreenshareLayersVP9(2)) {
   memset(&codec_, 0, sizeof(codec_));
   memset(&svc_internal_.svc_params, 0, sizeof(vpx_svc_extra_cfg_t));
   uint32_t seed = rtc::Time32();
   srand(seed);
 }
 
 VP9EncoderImpl::~VP9EncoderImpl() {
@@ skipping 96 matching lines @@
   // For now, temporal layers only supported when having one spatial layer.
   if (num_spatial_layers_ == 1) {
     for (i = 0; i < num_temporal_layers_; ++i) {
       config_->ts_target_bitrate[i] = config_->layer_target_bitrate[i];
     }
   }
 
   return true;
 }
 
-int VP9EncoderImpl::SetRates(uint32_t new_bitrate_kbit,
-                             uint32_t new_framerate) {
+int VP9EncoderImpl::SetRateAllocation(
+    const BitrateAllocation& bitrate_allocation,
+    uint32_t frame_rate) {
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   if (encoder_->err) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
-  if (new_framerate < 1) {
+  if (frame_rate < 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // Update bit rate
-  if (codec_.maxBitrate > 0 && new_bitrate_kbit > codec_.maxBitrate) {
-    new_bitrate_kbit = codec_.maxBitrate;
+  if (codec_.maxBitrate > 0 &&
+      bitrate_allocation.get_sum_kbps() > codec_.maxBitrate) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
-  config_->rc_target_bitrate = new_bitrate_kbit;
-  codec_.maxFramerate = new_framerate;
-  spatial_layer_->ConfigureBitrate(new_bitrate_kbit, 0);
+
+  // TODO(sprang): Actually use BitrateAllocation layer info.
+  config_->rc_target_bitrate = bitrate_allocation.get_sum_kbps();
+  codec_.maxFramerate = frame_rate;
+  spatial_layer_->ConfigureBitrate(bitrate_allocation.get_sum_kbps(), 0);
 
   if (!SetSvcRates()) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
   // Update encoder context
   if (vpx_codec_enc_config_set(encoder_, config_)) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   return WEBRTC_VIDEO_CODEC_OK;
@@ skipping 772 matching lines @@
   frame_buffer_pool_.ClearPool();
   inited_ = false;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 const char* VP9DecoderImpl::ImplementationName() const {
   return "libvpx";
 }
 
 }  // namespace webrtc