hashirama/uvg266
1
0
Fork 0
mirror of https://github.com/ultravideo/uvg266.git synced 2024-11-27 19:24:06 +00:00
Code Issues Actions Projects Releases Wiki Activity

unify naming

Browse source
This commit is contained in:
Joose Sainio 2019-09-27 10:16:21 +03:00
parent e36f481bda
commit ef74bfb182
2 changed files with 69 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

130
src/rate_control.c
View file

@ -180,15 +180,15 @@ static double solve_cubic_equation(const encoder_state_config_frame_t * const st
double est_lambda, double est_lambda,
double target_bits) double target_bits)
{ {
double bestlambda = 0.0; double best_lambda = 0.0;
double paraA = 0.0; double para_a = 0.0;
double paraB = 0.0; double para_b = 0.0;
double paraC = 0.0; double para_c = 0.0;
double paraD = 0.0; double para_d = 0.0;
double delta = 0.0; double delta = 0.0;
double paraAA = 0.0; double para_aa = 0.0;
double paraBB = 0.0; double para_bb = 0.0;
double paraCC = 0.0; double para_cc = 0.0;
for (int i = ctu_index; i < last_ctu; i++) for (int i = ctu_index; i < last_ctu; i++)
{ {
double a = 0.0; double a = 0.0;
@ -203,28 +203,28 @@ static double solve_cubic_equation(const encoder_state_config_frame_t * const st
b = -1.0 / (KLCU - 1.0); b = -1.0 / (KLCU - 1.0);
d = est_lambda; d = est_lambda;
c = pow(a / d, b); c = pow(a / d, b);
paraA = paraA - c * pow(b, 3.0) / 6.0; para_a = para_a - c * pow(b, 3.0) / 6.0;
paraB = paraB + (pow(b, 2.0) / 2.0 + pow(b, 3.0)*log(d) / 2.0)*c; para_b = para_b + (pow(b, 2.0) / 2.0 + pow(b, 3.0)*log(d) / 2.0)*c;
paraC = paraC - (pow(b, 3.0) / 2.0*pow(log(d), 2.0) + pow(b, 2.0)*log(d) + b)*c; para_c = para_c - (pow(b, 3.0) / 2.0*pow(log(d), 2.0) + pow(b, 2.0)*log(d) + b)*c;
paraD = paraD + c * (1 + b * log(d) + pow(b, 2.0) / 2 * pow(log(d), 2.0) + pow(b, 3.0) / 6 * pow(log(d), 3.0)); para_d = para_d + c * (1 + b * log(d) + pow(b, 2.0) / 2 * pow(log(d), 2.0) + pow(b, 3.0) / 6 * pow(log(d), 3.0));
} }
paraD = paraD - target_bits; para_d = para_d - target_bits;
paraAA = paraB * paraB - 3 * paraA*paraC; para_aa = para_b * para_b - 3 * para_a*para_c;
paraBB = paraB * paraC - 9 * paraA*paraD; para_bb = para_b * para_c - 9 * para_a*para_d;
paraCC = paraC * paraC - 3 * paraB*paraD; para_cc = para_c * para_c - 3 * para_b*para_d;
delta = paraBB * paraBB - 4 * paraAA*paraCC; delta = para_bb * para_bb - 4 * para_aa*para_cc;
if (delta > 0.0) //Check whether delta is right if (delta > 0.0) //Check whether delta is right
{ {
double tempx = 0.0; double temp_x = 0.0;
double part1 = 0.0; double part1 = 0.0;
double part2 = 0.0; double part2 = 0.0;
double flag1 = 0.0; double flag1 = 0.0;
double flag2 = 0.0; double flag2 = 0.0;
part1 = paraAA * paraB + 3 * paraA*(-paraBB - pow(delta, 0.5)) / 2.0; part1 = para_aa * para_b + 3 * para_a*(-para_bb - pow(delta, 0.5)) / 2.0;
part2 = paraAA * paraB + 3 * paraA*(-paraBB + pow(delta, 0.5)) / 2.0; part2 = para_aa * para_b + 3 * para_a*(-para_bb + pow(delta, 0.5)) / 2.0;
if (part1 < 0.0) { if (part1 < 0.0) {
part1 = -part1; part1 = -part1;
flag1 = -1.0; flag1 = -1.0;
@ -239,24 +239,24 @@ static double solve_cubic_equation(const encoder_state_config_frame_t * const st
else { else {
flag2 = 1.0; flag2 = 1.0;
} }
tempx = (-paraB - flag1 * pow(part1, 1.0 / 3.0) - flag2 * pow(part2, 1.0 / 3.0)) / 3 / paraA; temp_x = (-para_b - flag1 * pow(part1, 1.0 / 3.0) - flag2 * pow(part2, 1.0 / 3.0)) / 3 / para_a;
bestlambda = exp(tempx); best_lambda = exp(temp_x);
} }
else { else {
bestlambda = est_lambda; //Use the original picture estimated lambda for the current CTU best_lambda = est_lambda; //Use the original picture estimated lambda for the current CTU
} }
bestlambda = CLIP(0.001, 100000000.0, bestlambda); best_lambda = CLIP(0.001, 100000000.0, best_lambda);
return bestlambda; return best_lambda;
} }
static INLINE double calculate_weights(encoder_state_t* const state, const int layer, const int ctu_count, double estLambda) { static INLINE double calculate_weights(encoder_state_t* const state, const int layer, const int ctu_count, double estLambda) {
double total_weight = 0; double total_weight = 0;
for(int i = 0; i < ctu_count; i++) { for(int i = 0; i < ctu_count; i++) {
double CLCU = state->frame->new_ratecontrol.c_para[layer][i]; double c_lcu = state->frame->new_ratecontrol.c_para[layer][i];
double KLCU = state->frame->new_ratecontrol.k_para[layer][i]; double k_lcu = state->frame->new_ratecontrol.k_para[layer][i];
double a = -CLCU * KLCU / pow(state->frame->lcu_stats[i].pixels, KLCU - 1.0); double a = -c_lcu * k_lcu / pow(state->frame->lcu_stats[i].pixels, k_lcu - 1.0);
double b = -1.0 / (KLCU - 1.0); double b = -1.0 / (k_lcu - 1.0);
state->frame->lcu_stats[i].weight = pow(a / estLambda, b); state->frame->lcu_stats[i].weight = pow(a / estLambda, b);
if (state->frame->lcu_stats[i].weight < 0.01) { if (state->frame->lcu_stats[i].weight < 0.01) {
state->frame->lcu_stats[i].weight = 0.01; state->frame->lcu_stats[i].weight = 0.01;
@ -267,7 +267,7 @@ static INLINE double calculate_weights(encoder_state_t* const state, const int l
} }
void estimatePicLambda(encoder_state_t * const state) { void kvz_estimate_pic_lambda(encoder_state_t * const state) {
double bits = pic_allocate_bits(state); double bits = pic_allocate_bits(state);
const int layer = state->frame->gop_offset - (state->frame->is_irap ? 1 : 0); const int layer = state->frame->gop_offset - (state->frame->is_irap ? 1 : 0);
const int ctu_count = state->tile->frame->height_in_lcu * state->tile->frame->width_in_lcu; const int ctu_count = state->tile->frame->height_in_lcu * state->tile->frame->width_in_lcu;
@ -283,33 +283,33 @@ void estimatePicLambda(encoder_state_t * const state) {
state->frame->new_ratecontrol.pic_k_para[state->frame->gop_offset]; state->frame->new_ratecontrol.pic_k_para[state->frame->gop_offset];
beta = state->frame->new_ratecontrol.pic_k_para[state->frame->gop_offset] - 1; beta = state->frame->new_ratecontrol.pic_k_para[state->frame->gop_offset] - 1;
} }
double estLambda; double est_lambda;
double bpp = bits / (state->encoder_control->cfg.width * state->encoder_control->cfg.height); double bpp = bits / (state->encoder_control->cfg.width * state->encoder_control->cfg.height);
if (state->frame->is_irap) { if (state->frame->is_irap) {
// TODO: Intra // TODO: Intra
estLambda = alpha * pow(bpp, beta) * 0.5; est_lambda = alpha * pow(bpp, beta) * 0.5;
} }
else { else {
estLambda = alpha * pow(bpp, beta); est_lambda = alpha * pow(bpp, beta);
} }
double temp_lambda; double temp_lambda;
if ((temp_lambda = state->frame->new_ratecontrol.previous_lambdas[layer]) > 0.0) { if ((temp_lambda = state->frame->new_ratecontrol.previous_lambdas[layer]) > 0.0) {
estLambda = CLIP(temp_lambda * pow(2.0, -1), temp_lambda * 2, estLambda); est_lambda = CLIP(temp_lambda * pow(2.0, -1), temp_lambda * 2, est_lambda);
} }
if((temp_lambda = state->frame->new_ratecontrol.previous_frame_lambda) > 0.0) { if((temp_lambda = state->frame->new_ratecontrol.previous_frame_lambda) > 0.0) {
estLambda = CLIP(temp_lambda * pow(2.0, -10.0 / 3.0), temp_lambda * pow(2.0, 10.0 / 3.0), estLambda); est_lambda = CLIP(temp_lambda * pow(2.0, -10.0 / 3.0), temp_lambda * pow(2.0, 10.0 / 3.0), est_lambda);
} }
estLambda = MIN(estLambda, 0.1); est_lambda = MIN(est_lambda, 0.1);
double total_weight = 0; double total_weight = 0;
if(!state->frame->is_irap) { if(!state->frame->is_irap) {
if(!state->encoder_control->cfg.frame_allocation) { if(!state->encoder_control->cfg.frame_allocation) {
double best_lambda = 0.0; double best_lambda = 0.0;
temp_lambda = estLambda; temp_lambda = est_lambda;
double taylor_e3; double taylor_e3;
int iteration_number = 0; int iteration_number = 0;
do { do {
@ -325,12 +325,12 @@ void estimatePicLambda(encoder_state_t * const state) {
} }
while (fabs(taylor_e3 - bits) > 0.01 && iteration_number <= 11); while (fabs(taylor_e3 - bits) > 0.01 && iteration_number <= 11);
} }
total_weight = calculate_weights(state, layer, ctu_count, estLambda); total_weight = calculate_weights(state, layer, ctu_count, est_lambda);
} }
else { else {
for (int i = 0; i < ctu_count; ++i) { for (int i = 0; i < ctu_count; ++i) {
state->frame->lcu_stats[i].weight = MAX(0.01, state->frame->lcu_stats[i].weight = MAX(0.01,
state->frame->lcu_stats[i].pixels * pow(estLambda / state->frame->rc_alpha, state->frame->lcu_stats[i].pixels * pow(est_lambda / state->frame->rc_alpha,
1.0 / state->frame->rc_beta)); 1.0 / state->frame->rc_beta));
total_weight += state->frame->lcu_stats[i].weight; total_weight += state->frame->lcu_stats[i].weight;
} }
@ -340,8 +340,8 @@ void estimatePicLambda(encoder_state_t * const state) {
state->frame->lcu_stats[i].weight = bits * state->frame->lcu_stats[i].weight / total_weight; state->frame->lcu_stats[i].weight = bits * state->frame->lcu_stats[i].weight / total_weight;
} }
state->frame->lambda = estLambda; state->frame->lambda = est_lambda;
state->frame->QP = lambda_to_qp(estLambda); state->frame->QP = lambda_to_qp(est_lambda);
} }
@ -359,48 +359,48 @@ static double get_ctu_bits(encoder_state_t * const state, vector2d_t pos) {
(state->encoder_control->in.height * state->encoder_control->in.width)); (state->encoder_control->in.height * state->encoder_control->in.width));
} }
else { else {
double totalWeight = 0; double total_weight = 0;
const int realInfluenceLCU = MIN(4, num_ctu - index); //g_RCLCUSmoothWindowSize, the same as the original RC scheme const int used_ctu_count = MIN(4, num_ctu - index); //g_RCLCUSmoothWindowSize, the same as the original RC scheme
int TargetbitsForSmoothWindow = 0; int target_bits = 0;
double bestlambda = 0.0; double best_lambda = 0.0;
double Templambda = state->frame->lambda; double temp_lambda = state->frame->lambda;
double TaylorE3 = 0.0; double taylor_e3 = 0.0;
int IterationNum = 0; int iter = 0;
double estLambda = Templambda; double est_lambda = temp_lambda;
for (int i = index; i < num_ctu; i++) { for (int i = index; i < num_ctu; i++) {
totalWeight += state->frame->lcu_stats[i].weight; total_weight += state->frame->lcu_stats[i].weight;
} }
int last_ctu = index + realInfluenceLCU; int last_ctu = index + used_ctu_count;
for (int i = index; i < last_ctu; i++) { for (int i = index; i < last_ctu; i++) {
TargetbitsForSmoothWindow += state->frame->lcu_stats[i].weight; target_bits += state->frame->lcu_stats[i].weight;
} }
TargetbitsForSmoothWindow = MAX(TargetbitsForSmoothWindow + state->frame->total_bits_coded - (int)totalWeight, 10); //obtain the total bit-rate for the realInfluenceLCU (=4) CTUs target_bits = MAX(target_bits + state->frame->total_bits_coded - (int)total_weight, 10); //obtain the total bit-rate for the realInfluenceLCU (=4) CTUs
//just similar with the process at frame level, details can refer to the function TEncRCPic::estimatePicLambda //just similar with the process at frame level, details can refer to the function TEncRCPic::kvz_estimate_pic_lambda
do { do {
TaylorE3 = 0.0; taylor_e3 = 0.0;
bestlambda = solve_cubic_equation(state->frame, index, last_ctu, layer, Templambda, TargetbitsForSmoothWindow); best_lambda = solve_cubic_equation(state->frame, index, last_ctu, layer, temp_lambda, target_bits);
Templambda = bestlambda; temp_lambda = best_lambda;
for (int i = index; i < last_ctu; i++) { for (int i = index; i < last_ctu; i++) {
double CLCU = state->frame->new_ratecontrol.c_para[layer][i]; double CLCU = state->frame->new_ratecontrol.c_para[layer][i];
double KLCU = state->frame->new_ratecontrol.k_para[layer][i]; double KLCU = state->frame->new_ratecontrol.k_para[layer][i];
double a = -CLCU * KLCU / pow((double)state->frame->lcu_stats[i].pixels, KLCU - 1.0); double a = -CLCU * KLCU / pow((double)state->frame->lcu_stats[i].pixels, KLCU - 1.0);
double b = -1.0 / (KLCU - 1.0); double b = -1.0 / (KLCU - 1.0);
TaylorE3 += pow(a / bestlambda, b); taylor_e3 += pow(a / best_lambda, b);
} }
IterationNum++; iter++;
} while (fabs(TaylorE3 - TargetbitsForSmoothWindow) > 0.01 && IterationNum < 5); } while (fabs(taylor_e3 - target_bits) > 0.01 && iter < 5);
double CLCU = state->frame->new_ratecontrol.c_para[layer][index]; double c_ctu = state->frame->new_ratecontrol.c_para[layer][index];
double KLCU = state->frame->new_ratecontrol.k_para[layer][index]; double k_ctu = state->frame->new_ratecontrol.k_para[layer][index];
double a = -CLCU * KLCU / pow(((double)state->frame->lcu_stats[index].pixels), KLCU - 1.0); double a = -c_ctu * k_ctu / pow(((double)state->frame->lcu_stats[index].pixels), k_ctu - 1.0);
double b = -1.0 / (KLCU - 1.0); double b = -1.0 / (k_ctu - 1.0);
state->frame->lcu_stats[index].weight = MAX(pow(a / bestlambda, b), 0.01); state->frame->lcu_stats[index].weight = MAX(pow(a / best_lambda, b), 0.01);
avg_bits = (int)(state->frame->lcu_stats[index].weight + 0.5); avg_bits = (int)(state->frame->lcu_stats[index].weight + 0.5);
} }

4
src/rate_control.h
View file

@ -35,4 +35,8 @@ void kvz_set_picture_lambda_and_qp(encoder_state_t * const state);
void kvz_set_lcu_lambda_and_qp(encoder_state_t * const state, void kvz_set_lcu_lambda_and_qp(encoder_state_t * const state,
vector2d_t pos); vector2d_t pos);
void kvz_set_ctu_qp_lambda(encoder_state_t * const state, vector2d_t pos);
void kvz_update_after_picture(encoder_state_t * const state);
void kvz_estimate_pic_lambda(encoder_state_t * const state);
#endif // RATE_CONTROL_H_ #endif // RATE_CONTROL_H_