From 74cc83f69eccd8d38c7f3108ffb97a8b70c39ead Mon Sep 17 00:00:00 2001 From: "sayon.chen" Date: Thu, 23 Jul 2020 10:03:14 +0800 Subject: [PATCH] [rc_v2]: Support avbr ratecontrol when select avbr must set target_bps max_bps min_bps,in still scene will used min_bps for enc, in the moving scene will max_bps for enc. and final avg bit will get close to target_bps Change-Id: I84b2878c7e76b18a593ca2a0d99c0c8f26a2d557 Signed-off-by: sayon.chen --- inc/rk_venc_cmd.h | 1 + mpp/codec/mpp_enc_v2.cpp | 3 + mpp/codec/rc/rc_model_v2.c | 321 ++++++++++++++++++++++++++++++++++--- 3 files changed, 304 insertions(+), 21 deletions(-) diff --git a/inc/rk_venc_cmd.h b/inc/rk_venc_cmd.h index aea44fbc..ef2aa0df 100644 --- a/inc/rk_venc_cmd.h +++ b/inc/rk_venc_cmd.h @@ -168,6 +168,7 @@ typedef enum MppEncRcMode_e { MPP_ENC_RC_MODE_VBR, MPP_ENC_RC_MODE_CBR, MPP_ENC_RC_MODE_FIXQP, + MPP_ENC_RC_MODE_AVBR, MPP_ENC_RC_MODE_BUTT } MppEncRcMode; diff --git a/mpp/codec/mpp_enc_v2.cpp b/mpp/codec/mpp_enc_v2.cpp index a630548c..a95cf566 100644 --- a/mpp/codec/mpp_enc_v2.cpp +++ b/mpp/codec/mpp_enc_v2.cpp @@ -675,6 +675,9 @@ static void set_rc_cfg(RcCfg *cfg, MppEncCfgSet *cfg_set) case MPP_ENC_RC_MODE_VBR : { cfg->mode = RC_VBR; } break; + case MPP_ENC_RC_MODE_AVBR : { + cfg->mode = RC_AVBR; + } break; case MPP_ENC_RC_MODE_FIXQP: { cfg->mode = RC_FIXQP; } break; diff --git a/mpp/codec/rc/rc_model_v2.c b/mpp/codec/rc/rc_model_v2.c index 56448b82..fd2f9aae 100644 --- a/mpp/codec/rc/rc_model_v2.c +++ b/mpp/codec/rc/rc_model_v2.c @@ -49,9 +49,25 @@ RK_S32 tab_lnx[64] = { 196, 202, 208, 214, 220, 226, 232, 237, }; +RK_S32 mean_qp2scale[16] = { + 14, 15, 16, 18, 20, 22, 25, 28, + 32, 36, 40, 44, 50, 56, 64, 72 +}; static const RK_S8 max_ip_qp_dealt[8] = { 7, 7, 7, 7, 6, 4, 3, 2 }; +RK_U32 bit2percent[100] = { + 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, + 99, 95, 90, 85, 80, 75, 72, 69, 66, 64, + 62, 59, 58, 57, 56, 55, 54, 53, 52, 51, + 50, 49, 48, 47, 47, 46, 46, 45, 45, 44, + 44, 43, 43, 43, 42, 42, 42, 41, 41, 41, + 40, 40, 40, 39, 39, 39, 38, 38, 38, 37, + 37, 37, 37, 37, 37, 37, 36, 36, 36, 36, + 36, 36, 36, 35, 35, 35, 34, 34, 34, 34, + 34, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, +}; typedef struct RcModelV2Ctx_t { RcCfg usr_cfg; @@ -62,6 +78,8 @@ typedef struct RcModelV2Ctx_t { RK_S64 gop_total_bits; RK_U32 bit_per_frame; RK_U32 first_frm_flg; + RK_S64 avg_gbits; + RK_S64 real_gbits; MppDataV2 *i_bit; RK_U32 i_sumbits; @@ -79,7 +97,10 @@ typedef struct RcModelV2Ctx_t { RK_U32 p_scale; MppDataV2 *pre_p_bit; + MppDataV2 *pre_i_bit; + MppDataV2 *pre_i_mean_qp; MppDataV2 *madi; + MppDataV2 *madp; RK_S32 target_bps; RK_S32 pre_target_bits; @@ -88,10 +109,17 @@ typedef struct RcModelV2Ctx_t { RK_S32 ins_bps; RK_S32 last_inst_bps; + RK_U32 motion_sensitivity; + RK_U32 min_still_percent; + RK_U32 max_still_qp; + RK_S32 moving_ratio; + RK_U32 pre_mean_qp; + RK_U32 pre_i_scale; /*super frame thr*/ RK_U32 super_ifrm_bits_thr; RK_U32 super_pfrm_bits_thr; MppDataV2 *stat_bits; + MppDataV2 *gop_bits; MppDataV2 *stat_rate; RK_S32 watl_thrd; RK_S32 stat_watl; @@ -101,13 +129,15 @@ typedef struct RcModelV2Ctx_t { RK_S32 next_ratio; // scale 64 RK_S32 pre_i_qp; RK_S32 pre_p_qp; - RK_S32 scale_qp; // scale 64 + RK_U32 scale_qp; // scale 64 MppDataV2 *means_qp; + RK_U32 frm_num; /*qp decision*/ RK_S32 cur_scale_qp; RK_S32 start_qp; RK_S32 prev_quality; + RK_S32 prev_md_prop; RK_S32 reenc_cnt; } RcModelV2Ctx; @@ -135,10 +165,19 @@ MPP_RET bits_model_deinit(RcModelV2Ctx *ctx) ctx->pre_p_bit = NULL; } + if (ctx->pre_i_mean_qp != NULL) { + mpp_data_deinit_v2(ctx->pre_i_mean_qp); + ctx->pre_i_mean_qp = NULL; + } + if (ctx->madi != NULL) { mpp_data_deinit_v2(ctx->madi); ctx->madi = NULL; } + if (ctx->madp != NULL) { + mpp_data_deinit_v2(ctx->madp); + ctx->madp = NULL; + } if (ctx->stat_rate != NULL) { mpp_data_deinit_v2(ctx->stat_rate); @@ -149,7 +188,10 @@ MPP_RET bits_model_deinit(RcModelV2Ctx *ctx) mpp_data_deinit_v2(ctx->stat_bits); ctx->stat_bits = NULL; } - + if (ctx->gop_bits != NULL) { + mpp_data_deinit_v2(ctx->gop_bits); + ctx->gop_bits = NULL; + } rc_dbg_func("leave %p\n", ctx); return MPP_OK; } @@ -226,9 +268,18 @@ MPP_RET bits_model_init(RcModelV2Ctx *ctx) mpp_log("infinte gop, set default for rc bit calc\n"); ctx->usr_cfg.igop = gop_len = 500; } - + if (!ctx->min_still_percent) { + if (ctx->usr_cfg.bps_min && ctx->usr_cfg.bps_max) { + ctx->min_still_percent = ctx->usr_cfg.bps_min * 100 / ctx->usr_cfg.bps_max; + } else { + ctx->min_still_percent = 25; + } + rc_dbg_rc("min_still_percent %d", ctx->min_still_percent); + } + ctx->max_still_qp = 35; ctx->super_ifrm_bits_thr = -1; ctx->super_pfrm_bits_thr = -1; + ctx->motion_sensitivity = 90; ctx->first_frm_flg = 1; @@ -272,11 +323,30 @@ MPP_RET bits_model_init(RcModelV2Ctx *ctx) mpp_err("pre_p_bit init fail"); return -1; } + mpp_data_init_v2(&ctx->pre_i_bit, I_WINDOW_LEN); + if (ctx->pre_i_bit == NULL) { + mpp_err("pre_i_bit init fail"); + return -1; + } + + mpp_data_init_v2(&ctx->pre_i_mean_qp, I_WINDOW_LEN); + if (ctx->pre_i_mean_qp == NULL) { + mpp_err("pre_i_mean_qp init fail"); + return -1; + } + mpp_data_reset_v2(ctx->pre_i_mean_qp, -1); mpp_data_init_v2(&ctx->madi, P_WINDOW2_LEN); if (ctx->madi == NULL) { mpp_err("madi init fail"); return -1; } + + mpp_data_init_v2(&ctx->madp, P_WINDOW2_LEN); + if (ctx->madp == NULL) { + mpp_err("madp init fail"); + return -1; + } + mpp_data_init_v2(&ctx->stat_rate, fps->fps_in_num); if (ctx->stat_rate == NULL) { mpp_err("stat_rate init fail fps_in_num %d", fps->fps_in_num); @@ -291,11 +361,12 @@ MPP_RET bits_model_init(RcModelV2Ctx *ctx) mpp_data_reset_v2(ctx->stat_rate, 0); - mpp_data_init_v2(&ctx->madi, P_WINDOW2_LEN); - if (ctx->madi == NULL) { - mpp_err("madi init fail"); + mpp_data_init_v2(&ctx->gop_bits, gop_len); + if (ctx->gop_bits == NULL) { + mpp_err("gop_bits init fail gop_len %d", gop_len); return -1; } + mpp_data_reset_v2(ctx->gop_bits, 0); ctx->bit_per_frame = target_bps / fps->fps_in_num; ctx->watl_thrd = 3 * target_bps; @@ -312,6 +383,38 @@ MPP_RET bits_model_init(RcModelV2Ctx *ctx) return MPP_OK; } +RK_S32 moving_judge_update(RcModelV2Ctx *ctx, EncRcTaskInfo *cfg) +{ + switch (ctx->frame_type) { + case INTRA_FRAME: { + mpp_data_update_v2(ctx->pre_i_bit, cfg->bit_real); + mpp_data_update_v2(ctx->pre_i_mean_qp, cfg->quality_real); + } break; + + case INTER_P_FRAME: { + mpp_data_update_v2(ctx->pre_p_bit, cfg->bit_real); + mpp_data_update_v2(ctx->madp, cfg->madp); + } break; + + default: + break; + } + return 0; +} + +void bit_statics_update(RcModelV2Ctx *ctx, RK_U32 real_bit) +{ + RK_S32 mean_pbits, mean_ibits; + RcCfg *usr_cfg = &ctx->usr_cfg; + RK_U32 gop_len = usr_cfg->igop; + + mpp_data_update_v2(ctx->gop_bits, real_bit); + mean_pbits = mpp_data_mean_v2(ctx->pre_p_bit); + mean_ibits = mpp_data_mean_v2(ctx->pre_i_bit); + ctx->real_gbits = mpp_data_sum_v2(ctx->gop_bits); + ctx->avg_gbits = (gop_len - 1) * (RK_S64)mean_pbits + mean_ibits; +} + MPP_RET bits_model_update(RcModelV2Ctx *ctx, RK_S32 real_bit, RK_U32 madi) { RK_S32 water_level = 0; @@ -320,7 +423,7 @@ MPP_RET bits_model_update(RcModelV2Ctx *ctx, RK_S32 real_bit, RK_U32 madi) mpp_data_update_v2(ctx->stat_rate, real_bit != 0); mpp_data_update_v2(ctx->stat_bits, real_bit); - + ctx->ins_bps = mpp_data_sum_v2(ctx->stat_bits) / ctx->usr_cfg.stat_times; if (real_bit + ctx->stat_watl > ctx->watl_thrd) water_level = ctx->watl_thrd - ctx->bit_per_frame; else @@ -360,12 +463,10 @@ MPP_RET bits_model_update(RcModelV2Ctx *ctx, RK_S32 real_bit, RK_U32 madi) return MPP_OK; } -MPP_RET bits_model_alloc(RcModelV2Ctx *ctx, EncRcTaskInfo *cfg) +MPP_RET bits_model_alloc(RcModelV2Ctx *ctx, EncRcTaskInfo *cfg, RK_S64 total_bits) { RK_U32 max_i_prop = ctx->usr_cfg.max_i_bit_prop * 16; RK_S32 gop_len = ctx->usr_cfg.igop; - RK_S64 total_bits = ctx->gop_total_bits; - RK_S32 ins_bps = mpp_data_sum_v2(ctx->stat_bits) / ctx->usr_cfg.stat_times; RK_S32 i_scale = ctx->i_scale; RK_S32 vi_scale = ctx->vi_scale; RK_S32 alloc_bits = 0; @@ -428,7 +529,7 @@ MPP_RET bits_model_alloc(RcModelV2Ctx *ctx, EncRcTaskInfo *cfg) } rc_dbg_rc("i_scale %d, total_bits %lld", i_scale, total_bits); cfg->bit_target = alloc_bits; - ctx->ins_bps = ins_bps; + rc_dbg_func("leave %p\n", ctx); return MPP_OK; } @@ -467,7 +568,7 @@ MPP_RET calc_next_i_ratio(RcModelV2Ctx *ctx) } -MPP_RET calc_cbr_ratio(RcModelV2Ctx *ctx) +MPP_RET calc_cbr_ratio(RcModelV2Ctx *ctx, EncRcTaskInfo *cfg) { RK_S32 target_bps = ctx->target_bps; RK_S32 ins_bps = ctx->ins_bps; @@ -480,12 +581,15 @@ MPP_RET calc_cbr_ratio(RcModelV2Ctx *ctx) RK_S32 fluc_l = 3; rc_dbg_func("enter %p\n", ctx); + rc_dbg_bps("%10s|%10s|%10s|%10s|%10s|%8s", "r_bits", "t_bits", "ins_bps", "p_ins_bps", "target_bps", "watl"); rc_dbg_bps("%10d %10d %10d %10d %10d %8d", pre_real_bits, pre_target_bits, ins_bps, pre_ins_bps, target_bps, ctx->stat_watl >> 10); + bits_model_alloc(ctx, cfg, ctx->gop_total_bits); mpp_assert(target_bps > 0); + if (pre_target_bits > pre_real_bits) bit_diff_ratio = 52 * (pre_real_bits - pre_target_bits) / pre_target_bits; else @@ -533,6 +637,7 @@ MPP_RET calc_cbr_ratio(RcModelV2Ctx *ctx) "wl_ratio", "next_ratio", "cur_qp_s"); rc_dbg_qp("%10d %10d %10d %10d %10d|%10d", bit_diff_ratio, ins_ratio - bit_diff_ratio, bps_ratio, wl_ratio, ctx->next_ratio, ctx->cur_scale_qp); + rc_dbg_func("leave %p\n", ctx); return MPP_OK; } @@ -607,7 +712,7 @@ MPP_RET reenc_calc_cbr_ratio(RcModelV2Ctx *ctx, EncRcTaskInfo *cfg) } -MPP_RET calc_vbr_ratio(RcModelV2Ctx *ctx) +MPP_RET calc_vbr_ratio(RcModelV2Ctx *ctx, EncRcTaskInfo *cfg) { RK_S32 bps_change = ctx->target_bps; RK_S32 max_bps_target = ctx->usr_cfg.bps_max; @@ -621,6 +726,7 @@ MPP_RET calc_vbr_ratio(RcModelV2Ctx *ctx) rc_dbg_func("enter %p\n", ctx); + bits_model_alloc(ctx, cfg, ctx->gop_total_bits); if (pre_target_bits > pre_real_bits) bit_diff_ratio = 32 * (pre_real_bits - pre_target_bits) / pre_target_bits; else @@ -706,6 +812,163 @@ MPP_RET reenc_calc_vbr_ratio(RcModelV2Ctx *ctx, EncRcTaskInfo *cfg) return MPP_OK; } +RK_S32 moving_ratio_calc(RcModelV2Ctx *ctx) +{ + RK_S32 motion_sensitivity = ctx->motion_sensitivity; + RK_S32 scale = 0, i; + RK_S32 total_bit = 0, pbit_sum = 0; + RK_S32 madi_sum = 0, madp_sum = 0; + RK_S32 percent = 0; + + for (i = 0; i < 2; i++) { + RK_S32 pre_I_bit = ctx->pre_i_bit->val[i]; + RK_S32 pre_mean_qp = ctx->pre_i_mean_qp->val[i]; + if (pre_mean_qp == -1) { + scale = 32; + } else { + RK_S32 index = pre_mean_qp + 8 - ctx->pre_mean_qp; + if (index >= 0) { + index = mpp_clip(index, 0 , 15); + scale = mean_qp2scale[index]; + } else { + scale = 14; + } + } + total_bit += (scale * pre_I_bit >> 5); + rc_dbg_rc("pre_mean_qp = %d, ctx->pre_mean_qp %d", pre_mean_qp, ctx->pre_mean_qp); + rc_dbg_rc("scale = %d, pre_I_bit %d", scale, pre_I_bit); + } + + pbit_sum = mpp_data_sum_v2(ctx->pre_p_bit); + madi_sum = mpp_data_sum_v2(ctx->madi); + madp_sum = mpp_data_sum_v2(ctx->madp); + rc_dbg_rc("pbit_sum %d,madi_sum = %d, madp_sum = %d", pbit_sum, madi_sum, madp_sum); + if ( pbit_sum == 0 || total_bit == 0) { + percent = 255; + } else { + RK_S32 index = (total_bit << 6) / pbit_sum; + index = mpp_clip(index >> 4, 1, 99); + percent = (bit2percent[index] << 8) / 100; + } + rc_dbg_rc("means qp percent %d min_still_percent %d", percent, ctx->min_still_percent); + RK_S32 percent_a = (ctx->min_still_percent - 30) << 8; + RK_S32 percent_b = 100 - ctx->min_still_percent; + + percent = (percent_a + percent * percent_b) / 70; + rc_dbg_rc("percent_a = %d percent_b %d", percent_a, percent_b); + RK_S32 mv_percnt = (ctx->prev_md_prop * 100) >> 8; + RK_S32 mv_ratio = (percent_a + 7680 + mv_percnt * percent_b) / 100; + rc_dbg_rc("mv_ratio = %d", mv_ratio); + RK_S32 mad_ratio = 256; + if (madi_sum) { + mad_ratio = 20 * madp_sum / madi_sum; + mad_ratio = mpp_clip(mad_ratio, 5, 100); + rc_dbg_rc("mad_ratio = %d", mad_ratio); + mad_ratio = (mad_ratio << 8) / 100; + } + mad_ratio = (percent_a + 7680 + percent_b * mad_ratio) / 100; + + RK_S32 moving_ratio = (percent + 1 + (mv_ratio * motion_sensitivity + (100 - motion_sensitivity) * mad_ratio) / 100) >> 1; + rc_dbg_rc("moving_ratio = %d, motion_sensitivity = %d", moving_ratio, motion_sensitivity); + rc_dbg_rc("percent %d mad_ratio %d hr_ratio %d, moving_ratio %d", percent, mad_ratio, mv_ratio, moving_ratio); + return moving_ratio; +} + + +MPP_RET calc_avbr_ratio(RcModelV2Ctx *ctx, EncRcTaskInfo *cfg) +{ + RK_S32 bps_change = ctx->target_bps; + RK_S32 max_bps_target = ctx->usr_cfg.bps_max; + RK_S32 ins_bps = ctx->ins_bps; + RK_S32 pre_target_bits = ctx->pre_target_bits; + RK_S32 pre_real_bits = ctx->pre_real_bits; + RK_S32 pre_ins_bps = ctx->last_inst_bps; + RK_S32 idx1, idx2; + RK_S32 bit_diff_ratio, ins_ratio, agop_dratio, rgop_dratio; + RK_S32 moving_ratio = 0, moving_percent; + RK_S32 gop_bits = 0, gop_kbits = 0; + RK_S32 i_ratio, max_bps; + RK_S32 qratio, final_qratio; + rc_dbg_func("enter %p\n", ctx); + moving_ratio = moving_ratio_calc(ctx); + if (ctx->moving_ratio - 2 >= moving_ratio) { + moving_ratio = ctx->moving_ratio - 2; + } + + if (ctx->moving_ratio > moving_ratio && (ctx->max_still_qp << 6) <= ctx->scale_qp) { + ctx->moving_ratio = mpp_clip(ctx->moving_ratio + 1, 0, 255); + } else { + ctx->moving_ratio = moving_ratio; + } + rc_dbg_rc("final moving_ratio = %d", moving_ratio); + gop_bits = moving_ratio * ctx->gop_total_bits >> 8; + gop_kbits = gop_bits >> 10; + if (gop_kbits < 1) { + gop_kbits = 1; + } + + bits_model_alloc(ctx, cfg, gop_bits); + bps_change = moving_ratio * bps_change >> 8; + if (moving_ratio < 0) { + moving_ratio += 255; + } + moving_percent = 100 * moving_ratio >> 8; + + rc_dbg_bps("%10s|%10s|%10s|%10s|%10s", "m_ratio", "r_bits", "t_bits", "ins_bps", "p_ins_bps"); + rc_dbg_bps("%10d %10d %10d %10d %10d", ctx->moving_ratio, pre_real_bits, pre_target_bits, ins_bps, pre_ins_bps); + + if (pre_target_bits > pre_real_bits) + bit_diff_ratio = 32 * (pre_real_bits - pre_target_bits) / pre_target_bits; + else + bit_diff_ratio = 64 * (pre_real_bits - pre_target_bits) / pre_target_bits * moving_percent; + + i_ratio = mpp_clip(ctx->pre_i_scale >> 4, 10, 200); + idx1 = ins_bps / (max_bps_target >> 5); + idx2 = pre_ins_bps / (max_bps_target >> 5); + idx1 = mpp_clip(idx1, 0, 64); + idx2 = mpp_clip(idx2, 0, 64); + ins_ratio = tab_lnx[idx2] - tab_lnx[idx1]; + max_bps = bps_change; + if (max_bps < pre_ins_bps) { + max_bps = pre_ins_bps; + } + if (ins_bps <= max_bps) { + if (ins_bps < pre_ins_bps && bps_change > pre_ins_bps) { + ins_ratio = 3 * ins_ratio; + } else { + ins_ratio = 0; + } + } else { + ins_ratio = 6 * ins_ratio; + } + + ins_ratio = mpp_clip(ins_ratio >> 2, -128, 256); + bit_diff_ratio = mpp_clip(10 * bit_diff_ratio / i_ratio, -128, 256); + rgop_dratio = mpp_clip(24 * ((ctx->real_gbits - gop_bits) >> 10) / gop_kbits, -1, 1); + agop_dratio = mpp_clip(48 * ((ctx->avg_gbits - gop_bits) >> 10) / gop_kbits , -1, 1); + if (ctx->pre_i_scale > 640) { + bit_diff_ratio = mpp_clip(bit_diff_ratio, -16, 32); + ins_ratio = mpp_clip(ins_ratio, -16, 32); + } + qratio = 0; + final_qratio = ins_ratio + bit_diff_ratio + agop_dratio + rgop_dratio; + if (max_bps_target >= ins_bps) { + if (final_qratio > 0) { + if (ctx->scale_qp >= (ctx->max_still_qp << 6)) { + final_qratio = ins_ratio + agop_dratio + rgop_dratio; + qratio = -6; + } + } + } + ctx->next_ratio = qratio + final_qratio; + + rc_dbg_qp("%10s|%10s|%10s|%10s|%10s|%10s|%10s", "diff_ratio", "ins_ratio", "rg_ratio", + "ag_ratio", "qratio", "next_ratio", "cur_qp_s"); + rc_dbg_qp("%10d %10d %10d %10d %10d %10d %10d", bit_diff_ratio, ins_ratio, rgop_dratio, + agop_dratio, qratio, ctx->next_ratio, ctx->cur_scale_qp); + rc_dbg_func("leave %p\n", ctx); + return MPP_OK; +} MPP_RET bits_mode_reset(RcModelV2Ctx *ctx) { @@ -744,10 +1007,10 @@ MPP_RET check_re_enc(RcModelV2Ctx *ctx, EncRcTaskInfo *cfg) rc_dbg_func("enter %p\n", ctx); rc_dbg_rc("reenc check target_bps %d last_ins_bps %d ins_bps %d", ctx->usr_cfg.bps_target, last_ins_bps, ins_bps); + if (ctx->reenc_cnt >= ctx->usr_cfg.max_reencode_times) { return MPP_OK; } - switch (frame_type) { case INTRA_FRAME: bit_thr = 3 * cfg->bit_target / 2; @@ -852,8 +1115,6 @@ MPP_RET rc_model_v2_start(void *ctx, EncRcTask *task) p->frame_type = INTER_VI_FRAME; } - /* bitrate allocation */ - bits_model_alloc(p, info); p->next_ratio = 0; if (p->last_frame_type == INTRA_FRAME) { @@ -861,11 +1122,22 @@ MPP_RET rc_model_v2_start(void *ctx, EncRcTask *task) } if (!p->first_frm_flg) { - if (cfg->mode == RC_CBR) { - calc_cbr_ratio(p); - } else { - calc_vbr_ratio(p); + switch (p->usr_cfg.mode) { + case RC_CBR: { + calc_cbr_ratio(p, info); + } break; + case RC_VBR: { + calc_vbr_ratio(p, info); + } break; + case RC_AVBR: { + calc_avbr_ratio(p, info); + } break; + default: + mpp_log("rc mode set error"); + break; } + } else { + bits_model_alloc(p, info, p->gop_total_bits); } /* quality determination */ @@ -1075,10 +1347,17 @@ MPP_RET rc_model_v2_end(void *ctx, EncRcTask *task) if (!frm->reencode) { rc_dbg_rc("bits_mode_update real_bit %d", cfg->bit_real); - bits_model_update(p, cfg->bit_real, cfg->madi); p->last_inst_bps = p->ins_bps; p->first_frm_flg = 0; + bits_model_update(p, cfg->bit_real, cfg->madi); + if (p->usr_cfg.mode == RC_AVBR) { + moving_judge_update(p, cfg); + bit_statics_update(p, cfg->bit_real); + } p->last_frame_type = p->frame_type; + p->pre_mean_qp = cfg->quality_real; + p->scale_qp = p->cur_scale_qp; + p->prev_md_prop = 0; } p->pre_target_bits = cfg->bit_target;