vp9/ratectrl_rtc.cc - webm/libvpx - Git at Google

 /*
  *  Copyright (c) 2020 The WebM 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 "vp9/ratectrl_rtc.h"

 #include <new>

 #include "vp9/common/vp9_common.h"
 #include "vp9/encoder/vp9_encoder.h"
 #include "vp9/encoder/vp9_picklpf.h"
 #include "vpx/vp8cx.h"
 #include "vpx/vpx_codec.h"

 namespace libvpx {

 std::unique_ptr<VP9RateControlRTC> VP9RateControlRTC::Create(
     const VP9RateControlRtcConfig &cfg) {
   std::unique_ptr<VP9RateControlRTC> rc_api(new (std::nothrow)
                                                 VP9RateControlRTC());
   if (!rc_api) return nullptr;
   rc_api->cpi_ = static_cast<VP9_COMP *>(vpx_memalign(32, sizeof(*cpi_)));
   if (!rc_api->cpi_) return nullptr;
   vp9_zero(*rc_api->cpi_);

   rc_api->InitRateControl(cfg);
   if (cfg.aq_mode) {
     VP9_COMP *const cpi = rc_api->cpi_;
     cpi->segmentation_map = static_cast<uint8_t *>(
         vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols,
                    sizeof(*cpi->segmentation_map)));
     cpi->cyclic_refresh =
         vp9_cyclic_refresh_alloc(cpi->common.mi_rows, cpi->common.mi_cols);
     cpi->cyclic_refresh->content_mode = 0;
   }
   return rc_api;
 }

 void VP9RateControlRTC::InitRateControl(const VP9RateControlRtcConfig &rc_cfg) {
   VP9_COMMON *cm = &cpi_->common;
   VP9EncoderConfig *oxcf = &cpi_->oxcf;
   RATE_CONTROL *const rc = &cpi_->rc;
   cm->profile = PROFILE_0;
   cm->bit_depth = VPX_BITS_8;
   cm->show_frame = 1;
   oxcf->profile = cm->profile;
   oxcf->bit_depth = cm->bit_depth;
   oxcf->rc_mode = rc_cfg.rc_mode;
   oxcf->pass = 0;
   oxcf->aq_mode = rc_cfg.aq_mode ? CYCLIC_REFRESH_AQ : NO_AQ;
   oxcf->content = VP9E_CONTENT_DEFAULT;
   oxcf->drop_frames_water_mark = 0;
   cm->current_video_frame = 0;
   rc->kf_boost = DEFAULT_KF_BOOST;

   UpdateRateControl(rc_cfg);
   vp9_set_mb_mi(cm, cm->width, cm->height);

   cpi_->use_svc = (cpi_->svc.number_spatial_layers > 1 ||
                    cpi_->svc.number_temporal_layers > 1)
                       ? 1
                       : 0;

   rc->rc_1_frame = 0;
   rc->rc_2_frame = 0;
   vp9_rc_init_minq_luts();
   vp9_rc_init(oxcf, 0, rc);
   rc->constrain_gf_key_freq_onepass_vbr = 0;
   cpi_->sf.use_nonrd_pick_mode = 1;
 }

 void VP9RateControlRTC::UpdateRateControl(
     const VP9RateControlRtcConfig &rc_cfg) {
   VP9_COMMON *cm = &cpi_->common;
   VP9EncoderConfig *oxcf = &cpi_->oxcf;
   RATE_CONTROL *const rc = &cpi_->rc;

   cm->width = rc_cfg.width;
   cm->height = rc_cfg.height;
   oxcf->width = rc_cfg.width;
   oxcf->height = rc_cfg.height;
   oxcf->worst_allowed_q = vp9_quantizer_to_qindex(rc_cfg.max_quantizer);
   oxcf->best_allowed_q = vp9_quantizer_to_qindex(rc_cfg.min_quantizer);
   rc->worst_quality = oxcf->worst_allowed_q;
   rc->best_quality = oxcf->best_allowed_q;
   oxcf->init_framerate = rc_cfg.framerate;
   oxcf->target_bandwidth = 1000 * rc_cfg.target_bandwidth;
   oxcf->starting_buffer_level_ms = rc_cfg.buf_initial_sz;
   oxcf->optimal_buffer_level_ms = rc_cfg.buf_optimal_sz;
   oxcf->maximum_buffer_size_ms = rc_cfg.buf_sz;
   oxcf->under_shoot_pct = rc_cfg.undershoot_pct;
   oxcf->over_shoot_pct = rc_cfg.overshoot_pct;
   oxcf->ss_number_layers = rc_cfg.ss_number_layers;
   oxcf->ts_number_layers = rc_cfg.ts_number_layers;
   oxcf->temporal_layering_mode = (VP9E_TEMPORAL_LAYERING_MODE)(
       (rc_cfg.ts_number_layers > 1) ? rc_cfg.ts_number_layers : 0);

   cpi_->oxcf.rc_max_intra_bitrate_pct = rc_cfg.max_intra_bitrate_pct;
   cpi_->oxcf.rc_max_inter_bitrate_pct = rc_cfg.max_inter_bitrate_pct;
   cpi_->framerate = rc_cfg.framerate;
   cpi_->svc.number_spatial_layers = rc_cfg.ss_number_layers;
   cpi_->svc.number_temporal_layers = rc_cfg.ts_number_layers;
   vp9_set_mb_mi(cm, cm->width, cm->height);
   for (int sl = 0; sl < cpi_->svc.number_spatial_layers; ++sl) {
     for (int tl = 0; tl < cpi_->svc.number_temporal_layers; ++tl) {
       const int layer =
           LAYER_IDS_TO_IDX(sl, tl, cpi_->svc.number_temporal_layers);
       LAYER_CONTEXT *lc = &cpi_->svc.layer_context[layer];
       RATE_CONTROL *const lrc = &lc->rc;
       oxcf->layer_target_bitrate[layer] =
           1000 * rc_cfg.layer_target_bitrate[layer];
       lrc->worst_quality =
           vp9_quantizer_to_qindex(rc_cfg.max_quantizers[layer]);
       lrc->best_quality = vp9_quantizer_to_qindex(rc_cfg.min_quantizers[layer]);
       lc->scaling_factor_num = rc_cfg.scaling_factor_num[sl];
       lc->scaling_factor_den = rc_cfg.scaling_factor_den[sl];
       oxcf->ts_rate_decimator[tl] = rc_cfg.ts_rate_decimator[tl];
     }
   }
   vp9_set_rc_buffer_sizes(cpi_);
   vp9_new_framerate(cpi_, cpi_->framerate);
   if (cpi_->svc.number_temporal_layers > 1 ||
       cpi_->svc.number_spatial_layers > 1) {
     if (cm->current_video_frame == 0) vp9_init_layer_context(cpi_);
     vp9_update_layer_context_change_config(cpi_,
                                            (int)cpi_->oxcf.target_bandwidth);
   }
   vp9_check_reset_rc_flag(cpi_);
 }

 void VP9RateControlRTC::ComputeQP(const VP9FrameParamsQpRTC &frame_params) {
   VP9_COMMON *const cm = &cpi_->common;
   int width, height;
   cpi_->svc.spatial_layer_id = frame_params.spatial_layer_id;
   cpi_->svc.temporal_layer_id = frame_params.temporal_layer_id;
   if (cpi_->svc.number_spatial_layers > 1) {
     const int layer = LAYER_IDS_TO_IDX(cpi_->svc.spatial_layer_id,
                                        cpi_->svc.temporal_layer_id,
                                        cpi_->svc.number_temporal_layers);
     LAYER_CONTEXT *lc = &cpi_->svc.layer_context[layer];
     get_layer_resolution(cpi_->oxcf.width, cpi_->oxcf.height,
                          lc->scaling_factor_num, lc->scaling_factor_den, &width,
                          &height);
     cm->width = width;
     cm->height = height;
   }
   vp9_set_mb_mi(cm, cm->width, cm->height);
   cm->frame_type = frame_params.frame_type;
   cpi_->refresh_golden_frame = (cm->frame_type == KEY_FRAME) ? 1 : 0;
   cpi_->sf.use_nonrd_pick_mode = 1;
   if (cpi_->svc.number_spatial_layers == 1 &&
       cpi_->svc.number_temporal_layers == 1) {
     int target = 0;
     if (cpi_->oxcf.rc_mode == VPX_CBR) {
       if (cpi_->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
         vp9_cyclic_refresh_update_parameters(cpi_);
       if (frame_is_intra_only(cm))
         target = vp9_calc_iframe_target_size_one_pass_cbr(cpi_);
       else
         target = vp9_calc_pframe_target_size_one_pass_cbr(cpi_);
     } else if (cpi_->oxcf.rc_mode == VPX_VBR) {
       if (cm->frame_type == KEY_FRAME) {
         cpi_->rc.this_key_frame_forced = cm->current_video_frame != 0;
         cpi_->rc.frames_to_key = cpi_->oxcf.key_freq;
       }
       vp9_set_gf_update_one_pass_vbr(cpi_);
       if (cpi_->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
         vp9_cyclic_refresh_update_parameters(cpi_);
       if (frame_is_intra_only(cm))
         target = vp9_calc_iframe_target_size_one_pass_vbr(cpi_);
       else
         target = vp9_calc_pframe_target_size_one_pass_vbr(cpi_);
     }
     vp9_rc_set_frame_target(cpi_, target);
     vp9_update_buffer_level_preencode(cpi_);
   } else {
     vp9_update_temporal_layer_framerate(cpi_);
     vp9_restore_layer_context(cpi_);
     vp9_rc_get_svc_params(cpi_);
   }
   int bottom_index, top_index;
   cpi_->common.base_qindex =
       vp9_rc_pick_q_and_bounds(cpi_, &bottom_index, &top_index);

   if (cpi_->oxcf.aq_mode == CYCLIC_REFRESH_AQ) vp9_cyclic_refresh_setup(cpi_);
 }

 int VP9RateControlRTC::GetQP() const { return cpi_->common.base_qindex; }

 int VP9RateControlRTC::GetLoopfilterLevel() const {
   struct loopfilter *const lf = &cpi_->common.lf;
   vp9_pick_filter_level(nullptr, cpi_, LPF_PICK_FROM_Q);
   return lf->filter_level;
 }

 signed char *VP9RateControlRTC::GetCyclicRefreshMap() const {
   return cpi_->cyclic_refresh->map;
 }

 int *VP9RateControlRTC::GetDeltaQ() const {
   return cpi_->cyclic_refresh->qindex_delta;
 }

 void VP9RateControlRTC::PostEncodeUpdate(uint64_t encoded_frame_size) {
   vp9_rc_postencode_update(cpi_, encoded_frame_size);
   if (cpi_->svc.number_spatial_layers > 1 ||
       cpi_->svc.number_temporal_layers > 1)
     vp9_save_layer_context(cpi_);
   cpi_->common.current_video_frame++;
 }

 }  // namespace libvpx
	/*
	* Copyright (c) 2020 The WebM 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 "vp9/ratectrl_rtc.h"

	#include <new>

	#include "vp9/common/vp9_common.h"
	#include "vp9/encoder/vp9_encoder.h"
	#include "vp9/encoder/vp9_picklpf.h"
	#include "vpx/vp8cx.h"
	#include "vpx/vpx_codec.h"

	namespace libvpx {

	std::unique_ptr<VP9RateControlRTC> VP9RateControlRTC::Create(
	const VP9RateControlRtcConfig &cfg) {
	std::unique_ptr<VP9RateControlRTC> rc_api(new (std::nothrow)
	VP9RateControlRTC());
	if (!rc_api) return nullptr;
	rc_api->cpi_ = static_cast<VP9_COMP >(vpx_memalign(32, sizeof(cpi_)));
	if (!rc_api->cpi_) return nullptr;
	vp9_zero(*rc_api->cpi_);

	rc_api->InitRateControl(cfg);
	if (cfg.aq_mode) {
	VP9_COMP *const cpi = rc_api->cpi_;
	cpi->segmentation_map = static_cast<uint8_t *>(
	vpx_calloc(cpi->common.mi_rows * cpi->common.mi_cols,
	sizeof(*cpi->segmentation_map)));
	cpi->cyclic_refresh =
	vp9_cyclic_refresh_alloc(cpi->common.mi_rows, cpi->common.mi_cols);
	cpi->cyclic_refresh->content_mode = 0;
	}
	return rc_api;
	}

	void VP9RateControlRTC::InitRateControl(const VP9RateControlRtcConfig &rc_cfg) {
	VP9_COMMON *cm = &cpi_->common;
	VP9EncoderConfig *oxcf = &cpi_->oxcf;
	RATE_CONTROL *const rc = &cpi_->rc;
	cm->profile = PROFILE_0;
	cm->bit_depth = VPX_BITS_8;
	cm->show_frame = 1;
	oxcf->profile = cm->profile;
	oxcf->bit_depth = cm->bit_depth;
	oxcf->rc_mode = rc_cfg.rc_mode;
	oxcf->pass = 0;
	oxcf->aq_mode = rc_cfg.aq_mode ? CYCLIC_REFRESH_AQ : NO_AQ;
	oxcf->content = VP9E_CONTENT_DEFAULT;
	oxcf->drop_frames_water_mark = 0;
	cm->current_video_frame = 0;
	rc->kf_boost = DEFAULT_KF_BOOST;

	UpdateRateControl(rc_cfg);
	vp9_set_mb_mi(cm, cm->width, cm->height);

	cpi_->use_svc = (cpi_->svc.number_spatial_layers > 1 \|\|
	cpi_->svc.number_temporal_layers > 1)
	? 1
	: 0;

	rc->rc_1_frame = 0;
	rc->rc_2_frame = 0;
	vp9_rc_init_minq_luts();
	vp9_rc_init(oxcf, 0, rc);
	rc->constrain_gf_key_freq_onepass_vbr = 0;
	cpi_->sf.use_nonrd_pick_mode = 1;
	}

	void VP9RateControlRTC::UpdateRateControl(
	const VP9RateControlRtcConfig &rc_cfg) {
	VP9_COMMON *cm = &cpi_->common;
	VP9EncoderConfig *oxcf = &cpi_->oxcf;
	RATE_CONTROL *const rc = &cpi_->rc;

	cm->width = rc_cfg.width;
	cm->height = rc_cfg.height;
	oxcf->width = rc_cfg.width;
	oxcf->height = rc_cfg.height;
	oxcf->worst_allowed_q = vp9_quantizer_to_qindex(rc_cfg.max_quantizer);
	oxcf->best_allowed_q = vp9_quantizer_to_qindex(rc_cfg.min_quantizer);
	rc->worst_quality = oxcf->worst_allowed_q;
	rc->best_quality = oxcf->best_allowed_q;
	oxcf->init_framerate = rc_cfg.framerate;
	oxcf->target_bandwidth = 1000 * rc_cfg.target_bandwidth;
	oxcf->starting_buffer_level_ms = rc_cfg.buf_initial_sz;
	oxcf->optimal_buffer_level_ms = rc_cfg.buf_optimal_sz;
	oxcf->maximum_buffer_size_ms = rc_cfg.buf_sz;
	oxcf->under_shoot_pct = rc_cfg.undershoot_pct;
	oxcf->over_shoot_pct = rc_cfg.overshoot_pct;
	oxcf->ss_number_layers = rc_cfg.ss_number_layers;
	oxcf->ts_number_layers = rc_cfg.ts_number_layers;
	oxcf->temporal_layering_mode = (VP9E_TEMPORAL_LAYERING_MODE)(
	(rc_cfg.ts_number_layers > 1) ? rc_cfg.ts_number_layers : 0);

	cpi_->oxcf.rc_max_intra_bitrate_pct = rc_cfg.max_intra_bitrate_pct;
	cpi_->oxcf.rc_max_inter_bitrate_pct = rc_cfg.max_inter_bitrate_pct;
	cpi_->framerate = rc_cfg.framerate;
	cpi_->svc.number_spatial_layers = rc_cfg.ss_number_layers;
	cpi_->svc.number_temporal_layers = rc_cfg.ts_number_layers;
	vp9_set_mb_mi(cm, cm->width, cm->height);
	for (int sl = 0; sl < cpi_->svc.number_spatial_layers; ++sl) {
	for (int tl = 0; tl < cpi_->svc.number_temporal_layers; ++tl) {
	const int layer =
	LAYER_IDS_TO_IDX(sl, tl, cpi_->svc.number_temporal_layers);
	LAYER_CONTEXT *lc = &cpi_->svc.layer_context[layer];
	RATE_CONTROL *const lrc = &lc->rc;
	oxcf->layer_target_bitrate[layer] =
	1000 * rc_cfg.layer_target_bitrate[layer];
	lrc->worst_quality =
	vp9_quantizer_to_qindex(rc_cfg.max_quantizers[layer]);
	lrc->best_quality = vp9_quantizer_to_qindex(rc_cfg.min_quantizers[layer]);
	lc->scaling_factor_num = rc_cfg.scaling_factor_num[sl];
	lc->scaling_factor_den = rc_cfg.scaling_factor_den[sl];
	oxcf->ts_rate_decimator[tl] = rc_cfg.ts_rate_decimator[tl];
	}
	}
	vp9_set_rc_buffer_sizes(cpi_);
	vp9_new_framerate(cpi_, cpi_->framerate);
	if (cpi_->svc.number_temporal_layers > 1 \|\|
	cpi_->svc.number_spatial_layers > 1) {
	if (cm->current_video_frame == 0) vp9_init_layer_context(cpi_);
	vp9_update_layer_context_change_config(cpi_,
	(int)cpi_->oxcf.target_bandwidth);
	}
	vp9_check_reset_rc_flag(cpi_);
	}

	void VP9RateControlRTC::ComputeQP(const VP9FrameParamsQpRTC &frame_params) {
	VP9_COMMON *const cm = &cpi_->common;
	int width, height;
	cpi_->svc.spatial_layer_id = frame_params.spatial_layer_id;
	cpi_->svc.temporal_layer_id = frame_params.temporal_layer_id;
	if (cpi_->svc.number_spatial_layers > 1) {
	const int layer = LAYER_IDS_TO_IDX(cpi_->svc.spatial_layer_id,
	cpi_->svc.temporal_layer_id,
	cpi_->svc.number_temporal_layers);
	LAYER_CONTEXT *lc = &cpi_->svc.layer_context[layer];
	get_layer_resolution(cpi_->oxcf.width, cpi_->oxcf.height,
	lc->scaling_factor_num, lc->scaling_factor_den, &width,
	&height);
	cm->width = width;
	cm->height = height;
	}
	vp9_set_mb_mi(cm, cm->width, cm->height);
	cm->frame_type = frame_params.frame_type;
	cpi_->refresh_golden_frame = (cm->frame_type == KEY_FRAME) ? 1 : 0;
	cpi_->sf.use_nonrd_pick_mode = 1;
	if (cpi_->svc.number_spatial_layers == 1 &&
	cpi_->svc.number_temporal_layers == 1) {
	int target = 0;
	if (cpi_->oxcf.rc_mode == VPX_CBR) {
	if (cpi_->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
	vp9_cyclic_refresh_update_parameters(cpi_);
	if (frame_is_intra_only(cm))
	target = vp9_calc_iframe_target_size_one_pass_cbr(cpi_);
	else
	target = vp9_calc_pframe_target_size_one_pass_cbr(cpi_);
	} else if (cpi_->oxcf.rc_mode == VPX_VBR) {
	if (cm->frame_type == KEY_FRAME) {
	cpi_->rc.this_key_frame_forced = cm->current_video_frame != 0;
	cpi_->rc.frames_to_key = cpi_->oxcf.key_freq;
	}
	vp9_set_gf_update_one_pass_vbr(cpi_);
	if (cpi_->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
	vp9_cyclic_refresh_update_parameters(cpi_);
	if (frame_is_intra_only(cm))
	target = vp9_calc_iframe_target_size_one_pass_vbr(cpi_);
	else
	target = vp9_calc_pframe_target_size_one_pass_vbr(cpi_);
	}
	vp9_rc_set_frame_target(cpi_, target);
	vp9_update_buffer_level_preencode(cpi_);
	} else {
	vp9_update_temporal_layer_framerate(cpi_);
	vp9_restore_layer_context(cpi_);
	vp9_rc_get_svc_params(cpi_);
	}
	int bottom_index, top_index;
	cpi_->common.base_qindex =
	vp9_rc_pick_q_and_bounds(cpi_, &bottom_index, &top_index);

	if (cpi_->oxcf.aq_mode == CYCLIC_REFRESH_AQ) vp9_cyclic_refresh_setup(cpi_);
	}

	int VP9RateControlRTC::GetQP() const { return cpi_->common.base_qindex; }

	int VP9RateControlRTC::GetLoopfilterLevel() const {
	struct loopfilter *const lf = &cpi_->common.lf;
	vp9_pick_filter_level(nullptr, cpi_, LPF_PICK_FROM_Q);
	return lf->filter_level;
	}

	signed char *VP9RateControlRTC::GetCyclicRefreshMap() const {
	return cpi_->cyclic_refresh->map;
	}

	int *VP9RateControlRTC::GetDeltaQ() const {
	return cpi_->cyclic_refresh->qindex_delta;
	}

	void VP9RateControlRTC::PostEncodeUpdate(uint64_t encoded_frame_size) {
	vp9_rc_postencode_update(cpi_, encoded_frame_size);
	if (cpi_->svc.number_spatial_layers > 1 \|\|
	cpi_->svc.number_temporal_layers > 1)
	vp9_save_layer_context(cpi_);
	cpi_->common.current_video_frame++;
	}

	} // namespace libvpx