Merge "Refactoring of rate control - part 1"
This commit is contained in:
commit
5576a4e1cb
@ -966,19 +966,19 @@ static double calc_correction_factor(double err_per_mb,
|
||||
// (now uses the actual quantizer) but has not been tuned.
|
||||
static void adjust_maxq_qrange(VP9_COMP *cpi) {
|
||||
int i;
|
||||
// Set the max corresponding to cpi->avg_q * 2.0
|
||||
double q = cpi->avg_q * 2.0;
|
||||
cpi->twopass.maxq_max_limit = cpi->worst_quality;
|
||||
for (i = cpi->best_quality; i <= cpi->worst_quality; i++) {
|
||||
// Set the max corresponding to cpi->rc.avg_q * 2.0
|
||||
double q = cpi->rc.avg_q * 2.0;
|
||||
cpi->twopass.maxq_max_limit = cpi->rc.worst_quality;
|
||||
for (i = cpi->rc.best_quality; i <= cpi->rc.worst_quality; i++) {
|
||||
cpi->twopass.maxq_max_limit = i;
|
||||
if (vp9_convert_qindex_to_q(i) >= q)
|
||||
break;
|
||||
}
|
||||
|
||||
// Set the min corresponding to cpi->avg_q * 0.5
|
||||
q = cpi->avg_q * 0.5;
|
||||
cpi->twopass.maxq_min_limit = cpi->best_quality;
|
||||
for (i = cpi->worst_quality; i >= cpi->best_quality; i--) {
|
||||
// Set the min corresponding to cpi->rc.avg_q * 0.5
|
||||
q = cpi->rc.avg_q * 0.5;
|
||||
cpi->twopass.maxq_min_limit = cpi->rc.best_quality;
|
||||
for (i = cpi->rc.worst_quality; i >= cpi->rc.best_quality; i--) {
|
||||
cpi->twopass.maxq_min_limit = i;
|
||||
if (vp9_convert_qindex_to_q(i) <= q)
|
||||
break;
|
||||
@ -1017,10 +1017,10 @@ static int estimate_max_q(VP9_COMP *cpi,
|
||||
|
||||
// Calculate a corrective factor based on a rolling ratio of bits spent
|
||||
// vs target bits
|
||||
if (cpi->rolling_target_bits > 0 &&
|
||||
cpi->active_worst_quality < cpi->worst_quality) {
|
||||
double rolling_ratio = (double)cpi->rolling_actual_bits /
|
||||
(double)cpi->rolling_target_bits;
|
||||
if (cpi->rc.rolling_target_bits > 0 &&
|
||||
cpi->rc.active_worst_quality < cpi->rc.worst_quality) {
|
||||
double rolling_ratio = (double)cpi->rc.rolling_actual_bits /
|
||||
(double)cpi->rc.rolling_target_bits;
|
||||
|
||||
if (rolling_ratio < 0.95)
|
||||
cpi->twopass.est_max_qcorrection_factor -= 0.005;
|
||||
@ -1066,8 +1066,8 @@ static int estimate_max_q(VP9_COMP *cpi,
|
||||
// average q observed in clip for non kf/gf/arf frames
|
||||
// Give average a chance to settle though.
|
||||
// PGW TODO.. This code is broken for the extended Q range
|
||||
if (cpi->ni_frames > ((int)cpi->twopass.total_stats.count >> 8) &&
|
||||
cpi->ni_frames > 25)
|
||||
if (cpi->rc.ni_frames > ((int)cpi->twopass.total_stats.count >> 8) &&
|
||||
cpi->rc.ni_frames > 25)
|
||||
adjust_maxq_qrange(cpi);
|
||||
|
||||
return q;
|
||||
@ -1146,10 +1146,10 @@ static int estimate_cq(VP9_COMP *cpi,
|
||||
|
||||
// Clip value to range "best allowed to (worst allowed - 1)"
|
||||
q = select_cq_level(q);
|
||||
if (q >= cpi->worst_quality)
|
||||
q = cpi->worst_quality - 1;
|
||||
if (q < cpi->best_quality)
|
||||
q = cpi->best_quality;
|
||||
if (q >= cpi->rc.worst_quality)
|
||||
q = cpi->rc.worst_quality - 1;
|
||||
if (q < cpi->rc.best_quality)
|
||||
q = cpi->rc.best_quality;
|
||||
|
||||
return q;
|
||||
}
|
||||
@ -1599,13 +1599,13 @@ void define_fixed_arf_period(VP9_COMP *cpi) {
|
||||
if (cpi->twopass.frames_to_key <= (FIXED_ARF_GROUP_SIZE + 8)) {
|
||||
// Setup a GF group close to the keyframe.
|
||||
cpi->source_alt_ref_pending = 0;
|
||||
cpi->baseline_gf_interval = cpi->twopass.frames_to_key;
|
||||
schedule_frames(cpi, 0, (cpi->baseline_gf_interval - 1), 2, 0, 0);
|
||||
cpi->rc.baseline_gf_interval = cpi->twopass.frames_to_key;
|
||||
schedule_frames(cpi, 0, (cpi->rc.baseline_gf_interval - 1), 2, 0, 0);
|
||||
} else {
|
||||
// Setup a fixed period ARF group.
|
||||
cpi->source_alt_ref_pending = 1;
|
||||
cpi->baseline_gf_interval = FIXED_ARF_GROUP_SIZE;
|
||||
schedule_frames(cpi, 0, -(cpi->baseline_gf_interval - 1), 2, 1, 0);
|
||||
cpi->rc.baseline_gf_interval = FIXED_ARF_GROUP_SIZE;
|
||||
schedule_frames(cpi, 0, -(cpi->rc.baseline_gf_interval - 1), 2, 1, 0);
|
||||
}
|
||||
|
||||
// Replace level indicator of -1 with correct level.
|
||||
@ -1702,10 +1702,10 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
// At high Q when there are few bits to spare we are better with a longer
|
||||
// interval to spread the cost of the GF.
|
||||
active_max_gf_interval =
|
||||
12 + ((int)vp9_convert_qindex_to_q(cpi->active_worst_quality) >> 5);
|
||||
12 + ((int)vp9_convert_qindex_to_q(cpi->rc.active_worst_quality) >> 5);
|
||||
|
||||
if (active_max_gf_interval > cpi->max_gf_interval)
|
||||
active_max_gf_interval = cpi->max_gf_interval;
|
||||
if (active_max_gf_interval > cpi->rc.max_gf_interval)
|
||||
active_max_gf_interval = cpi->rc.max_gf_interval;
|
||||
|
||||
i = 0;
|
||||
while (((i < cpi->twopass.static_scene_max_gf_interval) ||
|
||||
@ -1799,7 +1799,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
}
|
||||
|
||||
// Set the interval until the next gf or arf.
|
||||
cpi->baseline_gf_interval = i;
|
||||
cpi->rc.baseline_gf_interval = i;
|
||||
|
||||
#if CONFIG_MULTIPLE_ARF
|
||||
if (cpi->multi_arf_enabled) {
|
||||
@ -1825,24 +1825,25 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
(mv_in_out_accumulator > -2.0)) &&
|
||||
(boost_score > 100)) {
|
||||
// Alternative boost calculation for alt ref
|
||||
cpi->gfu_boost = calc_arf_boost(cpi, 0, (i - 1), (i - 1), &f_boost,
|
||||
cpi->rc.gfu_boost = calc_arf_boost(cpi, 0, (i - 1), (i - 1), &f_boost,
|
||||
&b_boost);
|
||||
cpi->source_alt_ref_pending = 1;
|
||||
|
||||
#if CONFIG_MULTIPLE_ARF
|
||||
// Set the ARF schedule.
|
||||
if (cpi->multi_arf_enabled) {
|
||||
schedule_frames(cpi, 0, -(cpi->baseline_gf_interval - 1), 2, 1, 0);
|
||||
schedule_frames(cpi, 0, -(cpi->rc.baseline_gf_interval - 1), 2, 1, 0);
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
cpi->gfu_boost = (int)boost_score;
|
||||
cpi->rc.gfu_boost = (int)boost_score;
|
||||
cpi->source_alt_ref_pending = 0;
|
||||
#if CONFIG_MULTIPLE_ARF
|
||||
// Set the GF schedule.
|
||||
if (cpi->multi_arf_enabled) {
|
||||
schedule_frames(cpi, 0, cpi->baseline_gf_interval - 1, 2, 0, 0);
|
||||
assert(cpi->new_frame_coding_order_period == cpi->baseline_gf_interval);
|
||||
schedule_frames(cpi, 0, cpi->rc.baseline_gf_interval - 1, 2, 0, 0);
|
||||
assert(cpi->new_frame_coding_order_period ==
|
||||
cpi->rc.baseline_gf_interval);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@ -1915,8 +1916,9 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
// Clip cpi->twopass.gf_group_bits based on user supplied data rate
|
||||
// variability limit (cpi->oxcf.two_pass_vbrmax_section)
|
||||
if (cpi->twopass.gf_group_bits >
|
||||
(int64_t)max_bits * cpi->baseline_gf_interval)
|
||||
cpi->twopass.gf_group_bits = (int64_t)max_bits * cpi->baseline_gf_interval;
|
||||
(int64_t)max_bits * cpi->rc.baseline_gf_interval)
|
||||
cpi->twopass.gf_group_bits =
|
||||
(int64_t)max_bits * cpi->rc.baseline_gf_interval;
|
||||
|
||||
// Reset the file position
|
||||
reset_fpf_position(cpi, start_pos);
|
||||
@ -1929,19 +1931,18 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
i <= (cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME);
|
||||
++i) {
|
||||
int allocation_chunks;
|
||||
int q = cpi->oxcf.fixed_q < 0 ? cpi->last_q[INTER_FRAME]
|
||||
: cpi->oxcf.fixed_q;
|
||||
int q = cpi->rc.last_q[INTER_FRAME];
|
||||
int gf_bits;
|
||||
|
||||
int boost = (cpi->gfu_boost * vp9_gfboost_qadjust(q)) / 100;
|
||||
int boost = (cpi->rc.gfu_boost * vp9_gfboost_qadjust(q)) / 100;
|
||||
|
||||
// Set max and minimum boost and hence minimum allocation
|
||||
boost = clamp(boost, 125, (cpi->baseline_gf_interval + 1) * 200);
|
||||
boost = clamp(boost, 125, (cpi->rc.baseline_gf_interval + 1) * 200);
|
||||
|
||||
if (cpi->source_alt_ref_pending && i == 0)
|
||||
allocation_chunks = ((cpi->baseline_gf_interval + 1) * 100) + boost;
|
||||
allocation_chunks = ((cpi->rc.baseline_gf_interval + 1) * 100) + boost;
|
||||
else
|
||||
allocation_chunks = (cpi->baseline_gf_interval * 100) + (boost - 100);
|
||||
allocation_chunks = (cpi->rc.baseline_gf_interval * 100) + (boost - 100);
|
||||
|
||||
// Prevent overflow
|
||||
if (boost > 1023) {
|
||||
@ -1958,10 +1959,10 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
// If the frame that is to be boosted is simpler than the average for
|
||||
// the gf/arf group then use an alternative calculation
|
||||
// based on the error score of the frame itself
|
||||
if (mod_frame_err < gf_group_err / (double)cpi->baseline_gf_interval) {
|
||||
if (mod_frame_err < gf_group_err / (double)cpi->rc.baseline_gf_interval) {
|
||||
double alt_gf_grp_bits =
|
||||
(double)cpi->twopass.kf_group_bits *
|
||||
(mod_frame_err * (double)cpi->baseline_gf_interval) /
|
||||
(mod_frame_err * (double)cpi->rc.baseline_gf_interval) /
|
||||
DOUBLE_DIVIDE_CHECK(cpi->twopass.kf_group_error_left);
|
||||
|
||||
int alt_gf_bits = (int)((double)boost * (alt_gf_grp_bits /
|
||||
@ -1986,7 +1987,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
gf_bits = 0;
|
||||
|
||||
// Add in minimum for a frame
|
||||
gf_bits += cpi->min_frame_bandwidth;
|
||||
gf_bits += cpi->rc.min_frame_bandwidth;
|
||||
|
||||
if (i == 0) {
|
||||
cpi->twopass.gf_bits = gf_bits;
|
||||
@ -1994,7 +1995,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
if (i == 1 || (!cpi->source_alt_ref_pending
|
||||
&& (cpi->common.frame_type != KEY_FRAME))) {
|
||||
// Per frame bit target for this frame
|
||||
cpi->per_frame_bandwidth = gf_bits;
|
||||
cpi->rc.per_frame_bandwidth = gf_bits;
|
||||
}
|
||||
}
|
||||
|
||||
@ -2017,7 +2018,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
cpi->twopass.gf_group_error_left = (int64_t)gf_group_err;
|
||||
|
||||
cpi->twopass.gf_group_bits -= cpi->twopass.gf_bits
|
||||
- cpi->min_frame_bandwidth;
|
||||
- cpi->rc.min_frame_bandwidth;
|
||||
|
||||
if (cpi->twopass.gf_group_bits < 0)
|
||||
cpi->twopass.gf_group_bits = 0;
|
||||
@ -2025,8 +2026,9 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
// This condition could fail if there are two kfs very close together
|
||||
// despite (MIN_GF_INTERVAL) and would cause a divide by 0 in the
|
||||
// calculation of alt_extra_bits.
|
||||
if (cpi->baseline_gf_interval >= 3) {
|
||||
const int boost = cpi->source_alt_ref_pending ? b_boost : cpi->gfu_boost;
|
||||
if (cpi->rc.baseline_gf_interval >= 3) {
|
||||
const int boost = cpi->source_alt_ref_pending ?
|
||||
b_boost : cpi->rc.gfu_boost;
|
||||
|
||||
if (boost >= 150) {
|
||||
int alt_extra_bits;
|
||||
@ -2045,7 +2047,7 @@ static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
zero_stats(§ionstats);
|
||||
reset_fpf_position(cpi, start_pos);
|
||||
|
||||
for (i = 0; i < cpi->baseline_gf_interval; i++) {
|
||||
for (i = 0; i < cpi->rc.baseline_gf_interval; i++) {
|
||||
input_stats(cpi, &next_frame);
|
||||
accumulate_stats(§ionstats, &next_frame);
|
||||
}
|
||||
@ -2102,10 +2104,10 @@ static void assign_std_frame_bits(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
cpi->twopass.gf_group_bits = 0;
|
||||
|
||||
// Add in the minimum number of bits that is set aside for every frame.
|
||||
target_frame_size += cpi->min_frame_bandwidth;
|
||||
target_frame_size += cpi->rc.min_frame_bandwidth;
|
||||
|
||||
// Per frame bit target for this frame.
|
||||
cpi->per_frame_bandwidth = target_frame_size;
|
||||
cpi->rc.per_frame_bandwidth = target_frame_size;
|
||||
}
|
||||
|
||||
// Make a damped adjustment to the active max q.
|
||||
@ -2145,7 +2147,7 @@ void vp9_second_pass(VP9_COMP *cpi) {
|
||||
vp9_clear_system_state();
|
||||
|
||||
if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
|
||||
cpi->active_worst_quality = cpi->oxcf.cq_level;
|
||||
cpi->rc.active_worst_quality = cpi->oxcf.cq_level;
|
||||
} else {
|
||||
// Special case code for first frame.
|
||||
if (cpi->common.current_video_frame == 0) {
|
||||
@ -2169,15 +2171,15 @@ void vp9_second_pass(VP9_COMP *cpi) {
|
||||
*/
|
||||
|
||||
// guess at maxq needed in 2nd pass
|
||||
cpi->twopass.maxq_max_limit = cpi->worst_quality;
|
||||
cpi->twopass.maxq_min_limit = cpi->best_quality;
|
||||
cpi->twopass.maxq_max_limit = cpi->rc.worst_quality;
|
||||
cpi->twopass.maxq_min_limit = cpi->rc.best_quality;
|
||||
|
||||
tmp_q = estimate_max_q(cpi, &cpi->twopass.total_left_stats,
|
||||
section_target_bandwidth);
|
||||
|
||||
cpi->active_worst_quality = tmp_q;
|
||||
cpi->ni_av_qi = tmp_q;
|
||||
cpi->avg_q = vp9_convert_qindex_to_q(tmp_q);
|
||||
cpi->rc.active_worst_quality = tmp_q;
|
||||
cpi->rc.ni_av_qi = tmp_q;
|
||||
cpi->rc.avg_q = vp9_convert_qindex_to_q(tmp_q);
|
||||
|
||||
// Limit the maxq value returned subsequently.
|
||||
// This increases the risk of overspend or underspend if the initial
|
||||
@ -2193,7 +2195,7 @@ void vp9_second_pass(VP9_COMP *cpi) {
|
||||
// few surplus bits or get beneath the target rate.
|
||||
else if ((cpi->common.current_video_frame <
|
||||
(((unsigned int)cpi->twopass.total_stats.count * 255) >> 8)) &&
|
||||
((cpi->common.current_video_frame + cpi->baseline_gf_interval) <
|
||||
((cpi->common.current_video_frame + cpi->rc.baseline_gf_interval) <
|
||||
(unsigned int)cpi->twopass.total_stats.count)) {
|
||||
int section_target_bandwidth =
|
||||
(int)(cpi->twopass.bits_left / frames_left);
|
||||
@ -2206,8 +2208,8 @@ void vp9_second_pass(VP9_COMP *cpi) {
|
||||
section_target_bandwidth);
|
||||
|
||||
// Make a damped adjustment to active max Q
|
||||
cpi->active_worst_quality =
|
||||
adjust_active_maxq(cpi->active_worst_quality, tmp_q);
|
||||
cpi->rc.active_worst_quality =
|
||||
adjust_active_maxq(cpi->rc.active_worst_quality, tmp_q);
|
||||
}
|
||||
}
|
||||
vp9_zero(this_frame);
|
||||
@ -2225,7 +2227,7 @@ void vp9_second_pass(VP9_COMP *cpi) {
|
||||
}
|
||||
|
||||
// Is this a GF / ARF (Note that a KF is always also a GF)
|
||||
if (cpi->frames_till_gf_update_due == 0) {
|
||||
if (cpi->rc.frames_till_gf_update_due == 0) {
|
||||
// Define next gf group and assign bits to it
|
||||
this_frame_copy = this_frame;
|
||||
|
||||
@ -2259,10 +2261,10 @@ void vp9_second_pass(VP9_COMP *cpi) {
|
||||
if (cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME)) {
|
||||
// Assign a standard frames worth of bits from those allocated
|
||||
// to the GF group
|
||||
int bak = cpi->per_frame_bandwidth;
|
||||
int bak = cpi->rc.per_frame_bandwidth;
|
||||
this_frame_copy = this_frame;
|
||||
assign_std_frame_bits(cpi, &this_frame_copy);
|
||||
cpi->per_frame_bandwidth = bak;
|
||||
cpi->rc.per_frame_bandwidth = bak;
|
||||
}
|
||||
} else {
|
||||
// Otherwise this is an ordinary frame
|
||||
@ -2283,7 +2285,7 @@ void vp9_second_pass(VP9_COMP *cpi) {
|
||||
}
|
||||
|
||||
// Set nominal per second bandwidth for this frame
|
||||
cpi->target_bandwidth = (int)(cpi->per_frame_bandwidth
|
||||
cpi->target_bandwidth = (int)(cpi->rc.per_frame_bandwidth
|
||||
* cpi->output_framerate);
|
||||
if (cpi->target_bandwidth < 0)
|
||||
cpi->target_bandwidth = 0;
|
||||
@ -2416,7 +2418,7 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
cpi->source_alt_ref_active = 0;
|
||||
|
||||
// Kf is always a gf so clear frames till next gf counter
|
||||
cpi->frames_till_gf_update_due = 0;
|
||||
cpi->rc.frames_till_gf_update_due = 0;
|
||||
|
||||
cpi->twopass.frames_to_key = 1;
|
||||
|
||||
@ -2579,7 +2581,7 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
}
|
||||
|
||||
// For the first few frames collect data to decide kf boost.
|
||||
if (i <= (cpi->max_gf_interval * 2)) {
|
||||
if (i <= (cpi->rc.max_gf_interval * 2)) {
|
||||
if (next_frame.intra_error > cpi->twopass.kf_intra_err_min)
|
||||
r = (IIKFACTOR2 * next_frame.intra_error /
|
||||
DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
|
||||
@ -2637,7 +2639,7 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
|
||||
// Make a note of baseline boost and the zero motion
|
||||
// accumulator value for use elsewhere.
|
||||
cpi->kf_boost = kf_boost;
|
||||
cpi->rc.kf_boost = kf_boost;
|
||||
cpi->kf_zeromotion_pct = (int)(zero_motion_accumulator * 100.0);
|
||||
|
||||
// We do three calculations for kf size.
|
||||
@ -2707,10 +2709,10 @@ static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
|
||||
|
||||
cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits;
|
||||
// Add in the minimum frame allowance
|
||||
cpi->twopass.kf_bits += cpi->min_frame_bandwidth;
|
||||
cpi->twopass.kf_bits += cpi->rc.min_frame_bandwidth;
|
||||
|
||||
// Peer frame bit target for this frame
|
||||
cpi->per_frame_bandwidth = cpi->twopass.kf_bits;
|
||||
cpi->rc.per_frame_bandwidth = cpi->twopass.kf_bits;
|
||||
// Convert to a per second bitrate
|
||||
cpi->target_bandwidth = (int)(cpi->twopass.kf_bits *
|
||||
cpi->output_framerate);
|
||||
|
@ -323,8 +323,8 @@ static void separate_arf_mbs(VP9_COMP *cpi) {
|
||||
1));
|
||||
|
||||
// We are not interested in results beyond the alt ref itself.
|
||||
if (n_frames > cpi->frames_till_gf_update_due)
|
||||
n_frames = cpi->frames_till_gf_update_due;
|
||||
if (n_frames > cpi->rc.frames_till_gf_update_due)
|
||||
n_frames = cpi->rc.frames_till_gf_update_due;
|
||||
|
||||
// defer cost to reference frames
|
||||
for (i = n_frames - 1; i >= 0; i--) {
|
||||
@ -396,7 +396,7 @@ void vp9_update_mbgraph_stats(VP9_COMP *cpi) {
|
||||
|
||||
// we need to look ahead beyond where the ARF transitions into
|
||||
// being a GF - so exit if we don't look ahead beyond that
|
||||
if (n_frames <= cpi->frames_till_gf_update_due)
|
||||
if (n_frames <= cpi->rc.frames_till_gf_update_due)
|
||||
return;
|
||||
if (n_frames > (int)cpi->frames_till_alt_ref_frame)
|
||||
n_frames = cpi->frames_till_alt_ref_frame;
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -289,6 +289,59 @@ typedef struct {
|
||||
int use_fast_coef_updates; // 0: 2-loop, 1: 1-loop, 2: 1-loop reduced
|
||||
} SPEED_FEATURES;
|
||||
|
||||
typedef struct {
|
||||
// Rate targetting variables
|
||||
int this_frame_target;
|
||||
int projected_frame_size;
|
||||
int last_q[2]; // Separate values for Intra/Inter
|
||||
int last_boosted_qindex; // Last boosted GF/KF/ARF q
|
||||
|
||||
int gfu_boost;
|
||||
int last_boost;
|
||||
int kf_boost;
|
||||
|
||||
double rate_correction_factor;
|
||||
double key_frame_rate_correction_factor;
|
||||
double gf_rate_correction_factor;
|
||||
|
||||
unsigned int frames_since_golden;
|
||||
int frames_till_gf_update_due; // Count down till next GF
|
||||
|
||||
int max_gf_interval;
|
||||
int baseline_gf_interval;
|
||||
|
||||
int64_t key_frame_count;
|
||||
int prior_key_frame_distance[KEY_FRAME_CONTEXT];
|
||||
int per_frame_bandwidth; // Current section per frame bandwidth target
|
||||
int av_per_frame_bandwidth; // Average frame size target for clip
|
||||
int min_frame_bandwidth; // Minimum allocation used for any frame
|
||||
|
||||
int ni_av_qi;
|
||||
int ni_tot_qi;
|
||||
int ni_frames;
|
||||
int avg_frame_qindex;
|
||||
double tot_q;
|
||||
double avg_q;
|
||||
|
||||
int buffer_level;
|
||||
int bits_off_target;
|
||||
|
||||
int rolling_target_bits;
|
||||
int rolling_actual_bits;
|
||||
|
||||
int long_rolling_target_bits;
|
||||
int long_rolling_actual_bits;
|
||||
|
||||
int64_t total_actual_bits;
|
||||
int total_target_vs_actual; // debug stats
|
||||
|
||||
int worst_quality;
|
||||
int active_worst_quality;
|
||||
int best_quality;
|
||||
int active_best_quality;
|
||||
int active_worst_qchanged;
|
||||
} RATE_CONTROL;
|
||||
|
||||
typedef struct VP9_COMP {
|
||||
DECLARE_ALIGNED(16, int16_t, y_quant[QINDEX_RANGE][8]);
|
||||
DECLARE_ALIGNED(16, int16_t, y_quant_shift[QINDEX_RANGE][8]);
|
||||
@ -398,71 +451,17 @@ typedef struct VP9_COMP {
|
||||
|
||||
CODING_CONTEXT coding_context;
|
||||
|
||||
// Rate targetting variables
|
||||
int this_frame_target;
|
||||
int projected_frame_size;
|
||||
int last_q[2]; // Separate values for Intra/Inter
|
||||
int last_boosted_qindex; // Last boosted GF/KF/ARF q
|
||||
|
||||
double rate_correction_factor;
|
||||
double key_frame_rate_correction_factor;
|
||||
double gf_rate_correction_factor;
|
||||
|
||||
unsigned int frames_since_golden;
|
||||
int frames_till_gf_update_due; // Count down till next GF
|
||||
|
||||
int gf_overspend_bits; // cumulative bits overspent because of GF boost
|
||||
|
||||
int non_gf_bitrate_adjustment; // Following GF to recover extra bits spent
|
||||
|
||||
int kf_overspend_bits; // Bits spent on key frames to be recovered on inters
|
||||
int kf_bitrate_adjustment; // number of bits to recover on each inter frame.
|
||||
int max_gf_interval;
|
||||
int baseline_gf_interval;
|
||||
int zbin_mode_boost;
|
||||
int zbin_mode_boost_enabled;
|
||||
int active_arnr_frames; // <= cpi->oxcf.arnr_max_frames
|
||||
int active_arnr_strength; // <= cpi->oxcf.arnr_max_strength
|
||||
|
||||
int64_t key_frame_count;
|
||||
int prior_key_frame_distance[KEY_FRAME_CONTEXT];
|
||||
int per_frame_bandwidth; // Current section per frame bandwidth target
|
||||
int av_per_frame_bandwidth; // Average frame size target for clip
|
||||
int min_frame_bandwidth; // Minimum allocation used for any frame
|
||||
int inter_frame_target;
|
||||
double output_framerate;
|
||||
int64_t last_time_stamp_seen;
|
||||
int64_t last_end_time_stamp_seen;
|
||||
int64_t first_time_stamp_ever;
|
||||
|
||||
int ni_av_qi;
|
||||
int ni_tot_qi;
|
||||
int ni_frames;
|
||||
int avg_frame_qindex;
|
||||
double tot_q;
|
||||
double avg_q;
|
||||
|
||||
int zbin_mode_boost;
|
||||
int zbin_mode_boost_enabled;
|
||||
|
||||
int64_t total_byte_count;
|
||||
|
||||
int buffered_mode;
|
||||
|
||||
int buffer_level;
|
||||
int bits_off_target;
|
||||
|
||||
int rolling_target_bits;
|
||||
int rolling_actual_bits;
|
||||
|
||||
int long_rolling_target_bits;
|
||||
int long_rolling_actual_bits;
|
||||
|
||||
int64_t total_actual_bits;
|
||||
int total_target_vs_actual; // debug stats
|
||||
|
||||
int worst_quality;
|
||||
int active_worst_quality;
|
||||
int best_quality;
|
||||
int active_best_quality;
|
||||
RATE_CONTROL rc;
|
||||
|
||||
int cq_target_quality;
|
||||
|
||||
@ -476,9 +475,6 @@ typedef struct VP9_COMP {
|
||||
vp9_coeff_probs_model frame_coef_probs[TX_SIZES][BLOCK_TYPES];
|
||||
vp9_coeff_stats frame_branch_ct[TX_SIZES][BLOCK_TYPES];
|
||||
|
||||
int gfu_boost;
|
||||
int last_boost;
|
||||
int kf_boost;
|
||||
int kf_zeromotion_pct;
|
||||
int gf_zeromotion_pct;
|
||||
|
||||
@ -502,7 +498,6 @@ typedef struct VP9_COMP {
|
||||
int speed;
|
||||
int compressor_speed;
|
||||
|
||||
int auto_worst_q;
|
||||
int cpu_used;
|
||||
int pass;
|
||||
|
||||
|
@ -35,6 +35,84 @@
|
||||
static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] =
|
||||
{ 1, 2, 3, 4, 5 };
|
||||
|
||||
// Tables relating active max Q to active min Q
|
||||
static int kf_low_motion_minq[QINDEX_RANGE];
|
||||
static int kf_high_motion_minq[QINDEX_RANGE];
|
||||
static int gf_low_motion_minq[QINDEX_RANGE];
|
||||
static int gf_high_motion_minq[QINDEX_RANGE];
|
||||
static int inter_minq[QINDEX_RANGE];
|
||||
static int afq_low_motion_minq[QINDEX_RANGE];
|
||||
static int afq_high_motion_minq[QINDEX_RANGE];
|
||||
|
||||
// Functions to compute the active minq lookup table entries based on a
|
||||
// formulaic approach to facilitate easier adjustment of the Q tables.
|
||||
// The formulae were derived from computing a 3rd order polynomial best
|
||||
// fit to the original data (after plotting real maxq vs minq (not q index))
|
||||
static int calculate_minq_index(double maxq,
|
||||
double x3, double x2, double x1, double c) {
|
||||
int i;
|
||||
const double minqtarget = MIN(((x3 * maxq + x2) * maxq + x1) * maxq + c,
|
||||
maxq);
|
||||
|
||||
// Special case handling to deal with the step from q2.0
|
||||
// down to lossless mode represented by q 1.0.
|
||||
if (minqtarget <= 2.0)
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < QINDEX_RANGE; i++) {
|
||||
if (minqtarget <= vp9_convert_qindex_to_q(i))
|
||||
return i;
|
||||
}
|
||||
|
||||
return QINDEX_RANGE - 1;
|
||||
}
|
||||
|
||||
void vp9_init_minq_luts(void) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < QINDEX_RANGE; i++) {
|
||||
const double maxq = vp9_convert_qindex_to_q(i);
|
||||
|
||||
|
||||
kf_low_motion_minq[i] = calculate_minq_index(maxq,
|
||||
0.000001,
|
||||
-0.0004,
|
||||
0.15,
|
||||
0.0);
|
||||
kf_high_motion_minq[i] = calculate_minq_index(maxq,
|
||||
0.000002,
|
||||
-0.0012,
|
||||
0.5,
|
||||
0.0);
|
||||
|
||||
gf_low_motion_minq[i] = calculate_minq_index(maxq,
|
||||
0.0000015,
|
||||
-0.0009,
|
||||
0.32,
|
||||
0.0);
|
||||
gf_high_motion_minq[i] = calculate_minq_index(maxq,
|
||||
0.0000021,
|
||||
-0.00125,
|
||||
0.50,
|
||||
0.0);
|
||||
inter_minq[i] = calculate_minq_index(maxq,
|
||||
0.00000271,
|
||||
-0.00113,
|
||||
0.75,
|
||||
0.0);
|
||||
afq_low_motion_minq[i] = calculate_minq_index(maxq,
|
||||
0.0000015,
|
||||
-0.0009,
|
||||
0.33,
|
||||
0.0);
|
||||
afq_high_motion_minq[i] = calculate_minq_index(maxq,
|
||||
0.0000021,
|
||||
-0.00125,
|
||||
0.55,
|
||||
0.0);
|
||||
}
|
||||
}
|
||||
|
||||
// These functions use formulaic calculations to make playing with the
|
||||
// quantizer tables easier. If necessary they can be replaced by lookup
|
||||
// tables if and when things settle down in the experimental bitstream
|
||||
@ -118,7 +196,7 @@ void vp9_setup_key_frame(VP9_COMP *cpi) {
|
||||
vp9_setup_past_independence(cm);
|
||||
|
||||
// interval before next GF
|
||||
cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
|
||||
cpi->rc.frames_till_gf_update_due = cpi->rc.baseline_gf_interval;
|
||||
/* All buffers are implicitly updated on key frames. */
|
||||
cpi->refresh_golden_frame = 1;
|
||||
cpi->refresh_alt_ref_frame = 1;
|
||||
@ -153,17 +231,17 @@ static void calc_iframe_target_size(VP9_COMP *cpi) {
|
||||
vp9_clear_system_state(); // __asm emms;
|
||||
|
||||
// New Two pass RC
|
||||
target = cpi->per_frame_bandwidth;
|
||||
target = cpi->rc.per_frame_bandwidth;
|
||||
|
||||
if (cpi->oxcf.rc_max_intra_bitrate_pct) {
|
||||
int max_rate = cpi->per_frame_bandwidth
|
||||
int max_rate = cpi->rc.per_frame_bandwidth
|
||||
* cpi->oxcf.rc_max_intra_bitrate_pct / 100;
|
||||
|
||||
if (target > max_rate)
|
||||
target = max_rate;
|
||||
}
|
||||
|
||||
cpi->this_frame_target = target;
|
||||
cpi->rc.this_frame_target = target;
|
||||
}
|
||||
|
||||
|
||||
@ -174,21 +252,21 @@ static void calc_iframe_target_size(VP9_COMP *cpi) {
|
||||
// so we just use the interval determined in the two pass code.
|
||||
static void calc_gf_params(VP9_COMP *cpi) {
|
||||
// Set the gf interval
|
||||
cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
|
||||
cpi->rc.frames_till_gf_update_due = cpi->rc.baseline_gf_interval;
|
||||
}
|
||||
|
||||
|
||||
static void calc_pframe_target_size(VP9_COMP *cpi) {
|
||||
const int min_frame_target = MAX(cpi->min_frame_bandwidth,
|
||||
cpi->av_per_frame_bandwidth >> 5);
|
||||
const int min_frame_target = MAX(cpi->rc.min_frame_bandwidth,
|
||||
cpi->rc.av_per_frame_bandwidth >> 5);
|
||||
if (cpi->refresh_alt_ref_frame) {
|
||||
// Special alt reference frame case
|
||||
// Per frame bit target for the alt ref frame
|
||||
cpi->per_frame_bandwidth = cpi->twopass.gf_bits;
|
||||
cpi->this_frame_target = cpi->per_frame_bandwidth;
|
||||
cpi->rc.per_frame_bandwidth = cpi->twopass.gf_bits;
|
||||
cpi->rc.this_frame_target = cpi->rc.per_frame_bandwidth;
|
||||
} else {
|
||||
// Normal frames (gf,and inter)
|
||||
cpi->this_frame_target = cpi->per_frame_bandwidth;
|
||||
cpi->rc.this_frame_target = cpi->rc.per_frame_bandwidth;
|
||||
}
|
||||
|
||||
// Check that the total sum of adjustments is not above the maximum allowed.
|
||||
@ -197,41 +275,26 @@ static void calc_pframe_target_size(VP9_COMP *cpi) {
|
||||
// not capable of recovering all the extra bits we have spent in the KF or GF,
|
||||
// then the remainder will have to be recovered over a longer time span via
|
||||
// other buffer / rate control mechanisms.
|
||||
if (cpi->this_frame_target < min_frame_target)
|
||||
cpi->this_frame_target = min_frame_target;
|
||||
|
||||
if (!cpi->refresh_alt_ref_frame)
|
||||
// Note the baseline target data rate for this inter frame.
|
||||
cpi->inter_frame_target = cpi->this_frame_target;
|
||||
if (cpi->rc.this_frame_target < min_frame_target)
|
||||
cpi->rc.this_frame_target = min_frame_target;
|
||||
|
||||
// Adjust target frame size for Golden Frames:
|
||||
if (cpi->frames_till_gf_update_due == 0) {
|
||||
const int q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME]
|
||||
: cpi->oxcf.fixed_q;
|
||||
|
||||
if (cpi->rc.frames_till_gf_update_due == 0) {
|
||||
cpi->refresh_golden_frame = 1;
|
||||
|
||||
calc_gf_params(cpi);
|
||||
|
||||
// If we are using alternate ref instead of gf then do not apply the boost
|
||||
// It will instead be applied to the altref update
|
||||
// Jims modified boost
|
||||
if (!cpi->source_alt_ref_active) {
|
||||
if (cpi->oxcf.fixed_q < 0) {
|
||||
// The spend on the GF is defined in the two pass code
|
||||
// for two pass encodes
|
||||
cpi->this_frame_target = cpi->per_frame_bandwidth;
|
||||
} else {
|
||||
cpi->this_frame_target =
|
||||
(estimate_bits_at_q(1, q, cpi->common.MBs, 1.0)
|
||||
* cpi->last_boost) / 100;
|
||||
}
|
||||
// The spend on the GF is defined in the two pass code
|
||||
// for two pass encodes
|
||||
cpi->rc.this_frame_target = cpi->rc.per_frame_bandwidth;
|
||||
} else {
|
||||
// If there is an active ARF at this location use the minimum
|
||||
// bits on this frame even if it is a constructed arf.
|
||||
// The active maximum quantizer insures that an appropriate
|
||||
// number of bits will be spent if needed for constructed ARFs.
|
||||
cpi->this_frame_target = 0;
|
||||
cpi->rc.this_frame_target = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -249,12 +312,12 @@ void vp9_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) {
|
||||
vp9_clear_system_state(); // __asm emms;
|
||||
|
||||
if (cpi->common.frame_type == KEY_FRAME) {
|
||||
rate_correction_factor = cpi->key_frame_rate_correction_factor;
|
||||
rate_correction_factor = cpi->rc.key_frame_rate_correction_factor;
|
||||
} else {
|
||||
if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
|
||||
rate_correction_factor = cpi->gf_rate_correction_factor;
|
||||
rate_correction_factor = cpi->rc.gf_rate_correction_factor;
|
||||
else
|
||||
rate_correction_factor = cpi->rate_correction_factor;
|
||||
rate_correction_factor = cpi->rc.rate_correction_factor;
|
||||
}
|
||||
|
||||
// Work out how big we would have expected the frame to be at this Q given
|
||||
@ -267,7 +330,7 @@ void vp9_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) {
|
||||
// Work out a size correction factor.
|
||||
if (projected_size_based_on_q > 0)
|
||||
correction_factor =
|
||||
(100 * cpi->projected_frame_size) / projected_size_based_on_q;
|
||||
(100 * cpi->rc.projected_frame_size) / projected_size_based_on_q;
|
||||
|
||||
// More heavily damped adjustment used if we have been oscillating either side
|
||||
// of target.
|
||||
@ -284,7 +347,7 @@ void vp9_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) {
|
||||
break;
|
||||
}
|
||||
|
||||
// if ( (correction_factor > 102) && (Q < cpi->active_worst_quality) )
|
||||
// if ( (correction_factor > 102) && (Q < cpi->rc.active_worst_quality) )
|
||||
if (correction_factor > 102) {
|
||||
// We are not already at the worst allowable quality
|
||||
correction_factor =
|
||||
@ -308,18 +371,18 @@ void vp9_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) {
|
||||
}
|
||||
|
||||
if (cpi->common.frame_type == KEY_FRAME) {
|
||||
cpi->key_frame_rate_correction_factor = rate_correction_factor;
|
||||
cpi->rc.key_frame_rate_correction_factor = rate_correction_factor;
|
||||
} else {
|
||||
if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
|
||||
cpi->gf_rate_correction_factor = rate_correction_factor;
|
||||
cpi->rc.gf_rate_correction_factor = rate_correction_factor;
|
||||
else
|
||||
cpi->rate_correction_factor = rate_correction_factor;
|
||||
cpi->rc.rate_correction_factor = rate_correction_factor;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int vp9_regulate_q(VP9_COMP *cpi, int target_bits_per_frame) {
|
||||
int q = cpi->active_worst_quality;
|
||||
int q = cpi->rc.active_worst_quality;
|
||||
|
||||
int i;
|
||||
int last_error = INT_MAX;
|
||||
@ -329,12 +392,12 @@ int vp9_regulate_q(VP9_COMP *cpi, int target_bits_per_frame) {
|
||||
|
||||
// Select the appropriate correction factor based upon type of frame.
|
||||
if (cpi->common.frame_type == KEY_FRAME) {
|
||||
correction_factor = cpi->key_frame_rate_correction_factor;
|
||||
correction_factor = cpi->rc.key_frame_rate_correction_factor;
|
||||
} else {
|
||||
if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame)
|
||||
correction_factor = cpi->gf_rate_correction_factor;
|
||||
correction_factor = cpi->rc.gf_rate_correction_factor;
|
||||
else
|
||||
correction_factor = cpi->rate_correction_factor;
|
||||
correction_factor = cpi->rc.rate_correction_factor;
|
||||
}
|
||||
|
||||
// Calculate required scaling factor based on target frame size and size of
|
||||
@ -347,7 +410,7 @@ int vp9_regulate_q(VP9_COMP *cpi, int target_bits_per_frame) {
|
||||
target_bits_per_mb =
|
||||
(target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs;
|
||||
|
||||
i = cpi->active_best_quality;
|
||||
i = cpi->rc.active_best_quality;
|
||||
|
||||
do {
|
||||
bits_per_mb_at_this_q = (int)vp9_bits_per_mb(cpi->common.frame_type, i,
|
||||
@ -363,7 +426,214 @@ int vp9_regulate_q(VP9_COMP *cpi, int target_bits_per_frame) {
|
||||
} else {
|
||||
last_error = bits_per_mb_at_this_q - target_bits_per_mb;
|
||||
}
|
||||
} while (++i <= cpi->active_worst_quality);
|
||||
} while (++i <= cpi->rc.active_worst_quality);
|
||||
|
||||
return q;
|
||||
}
|
||||
|
||||
static int get_active_quality(int q,
|
||||
int gfu_boost,
|
||||
int low,
|
||||
int high,
|
||||
int *low_motion_minq,
|
||||
int *high_motion_minq) {
|
||||
int active_best_quality;
|
||||
if (gfu_boost > high) {
|
||||
active_best_quality = low_motion_minq[q];
|
||||
} else if (gfu_boost < low) {
|
||||
active_best_quality = high_motion_minq[q];
|
||||
} else {
|
||||
const int gap = high - low;
|
||||
const int offset = high - gfu_boost;
|
||||
const int qdiff = high_motion_minq[q] - low_motion_minq[q];
|
||||
const int adjustment = ((offset * qdiff) + (gap >> 1)) / gap;
|
||||
active_best_quality = low_motion_minq[q] + adjustment;
|
||||
}
|
||||
return active_best_quality;
|
||||
}
|
||||
|
||||
int vp9_pick_q_and_adjust_q_bounds(VP9_COMP *cpi,
|
||||
int * bottom_index, int * top_index) {
|
||||
// Set an active best quality and if necessary active worst quality
|
||||
int q = cpi->rc.active_worst_quality;
|
||||
VP9_COMMON *const cm = &cpi->common;
|
||||
|
||||
if (frame_is_intra_only(cm)) {
|
||||
#if !CONFIG_MULTIPLE_ARF
|
||||
// Handle the special case for key frames forced when we have75 reached
|
||||
// the maximum key frame interval. Here force the Q to a range
|
||||
// based on the ambient Q to reduce the risk of popping.
|
||||
if (cpi->this_key_frame_forced) {
|
||||
int delta_qindex;
|
||||
int qindex = cpi->rc.last_boosted_qindex;
|
||||
double last_boosted_q = vp9_convert_qindex_to_q(qindex);
|
||||
|
||||
delta_qindex = vp9_compute_qdelta(cpi, last_boosted_q,
|
||||
(last_boosted_q * 0.75));
|
||||
|
||||
cpi->rc.active_best_quality = MAX(qindex + delta_qindex,
|
||||
cpi->rc.best_quality);
|
||||
} else {
|
||||
int high = 5000;
|
||||
int low = 400;
|
||||
double q_adj_factor = 1.0;
|
||||
double q_val;
|
||||
|
||||
// Baseline value derived from cpi->active_worst_quality and kf boost
|
||||
cpi->rc.active_best_quality = get_active_quality(q, cpi->rc.kf_boost,
|
||||
low, high,
|
||||
kf_low_motion_minq,
|
||||
kf_high_motion_minq);
|
||||
|
||||
// Allow somewhat lower kf minq with small image formats.
|
||||
if ((cm->width * cm->height) <= (352 * 288)) {
|
||||
q_adj_factor -= 0.25;
|
||||
}
|
||||
|
||||
// Make a further adjustment based on the kf zero motion measure.
|
||||
q_adj_factor += 0.05 - (0.001 * (double)cpi->kf_zeromotion_pct);
|
||||
|
||||
// Convert the adjustment factor to a qindex delta
|
||||
// on active_best_quality.
|
||||
q_val = vp9_convert_qindex_to_q(cpi->rc.active_best_quality);
|
||||
cpi->rc.active_best_quality +=
|
||||
vp9_compute_qdelta(cpi, q_val, (q_val * q_adj_factor));
|
||||
}
|
||||
#else
|
||||
double current_q;
|
||||
// Force the KF quantizer to be 30% of the active_worst_quality.
|
||||
current_q = vp9_convert_qindex_to_q(cpi->rc.active_worst_quality);
|
||||
cpi->rc.active_best_quality = cpi->rc.active_worst_quality
|
||||
+ vp9_compute_qdelta(cpi, current_q, current_q * 0.3);
|
||||
#endif
|
||||
} else if (!cpi->is_src_frame_alt_ref &&
|
||||
(cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
|
||||
int high = 2000;
|
||||
int low = 400;
|
||||
|
||||
// Use the lower of cpi->rc.active_worst_quality and recent
|
||||
// average Q as basis for GF/ARF best Q limit unless last frame was
|
||||
// a key frame.
|
||||
if (cpi->frames_since_key > 1 &&
|
||||
cpi->rc.avg_frame_qindex < cpi->rc.active_worst_quality) {
|
||||
q = cpi->rc.avg_frame_qindex;
|
||||
}
|
||||
// For constrained quality dont allow Q less than the cq level
|
||||
if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
|
||||
if (q < cpi->cq_target_quality)
|
||||
q = cpi->cq_target_quality;
|
||||
if (cpi->frames_since_key > 1) {
|
||||
cpi->rc.active_best_quality = get_active_quality(q, cpi->rc.gfu_boost,
|
||||
low, high,
|
||||
afq_low_motion_minq,
|
||||
afq_high_motion_minq);
|
||||
} else {
|
||||
cpi->rc.active_best_quality = get_active_quality(q, cpi->rc.gfu_boost,
|
||||
low, high,
|
||||
gf_low_motion_minq,
|
||||
gf_high_motion_minq);
|
||||
}
|
||||
// Constrained quality use slightly lower active best.
|
||||
cpi->rc.active_best_quality = cpi->rc.active_best_quality * 15 / 16;
|
||||
|
||||
} else if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
|
||||
if (!cpi->refresh_alt_ref_frame) {
|
||||
cpi->rc.active_best_quality = cpi->cq_target_quality;
|
||||
} else {
|
||||
if (cpi->frames_since_key > 1) {
|
||||
cpi->rc.active_best_quality = get_active_quality(q, cpi->rc.gfu_boost,
|
||||
low, high,
|
||||
afq_low_motion_minq,
|
||||
afq_high_motion_minq);
|
||||
} else {
|
||||
cpi->rc.active_best_quality = get_active_quality(q, cpi->rc.gfu_boost,
|
||||
low, high,
|
||||
gf_low_motion_minq,
|
||||
gf_high_motion_minq);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
cpi->rc.active_best_quality = get_active_quality(q, cpi->rc.gfu_boost,
|
||||
low, high,
|
||||
gf_low_motion_minq,
|
||||
gf_high_motion_minq);
|
||||
}
|
||||
} else {
|
||||
if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
|
||||
cpi->rc.active_best_quality = cpi->cq_target_quality;
|
||||
} else {
|
||||
cpi->rc.active_best_quality = inter_minq[q];
|
||||
// 1-pass: for now, use the average Q for the active_best, if its lower
|
||||
// than active_worst.
|
||||
if (cpi->pass == 0 && (cpi->rc.avg_frame_qindex < q))
|
||||
cpi->rc.active_best_quality = inter_minq[cpi->rc.avg_frame_qindex];
|
||||
|
||||
// For the constrained quality mode we don't want
|
||||
// q to fall below the cq level.
|
||||
if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
|
||||
(cpi->rc.active_best_quality < cpi->cq_target_quality)) {
|
||||
// If we are strongly undershooting the target rate in the last
|
||||
// frames then use the user passed in cq value not the auto
|
||||
// cq value.
|
||||
if (cpi->rc.rolling_actual_bits < cpi->rc.min_frame_bandwidth)
|
||||
cpi->rc.active_best_quality = cpi->oxcf.cq_level;
|
||||
else
|
||||
cpi->rc.active_best_quality = cpi->cq_target_quality;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Clip the active best and worst quality values to limits
|
||||
if (cpi->rc.active_worst_quality > cpi->rc.worst_quality)
|
||||
cpi->rc.active_worst_quality = cpi->rc.worst_quality;
|
||||
|
||||
if (cpi->rc.active_best_quality < cpi->rc.best_quality)
|
||||
cpi->rc.active_best_quality = cpi->rc.best_quality;
|
||||
|
||||
if (cpi->rc.active_best_quality > cpi->rc.worst_quality)
|
||||
cpi->rc.active_best_quality = cpi->rc.worst_quality;
|
||||
|
||||
if (cpi->rc.active_worst_quality < cpi->rc.active_best_quality)
|
||||
cpi->rc.active_worst_quality = cpi->rc.active_best_quality;
|
||||
|
||||
// Limit Q range for the adaptive loop.
|
||||
if (cm->frame_type == KEY_FRAME && !cpi->this_key_frame_forced) {
|
||||
*top_index =
|
||||
(cpi->rc.active_worst_quality + cpi->rc.active_best_quality * 3) / 4;
|
||||
// If this is the first (key) frame in 1-pass, active best is the user
|
||||
// best-allowed, and leave the top_index to active_worst.
|
||||
if (cpi->pass == 0 && cpi->common.current_video_frame == 0) {
|
||||
cpi->rc.active_best_quality = cpi->oxcf.best_allowed_q;
|
||||
*top_index = cpi->oxcf.worst_allowed_q;
|
||||
}
|
||||
} else if (!cpi->is_src_frame_alt_ref &&
|
||||
(cpi->oxcf.end_usage != USAGE_STREAM_FROM_SERVER) &&
|
||||
(cpi->refresh_golden_frame || cpi->refresh_alt_ref_frame)) {
|
||||
*top_index =
|
||||
(cpi->rc.active_worst_quality + cpi->rc.active_best_quality) / 2;
|
||||
} else {
|
||||
*top_index = cpi->rc.active_worst_quality;
|
||||
}
|
||||
*bottom_index = cpi->rc.active_best_quality;
|
||||
|
||||
if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
|
||||
q = cpi->rc.active_best_quality;
|
||||
// Special case code to try and match quality with forced key frames
|
||||
} else if ((cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced) {
|
||||
q = cpi->rc.last_boosted_qindex;
|
||||
} else {
|
||||
// Determine initial Q to try.
|
||||
if (cpi->pass == 0) {
|
||||
// 1-pass: for now, use per-frame-bw for target size of frame, scaled
|
||||
// by |x| for key frame.
|
||||
int scale = (cm->frame_type == KEY_FRAME) ? 5 : 1;
|
||||
q = vp9_regulate_q(cpi, scale * cpi->rc.av_per_frame_bandwidth);
|
||||
} else {
|
||||
q = vp9_regulate_q(cpi, cpi->rc.this_frame_target);
|
||||
}
|
||||
if (q > *top_index)
|
||||
q = *top_index;
|
||||
}
|
||||
|
||||
return q;
|
||||
}
|
||||
@ -378,7 +648,7 @@ static int estimate_keyframe_frequency(VP9_COMP *cpi) {
|
||||
/* First key frame at start of sequence is a special case. We have no
|
||||
* frequency data.
|
||||
*/
|
||||
if (cpi->key_frame_count == 1) {
|
||||
if (cpi->rc.key_frame_count == 1) {
|
||||
/* Assume a default of 1 kf every 2 seconds, or the max kf interval,
|
||||
* whichever is smaller.
|
||||
*/
|
||||
@ -388,7 +658,7 @@ static int estimate_keyframe_frequency(VP9_COMP *cpi) {
|
||||
if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq)
|
||||
av_key_frame_frequency = cpi->oxcf.key_freq;
|
||||
|
||||
cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
|
||||
cpi->rc.prior_key_frame_distance[KEY_FRAME_CONTEXT - 1]
|
||||
= av_key_frame_frequency;
|
||||
} else {
|
||||
unsigned int total_weight = 0;
|
||||
@ -400,13 +670,13 @@ static int estimate_keyframe_frequency(VP9_COMP *cpi) {
|
||||
*/
|
||||
for (i = 0; i < KEY_FRAME_CONTEXT; i++) {
|
||||
if (i < KEY_FRAME_CONTEXT - 1)
|
||||
cpi->prior_key_frame_distance[i]
|
||||
= cpi->prior_key_frame_distance[i + 1];
|
||||
cpi->rc.prior_key_frame_distance[i]
|
||||
= cpi->rc.prior_key_frame_distance[i + 1];
|
||||
else
|
||||
cpi->prior_key_frame_distance[i] = last_kf_interval;
|
||||
cpi->rc.prior_key_frame_distance[i] = last_kf_interval;
|
||||
|
||||
av_key_frame_frequency += prior_key_frame_weight[i]
|
||||
* cpi->prior_key_frame_distance[i];
|
||||
* cpi->rc.prior_key_frame_distance[i];
|
||||
total_weight += prior_key_frame_weight[i];
|
||||
}
|
||||
|
||||
@ -421,33 +691,32 @@ void vp9_adjust_key_frame_context(VP9_COMP *cpi) {
|
||||
vp9_clear_system_state();
|
||||
|
||||
cpi->frames_since_key = 0;
|
||||
cpi->key_frame_count++;
|
||||
cpi->rc.key_frame_count++;
|
||||
}
|
||||
|
||||
|
||||
void vp9_compute_frame_size_bounds(VP9_COMP *cpi, int *frame_under_shoot_limit,
|
||||
int *frame_over_shoot_limit) {
|
||||
// Set-up bounds on acceptable frame size:
|
||||
if (cpi->oxcf.fixed_q >= 0) {
|
||||
// Fixed Q scenario: frame size never outranges target (there is no target!)
|
||||
if (cpi->oxcf.end_usage == USAGE_CONSTANT_QUALITY) {
|
||||
*frame_under_shoot_limit = 0;
|
||||
*frame_over_shoot_limit = INT_MAX;
|
||||
} else {
|
||||
if (cpi->common.frame_type == KEY_FRAME) {
|
||||
*frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
|
||||
*frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
|
||||
*frame_over_shoot_limit = cpi->rc.this_frame_target * 9 / 8;
|
||||
*frame_under_shoot_limit = cpi->rc.this_frame_target * 7 / 8;
|
||||
} else {
|
||||
if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) {
|
||||
*frame_over_shoot_limit = cpi->this_frame_target * 9 / 8;
|
||||
*frame_under_shoot_limit = cpi->this_frame_target * 7 / 8;
|
||||
*frame_over_shoot_limit = cpi->rc.this_frame_target * 9 / 8;
|
||||
*frame_under_shoot_limit = cpi->rc.this_frame_target * 7 / 8;
|
||||
} else {
|
||||
// Stron overshoot limit for constrained quality
|
||||
if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) {
|
||||
*frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
|
||||
*frame_under_shoot_limit = cpi->this_frame_target * 2 / 8;
|
||||
*frame_over_shoot_limit = cpi->rc.this_frame_target * 11 / 8;
|
||||
*frame_under_shoot_limit = cpi->rc.this_frame_target * 2 / 8;
|
||||
} else {
|
||||
*frame_over_shoot_limit = cpi->this_frame_target * 11 / 8;
|
||||
*frame_under_shoot_limit = cpi->this_frame_target * 5 / 8;
|
||||
*frame_over_shoot_limit = cpi->rc.this_frame_target * 11 / 8;
|
||||
*frame_under_shoot_limit = cpi->rc.this_frame_target * 5 / 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -27,6 +27,8 @@ void vp9_compute_frame_size_bounds(VP9_COMP *cpi,
|
||||
int *frame_under_shoot_limit,
|
||||
int *frame_over_shoot_limit);
|
||||
|
||||
void vp9_init_minq_luts(void);
|
||||
|
||||
// return of 0 means drop frame
|
||||
int vp9_pick_frame_size(VP9_COMP *cpi);
|
||||
|
||||
@ -35,5 +37,7 @@ int vp9_gfboost_qadjust(int qindex);
|
||||
int vp9_bits_per_mb(FRAME_TYPE frame_type, int qindex,
|
||||
double correction_factor);
|
||||
void vp9_setup_inter_frame(VP9_COMP *cpi);
|
||||
int vp9_pick_q_and_adjust_q_bounds(VP9_COMP *cpi,
|
||||
int * bottom_index, int * top_index);
|
||||
|
||||
#endif // VP9_ENCODER_VP9_RATECTRL_H_
|
||||
|
@ -469,7 +469,7 @@ void configure_arnr_filter(VP9_COMP *cpi, const unsigned int this_frame,
|
||||
// cases where the filter extends beyond the end of clip.
|
||||
// Note: this_frame->frame has been updated in the loop
|
||||
// so it now points at the ARF frame.
|
||||
half_gf_int = cpi->baseline_gf_interval >> 1;
|
||||
half_gf_int = cpi->rc.baseline_gf_interval >> 1;
|
||||
frames_after_arf = (int)(cpi->twopass.total_stats.count - this_frame - 1);
|
||||
|
||||
switch (cpi->oxcf.arnr_type) {
|
||||
@ -507,7 +507,7 @@ void configure_arnr_filter(VP9_COMP *cpi, const unsigned int this_frame,
|
||||
cpi->active_arnr_frames = frames_bwd + 1 + frames_fwd;
|
||||
|
||||
// Adjust the strength based on active max q
|
||||
q = ((int)vp9_convert_qindex_to_q(cpi->active_worst_quality) >> 1);
|
||||
q = ((int)vp9_convert_qindex_to_q(cpi->rc.active_worst_quality) >> 1);
|
||||
if (q > 8) {
|
||||
cpi->active_arnr_strength = cpi->oxcf.arnr_strength;
|
||||
} else {
|
||||
|
Loading…
Reference in New Issue
Block a user