diff --git a/mpp/base/mpp_enc_cfg.cpp b/mpp/base/mpp_enc_cfg.cpp
index ea72f36b..fe94c51c 100644
--- a/mpp/base/mpp_enc_cfg.cpp
+++ b/mpp/base/mpp_enc_cfg.cpp
@@ -177,13 +177,13 @@ RK_U32 mpp_enc_cfg_debug = 0;
     ENTRY(h264, dblk_disable,   S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_DEBLOCKING,     codec.h264, deblock_disable) \
     ENTRY(h264, dblk_alpha,     S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_DEBLOCKING,     codec.h264, deblock_offset_alpha) \
     ENTRY(h264, dblk_beta,      S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_DEBLOCKING,     codec.h264, deblock_offset_beta) \
-    ENTRY(h264, qp_init,        S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_QP_LIMIT,       codec.h264, qp_init) \
-    ENTRY(h264, qp_max,         S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_QP_LIMIT,       codec.h264, qp_max) \
-    ENTRY(h264, qp_min,         S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_QP_LIMIT,       codec.h264, qp_min) \
-    ENTRY(h264, qp_max_i,       S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_QP_LIMIT_I,     codec.h264, qp_max_i) \
-    ENTRY(h264, qp_min_i,       S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_QP_LIMIT_I,     codec.h264, qp_min_i) \
-    ENTRY(h264, qp_step,        S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_MAX_QP_STEP,    codec.h264, qp_max_step) \
-    ENTRY(h264, qp_delta_ip,    S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_QP_DELTA,       codec.h264, qp_delta_ip) \
+    ENTRY(h264, qp_init,        S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_INIT,          rc, qp_init) \
+    ENTRY(h264, qp_min,         S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE,         rc, qp_min) \
+    ENTRY(h264, qp_max,         S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE,         rc, qp_max) \
+    ENTRY(h264, qp_min_i,       S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE_I,       rc, qp_min_i) \
+    ENTRY(h264, qp_max_i,       S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE_I,       rc, qp_max_i) \
+    ENTRY(h264, qp_step,        S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_MAX_STEP,      rc, qp_max_step) \
+    ENTRY(h264, qp_delta_ip,    S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_IP,            rc, qp_delta_ip) \
     ENTRY(h264, max_tid,        S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_MAX_TID,        codec.h264, max_tid) \
     ENTRY(h264, max_ltr,        S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_MAX_LTR,        codec.h264, max_ltr_frames) \
     ENTRY(h264, prefix_mode,    S32, RK_S32,            MPP_ENC_H264_CFG_CHANGE_ADD_PREFIX,     codec.h264, prefix_mode) \
@@ -197,21 +197,22 @@ RK_U32 mpp_enc_cfg_debug = 0;
     ENTRY(h265, dblk_disable,   U32, RK_U32,            MPP_ENC_H265_CFG_DBLK_CHANGE,                   codec.h265, dblk_cfg.slice_deblocking_filter_disabled_flag) \
     ENTRY(h265, dblk_alpha,     S32, RK_S32,            MPP_ENC_H265_CFG_DBLK_CHANGE,                   codec.h265, dblk_cfg.slice_beta_offset_div2) \
     ENTRY(h265, dblk_beta,      S32, RK_S32,            MPP_ENC_H265_CFG_DBLK_CHANGE,                   codec.h265, dblk_cfg.slice_tc_offset_div2) \
-    ENTRY(h265, qp_init,        S32, RK_S32,            MPP_ENC_H265_CFG_RC_QP_CHANGE,                  codec.h265, qp_init) \
-    ENTRY(h265, qp_max,         S32, RK_S32,            MPP_ENC_H265_CFG_RC_QP_CHANGE,                  codec.h265, max_qp) \
-    ENTRY(h265, qp_min,         S32, RK_S32,            MPP_ENC_H265_CFG_RC_QP_CHANGE,                  codec.h265, min_qp) \
-    ENTRY(h265, qp_max_i,       S32, RK_S32,            MPP_ENC_H265_CFG_RC_I_QP_CHANGE,                codec.h265, max_i_qp) \
-    ENTRY(h265, qp_min_i,       S32, RK_S32,            MPP_ENC_H265_CFG_RC_I_QP_CHANGE,                codec.h265, min_i_qp) \
-    ENTRY(h265, qp_step,        S32, RK_S32,            MPP_ENC_H265_CFG_RC_MAX_QP_STEP_CHANGE,         codec.h265, qp_max_step) \
-    ENTRY(h265, qp_delta_ip,    S32, RK_S32,            MPP_ENC_H265_CFG_RC_IP_DELTA_QP_CHANGE,         codec.h265, ip_qp_delta) \
+    ENTRY(h265, qp_init,        S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_INIT,          rc, qp_init) \
+    ENTRY(h265, qp_min,         S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE,         rc, qp_min) \
+    ENTRY(h265, qp_max,         S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE,         rc, qp_max) \
+    ENTRY(h265, qp_min_i,       S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE_I,       rc, qp_min_i) \
+    ENTRY(h265, qp_max_i,       S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE_I,       rc, qp_max_i) \
+    ENTRY(h265, qp_step,        S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_MAX_STEP,      rc, qp_max_step) \
+    ENTRY(h265, qp_delta_ip,    S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_IP,            rc, qp_delta_ip) \
     /* vp8 config */ \
-    ENTRY(vp8, qp_init,         S32, RK_S32,            MPP_ENC_VP8_CFG_CHANGE_QP,              codec.vp8, qp_init) \
-    ENTRY(vp8, qp_max,          S32, RK_S32,            MPP_ENC_VP8_CFG_CHANGE_QP,              codec.vp8, qp_max) \
-    ENTRY(vp8, qp_min,          S32, RK_S32,            MPP_ENC_VP8_CFG_CHANGE_QP,              codec.vp8, qp_min) \
-    ENTRY(vp8, qp_max_i,        S32, RK_S32,            MPP_ENC_VP8_CFG_CHANGE_QP,              codec.vp8, qp_max_i) \
-    ENTRY(vp8, qp_min_i,        S32, RK_S32,            MPP_ENC_VP8_CFG_CHANGE_QP,              codec.vp8, qp_min_i) \
-    ENTRY(vp8, qp_step,         S32, RK_S32,            0,                                      codec.vp8, qp_max_step) \
-    ENTRY(vp8, disable_ivf,     S32, RK_S32,            MPP_ENC_VP8_CFG_CHANGE_DIS_IVF,         codec.vp8, disable_ivf) \
+    ENTRY(vp8,  qp_init,        S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_INIT,          rc, qp_init) \
+    ENTRY(vp8,  qp_min,         S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE,         rc, qp_min) \
+    ENTRY(vp8,  qp_max,         S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE,         rc, qp_max) \
+    ENTRY(vp8,  qp_min_i,       S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE_I,       rc, qp_min_i) \
+    ENTRY(vp8,  qp_max_i,       S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_RANGE_I,       rc, qp_max_i) \
+    ENTRY(vp8,  qp_step,        S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_MAX_STEP,      rc, qp_max_step) \
+    ENTRY(vp8,  qp_delta_ip,    S32, RK_S32,            MPP_ENC_RC_CFG_CHANGE_QP_IP,            rc, qp_delta_ip) \
+    ENTRY(vp8,  disable_ivf,    S32, RK_S32,            MPP_ENC_VP8_CFG_CHANGE_DIS_IVF,         codec.vp8, disable_ivf) \
     /* jpeg config */ \
     ENTRY(jpeg, quant,          S32, RK_S32,            MPP_ENC_JPEG_CFG_CHANGE_QP,             codec.jpeg, quant) \
     ENTRY(jpeg, qtable_y,       Ptr, RK_U8*,            MPP_ENC_JPEG_CFG_CHANGE_QTABLE,         codec.jpeg, qtable_y) \
diff --git a/mpp/codec/enc/h264/h264e_api_v2.c b/mpp/codec/enc/h264/h264e_api_v2.c
index 27e68cdf..bdeca78c 100644
--- a/mpp/codec/enc/h264/h264e_api_v2.c
+++ b/mpp/codec/enc/h264/h264e_api_v2.c
@@ -98,13 +98,6 @@ static void init_h264e_cfg_set(MppEncCfgSet *cfg, MppClientType type)
     memset(h264, 0, sizeof(*h264));
     h264->profile = H264_PROFILE_BASELINE;
     h264->level = H264_LEVEL_3_1;
-    h264->qp_init = 26;
-    h264->qp_max = 48;
-    h264->qp_min = 8;
-    /* default max/min intra qp is not set */
-    h264->qp_max_i = 0;
-    h264->qp_min_i = 0;
-    h264->qp_delta_ip = 4;
 
     switch (type) {
     case VPU_CLIENT_VEPU1 :
@@ -167,6 +160,13 @@ static void init_h264e_cfg_set(MppEncCfgSet *cfg, MppClientType type)
     rc_cfg->max_i_prop = 30;
     rc_cfg->min_i_prop = 10;
     rc_cfg->init_ip_ratio = 480;
+    rc_cfg->qp_init = 26;
+    rc_cfg->qp_max = 48;
+    rc_cfg->qp_min = 8;
+    /* default max/min intra qp is not set */
+    rc_cfg->qp_max_i = 0;
+    rc_cfg->qp_min_i = 0;
+    rc_cfg->qp_delta_ip = 4;
 }
 
 static void h264e_add_syntax(H264eCtx *ctx, H264eSyntaxType type, void *p)
@@ -320,123 +320,6 @@ static MPP_RET h264e_proc_prep_cfg(MppEncPrepCfg *dst, MppEncPrepCfg *src)
     return ret;
 }
 
-static MPP_RET h264e_proc_rc_cfg(MppEncRcCfg *dst, MppEncRcCfg *src, MppEncH264Cfg *h264)
-{
-    MPP_RET ret = MPP_OK;
-    RK_U32 change = src->change;
-
-    if (change) {
-        MppEncRcCfg bak = *dst;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_RC_MODE)
-            dst->rc_mode = src->rc_mode;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_QUALITY)
-            dst->quality = src->quality;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_BPS) {
-            dst->bps_target = src->bps_target;
-            dst->bps_max = src->bps_max;
-            dst->bps_min = src->bps_min;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_FPS_IN) {
-            dst->fps_in_flex = src->fps_in_flex;
-            dst->fps_in_num = src->fps_in_num;
-            dst->fps_in_denorm = src->fps_in_denorm;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_FPS_OUT) {
-            dst->fps_out_flex = src->fps_out_flex;
-            dst->fps_out_num = src->fps_out_num;
-            dst->fps_out_denorm = src->fps_out_denorm;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_GOP)
-            dst->gop = src->gop;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_MAX_REENC)
-            dst->max_reenc_times = src->max_reenc_times;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_DROP_FRM) {
-            dst->drop_mode = src->drop_mode;
-            dst->drop_threshold = src->drop_threshold;
-            dst->drop_gap = src->drop_gap;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_PRIORITY) {
-            if (src->rc_priority >= MPP_ENC_RC_PRIORITY_BUTT) {
-                mpp_err("invalid rc_priority %d should be[%d, %d] \n",
-                        src->rc_priority, MPP_ENC_RC_BY_BITRATE_FIRST, MPP_ENC_RC_PRIORITY_BUTT);
-                ret = MPP_ERR_VALUE;
-            }
-            dst->rc_priority = src->rc_priority;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_SUPER_FRM) {
-            if (src->super_mode >= MPP_ENC_RC_SUPER_FRM_BUTT) {
-                mpp_err("invalid super_mode %d should be[%d, %d] \n",
-                        src->super_mode, MPP_ENC_RC_SUPER_FRM_NONE, MPP_ENC_RC_SUPER_FRM_BUTT);
-                ret = MPP_ERR_VALUE;
-            }
-            dst->super_mode = src->super_mode;
-            dst->super_i_thd = src->super_i_thd;
-            dst->super_p_thd = src->super_p_thd;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_MAX_I_PROP)
-            dst->max_i_prop = src->max_i_prop;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_MIN_I_PROP)
-            dst->min_i_prop = src->min_i_prop;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_INIT_IP_RATIO)
-            dst->init_ip_ratio = src->init_ip_ratio;
-
-        // parameter checking
-        if (dst->rc_mode >= MPP_ENC_RC_MODE_BUTT) {
-            mpp_err("invalid rc mode %d should be RC_MODE_VBR or RC_MODE_CBR\n",
-                    src->rc_mode);
-            ret = MPP_ERR_VALUE;
-        }
-        if (dst->quality >= MPP_ENC_RC_QUALITY_BUTT) {
-            mpp_err("invalid quality %d should be from QUALITY_WORST to QUALITY_BEST\n",
-                    dst->quality);
-            ret = MPP_ERR_VALUE;
-        }
-        if (dst->rc_mode != MPP_ENC_RC_MODE_FIXQP) {
-            if ((dst->bps_target >= 100 * SZ_1M || dst->bps_target <= 1 * SZ_1K) ||
-                (dst->bps_max    >= 100 * SZ_1M || dst->bps_max    <= 1 * SZ_1K) ||
-                (dst->bps_min    >= 100 * SZ_1M || dst->bps_min    <= 1 * SZ_1K)) {
-                mpp_err("invalid bit per second %d [%d:%d] out of range 1K~100M\n",
-                        dst->bps_target, dst->bps_min, dst->bps_max);
-                ret = MPP_ERR_VALUE;
-            }
-        }
-        if (dst->drop_mode == MPP_ENC_RC_DROP_FRM_PSKIP &&
-            dst->drop_gap == 0 &&
-            h264->poc_type == 2) {
-            mpp_err("poc type 2 is ocnflict with successive non-reference pskip mode\n");
-            mpp_err("set drop gap to 1\n");
-            dst->drop_gap = 1;
-        }
-
-        dst->change |= change;
-
-        if (ret) {
-            mpp_err_f("failed to accept new rc config\n");
-            *dst = bak;
-        } else {
-            mpp_log("MPP_ENC_SET_RC_CFG bps %d [%d : %d] fps [%d:%d] gop %d\n",
-                    dst->bps_target, dst->bps_min, dst->bps_max,
-                    dst->fps_in_num, dst->fps_out_num, dst->gop);
-        }
-    }
-
-    src->change = 0;
-    return ret;
-}
-
 static MPP_RET h264e_proc_h264_cfg(MppEncH264Cfg *dst, MppEncH264Cfg *src)
 {
     MPP_RET ret = MPP_OK;
@@ -508,32 +391,6 @@ static MPP_RET h264e_proc_h264_cfg(MppEncH264Cfg *dst, MppEncH264Cfg *src)
         dst->change |= MPP_ENC_H264_CFG_CHANGE_SCALING_LIST;
     }
 
-    if ((change & MPP_ENC_H264_CFG_CHANGE_QP_LIMIT) &&
-        ((dst->qp_init != src->qp_init) ||
-         (dst->qp_max != src->qp_max) ||
-         (dst->qp_min != src->qp_min))) {
-        dst->qp_init = src->qp_init;
-        dst->qp_max = src->qp_max;
-        dst->qp_min = src->qp_min;
-        dst->change |= MPP_ENC_H264_CFG_CHANGE_QP_LIMIT;
-    }
-    if ((change & MPP_ENC_H264_CFG_CHANGE_QP_LIMIT_I) &&
-        ((dst->qp_max_i != src->qp_max_i) ||
-         (dst->qp_min_i != src->qp_min_i))) {
-        dst->qp_max_i = src->qp_max_i ? src->qp_max_i : src->qp_max;
-        dst->qp_min_i = src->qp_min_i ? src->qp_min_i : src->qp_min;
-        dst->change |= MPP_ENC_H264_CFG_CHANGE_QP_LIMIT_I;
-    }
-    if ((change & MPP_ENC_H264_CFG_CHANGE_MAX_QP_STEP) &&
-        (dst->qp_max_step != src->qp_max_step)) {
-        dst->qp_max_step = src->qp_max_step;
-        dst->change |= MPP_ENC_H264_CFG_CHANGE_MAX_QP_STEP;
-    }
-    if ((change & MPP_ENC_H264_CFG_CHANGE_QP_DELTA) &&
-        (dst->qp_delta_ip != src->qp_delta_ip)) {
-        dst->qp_delta_ip = src->qp_delta_ip;
-        dst->change |= MPP_ENC_H264_CFG_CHANGE_QP_DELTA;
-    }
     if ((change & MPP_ENC_H264_CFG_CHANGE_INTRA_REFRESH) &&
         ((dst->intra_refresh_mode != src->intra_refresh_mode) ||
          (dst->intra_refresh_arg != src->intra_refresh_arg))) {
@@ -589,6 +446,20 @@ static MPP_RET h264e_proc_split_cfg(MppEncSliceSplit *dst, MppEncSliceSplit *src
     return ret;
 }
 
+static void h264e_check_cfg(MppEncCfgSet *cfg)
+{
+    MppEncRcCfg *rc = &cfg->rc;
+    MppEncH264Cfg *h264 = &cfg->codec.h264;
+
+    if (rc->drop_mode == MPP_ENC_RC_DROP_FRM_PSKIP &&
+        rc->drop_gap == 0 &&
+        h264->poc_type == 2) {
+        mpp_err("poc type 2 is ocnflict with successive non-reference pskip mode\n");
+        mpp_err("set drop gap to 1\n");
+        rc->drop_gap = 1;
+    }
+}
+
 static MPP_RET h264e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
 {
     MPP_RET ret = MPP_OK;
@@ -608,18 +479,12 @@ static MPP_RET h264e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
         if (src->codec.h264.change)
             ret |= h264e_proc_h264_cfg(&cfg->codec.h264, &src->codec.h264);
 
-        if (src->rc.change)
-            ret |= h264e_proc_rc_cfg(&cfg->rc, &src->rc, &cfg->codec.h264);
-
         if (src->split.change)
             ret |= h264e_proc_split_cfg(&cfg->split, &src->split);
     } break;
     case MPP_ENC_SET_PREP_CFG : {
         ret = h264e_proc_prep_cfg(&cfg->prep, param);
     } break;
-    case MPP_ENC_SET_RC_CFG : {
-        ret = h264e_proc_rc_cfg(&cfg->rc, param, &cfg->codec.h264);
-    } break;
     case MPP_ENC_SET_CODEC_CFG : {
         MppEncCodecCfg *codec = (MppEncCodecCfg *)param;
         ret = h264e_proc_h264_cfg(&cfg->codec.h264, &codec->h264);
@@ -635,6 +500,8 @@ static MPP_RET h264e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
         break;
     }
 
+    h264e_check_cfg(cfg);
+
     h264e_dbg_func("leave ret %d\n", ret);
 
     return ret;
diff --git a/mpp/codec/enc/h265/h265e_api.c b/mpp/codec/enc/h265/h265e_api.c
index 0d6afbcb..a083b4eb 100644
--- a/mpp/codec/enc/h265/h265e_api.c
+++ b/mpp/codec/enc/h265/h265e_api.c
@@ -74,7 +74,6 @@ static MPP_RET h265e_init(void *ctx, EncImplCfg *ctrlCfg)
     h265->ip_qp_delta = 5;
     h265->raw_dealt_qp = 4;
     h265->max_delta_qp = 10;
-    h265->const_intra_pred = 0;
     h265->gop_delta_qp = 0;
     h265->intra_refresh_mode = 0;
     h265->intra_refresh_arg = 0;
@@ -146,6 +145,13 @@ static MPP_RET h265e_init(void *ctx, EncImplCfg *ctrlCfg)
     rc_cfg->max_i_prop = 30;
     rc_cfg->min_i_prop = 10;
     rc_cfg->init_ip_ratio = 480;
+    rc_cfg->qp_init = 26;
+    rc_cfg->qp_max = 51;
+    rc_cfg->qp_min = 10;
+    rc_cfg->qp_max_i = 51;
+    rc_cfg->qp_min_i = 15;
+    rc_cfg->qp_delta_ip = 4;
+    rc_cfg->qp_delta_vi = 2;
 
     INIT_LIST_HEAD(&p->rc_list);
 
@@ -388,121 +394,6 @@ static MPP_RET h265e_proc_prep_cfg(MppEncPrepCfg *dst, MppEncPrepCfg *src)
     return MPP_OK;
 }
 
-static MPP_RET h265e_proc_rc_cfg(MppEncRcCfg *dst, MppEncRcCfg *src)
-{
-    MPP_RET ret = MPP_OK;
-    RK_U32 change = src->change;
-
-    if (change) {
-        MppEncRcCfg bak = *dst;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_RC_MODE)
-            dst->rc_mode = src->rc_mode;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_QUALITY)
-            dst->quality = src->quality;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_BPS) {
-            dst->bps_target = src->bps_target;
-            dst->bps_max = src->bps_max;
-            dst->bps_min = src->bps_min;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_FPS_IN) {
-            dst->fps_in_flex = src->fps_in_flex;
-            dst->fps_in_num = src->fps_in_num;
-            dst->fps_in_denorm = src->fps_in_denorm;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_FPS_OUT) {
-            dst->fps_out_flex = src->fps_out_flex;
-            dst->fps_out_num = src->fps_out_num;
-            dst->fps_out_denorm = src->fps_out_denorm;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_GOP)
-            dst->gop = src->gop;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_MAX_REENC)
-            dst->max_reenc_times = src->max_reenc_times;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_DROP_FRM) {
-            dst->drop_mode = src->drop_mode;
-            dst->drop_threshold = src->drop_threshold;
-            dst->drop_gap = src->drop_gap;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_PRIORITY) {
-            if (src->rc_priority >= MPP_ENC_RC_PRIORITY_BUTT) {
-                mpp_err("invalid rc_priority %d should be[%d, %d] \n",
-                        src->rc_priority, MPP_ENC_RC_BY_BITRATE_FIRST, MPP_ENC_RC_PRIORITY_BUTT);
-                ret = MPP_ERR_VALUE;
-            }
-            dst->rc_priority = src->rc_priority;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_SUPER_FRM) {
-            if (src->super_mode >= MPP_ENC_RC_SUPER_FRM_BUTT) {
-                mpp_err("invalid super_mode %d should be[%d, %d] \n",
-                        src->super_mode, MPP_ENC_RC_SUPER_FRM_NONE, MPP_ENC_RC_SUPER_FRM_BUTT);
-                ret = MPP_ERR_VALUE;
-            }
-            dst->super_mode = src->super_mode;
-            dst->super_i_thd = src->super_i_thd;
-            dst->super_p_thd = src->super_p_thd;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_MAX_I_PROP)
-            dst->max_i_prop = src->max_i_prop;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_MIN_I_PROP)
-            dst->min_i_prop = src->min_i_prop;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_INIT_IP_RATIO)
-            dst->init_ip_ratio = src->init_ip_ratio;
-
-        // parameter checking
-        if (dst->rc_mode >= MPP_ENC_RC_MODE_BUTT) {
-            mpp_err("invalid rc mode %d should be RC_MODE_VBR or RC_MODE_CBR\n",
-                    src->rc_mode);
-            ret = MPP_ERR_VALUE;
-        }
-        if (dst->quality >= MPP_ENC_RC_QUALITY_BUTT) {
-            mpp_err("invalid quality %d should be from QUALITY_WORST to QUALITY_BEST\n",
-                    dst->quality);
-            ret = MPP_ERR_VALUE;
-        }
-        if (dst->rc_mode != MPP_ENC_RC_MODE_FIXQP) {
-            if ((dst->bps_target >= 100 * SZ_1M || dst->bps_target <= 1 * SZ_1K) ||
-                (dst->bps_max    >= 100 * SZ_1M || dst->bps_max    <= 1 * SZ_1K) ||
-                (dst->bps_min    >= 100 * SZ_1M || dst->bps_min    <= 1 * SZ_1K)) {
-                mpp_err("invalid bit per second %d [%d:%d] out of range 1K~100M\n",
-                        dst->bps_target, dst->bps_min, dst->bps_max);
-                ret = MPP_ERR_VALUE;
-            }
-
-            if ((dst->bps_target > dst->bps_max || dst->bps_target < dst->bps_min) ||
-                (dst->bps_max    < dst->bps_min)) {
-                mpp_err("invalid bit rate config %d [%d:%d] for size relationship\n",
-                        dst->bps_target, dst->bps_min, dst->bps_max);
-                ret = MPP_ERR_VALUE;
-            }
-        }
-
-        dst->change |= change;
-
-        if (ret) {
-            mpp_err_f("failed to accept new rc config\n");
-            *dst = bak;
-        } else {
-            mpp_log_f("MPP_ENC_SET_RC_CFG bps %d [%d : %d] fps [%d:%d] gop %d\n",
-                      dst->bps_target, dst->bps_min, dst->bps_max,
-                      dst->fps_in_num, dst->fps_out_num, dst->gop);
-        }
-    }
-
-    return ret;
-}
 
 static MPP_RET h265e_proc_h265_cfg(MppEncH265Cfg *dst, MppEncH265Cfg *src)
 {
@@ -543,23 +434,6 @@ static MPP_RET h265e_proc_h265_cfg(MppEncH265Cfg *dst, MppEncH265Cfg *src)
         memcpy(&dst->vui, &src->vui, sizeof(src->vui));
     }
 
-    if (change & MPP_ENC_H265_CFG_RC_QP_CHANGE) {
-        dst->qp_init = src->qp_init;
-        dst->max_qp = src->max_qp;
-        dst->min_qp = src->min_qp;
-    }
-
-    if (change & MPP_ENC_H265_CFG_RC_I_QP_CHANGE) {
-        dst->max_i_qp = src->max_i_qp;
-        dst->min_i_qp = src->min_i_qp;
-    }
-
-    if (change & MPP_ENC_H265_CFG_RC_MAX_QP_STEP_CHANGE)
-        dst->max_delta_qp = src->max_delta_qp;
-
-    if (change & MPP_ENC_H265_CFG_RC_IP_DELTA_QP_CHANGE)
-        dst->ip_qp_delta = src->ip_qp_delta;
-
     /*
      * NOTE: use OR here for avoiding overwrite on multiple config
      * When next encoding is trigger the change flag will be clear
@@ -601,10 +475,7 @@ static MPP_RET h265e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
             ret |= h265e_proc_prep_cfg(&cfg->prep, &src->prep);
             src->prep.change = 0;
         }
-        if (src->rc.change) {
-            ret |= h265e_proc_rc_cfg(&cfg->rc, &src->rc);
-            src->rc.change = 0;
-        }
+
         if (src->codec.h265.change) {
             ret |= h265e_proc_h265_cfg(&cfg->codec.h265, &src->codec.h265);
             src->codec.h265.change = 0;
@@ -624,12 +495,9 @@ static MPP_RET h265e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
     } break;
     case MPP_ENC_SET_CODEC_CFG: {
         MppEncCodecCfg *codec = (MppEncCodecCfg *)param;
-
         ret = h265e_proc_h265_cfg(&cfg->codec.h265, &codec->h265);
     } break;
-    case MPP_ENC_SET_RC_CFG : {
-        ret = h265e_proc_rc_cfg(&cfg->rc, param);
-    } break;
+
     case MPP_ENC_SET_SEI_CFG: {
     } break;
     case MPP_ENC_SET_SPLIT : {
diff --git a/mpp/codec/enc/vp8/vp8e_api_v2.c b/mpp/codec/enc/vp8/vp8e_api_v2.c
index a647cf81..9fcc23fa 100644
--- a/mpp/codec/enc/vp8/vp8e_api_v2.c
+++ b/mpp/codec/enc/vp8/vp8e_api_v2.c
@@ -208,80 +208,6 @@ static MPP_RET vp8e_proc_split_cfg(MppEncSliceSplit *dst, MppEncSliceSplit *src)
     return ret;
 }
 
-static MPP_RET vp8e_proc_rc_cfg(MppEncRcCfg *dst, MppEncRcCfg *src)
-{
-    MPP_RET ret = MPP_OK;
-    RK_U32 change = src->change;
-    vp8e_dbg_cfg("set rc cfg change %d\n", change);
-    if (change) {
-        MppEncRcCfg bak = *dst;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_RC_MODE)
-            dst->rc_mode = src->rc_mode;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_QUALITY)
-            dst->quality = src->quality;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_BPS) {
-            dst->bps_target = src->bps_target;
-            dst->bps_max = src->bps_max;
-            dst->bps_min = src->bps_min;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_FPS_IN) {
-            dst->fps_in_flex = src->fps_in_flex;
-            dst->fps_in_num = src->fps_in_num;
-            dst->fps_in_denorm = src->fps_in_denorm;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_FPS_OUT) {
-            dst->fps_out_flex = src->fps_out_flex;
-            dst->fps_out_num = src->fps_out_num;
-            dst->fps_out_denorm = src->fps_out_denorm;
-        }
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_GOP)
-            dst->gop = src->gop;
-
-        if (change & MPP_ENC_RC_CFG_CHANGE_MAX_REENC)
-            dst->max_reenc_times = src->max_reenc_times;
-
-        // parameter checking
-        if (dst->rc_mode >= MPP_ENC_RC_MODE_BUTT) {
-            mpp_err("invalid rc mode %d should be RC_MODE_VBR or RC_MODE_CBR\n",
-                    src->rc_mode);
-            ret = MPP_ERR_VALUE;
-        }
-        if (dst->quality >= MPP_ENC_RC_QUALITY_BUTT) {
-            mpp_err("invalid quality %d should be from QUALITY_WORST to QUALITY_BEST\n",
-                    dst->quality);
-            ret = MPP_ERR_VALUE;
-        }
-        if (dst->rc_mode != MPP_ENC_RC_MODE_FIXQP) {
-            if ((dst->bps_target >= 100 * SZ_1M || dst->bps_target <= 1 * SZ_1K) ||
-                (dst->bps_max    >= 100 * SZ_1M || dst->bps_max    <= 1 * SZ_1K) ||
-                (dst->bps_min    >= 100 * SZ_1M || dst->bps_min    <= 1 * SZ_1K)) {
-                mpp_err("invalid bit per second %d [%d:%d] out of range 1K~100M\n",
-                        dst->bps_target, dst->bps_min, dst->bps_max);
-                ret = MPP_ERR_VALUE;
-            }
-        }
-
-        dst->change |= change;
-
-        if (ret) {
-            mpp_err_f("failed to accept new rc config\n");
-            *dst = bak;
-        } else {
-            vp8e_dbg_cfg("MPP_ENC_SET_RC_CFG bps %d [%d : %d] fps [%d:%d] gop %d\n",
-                         dst->bps_target, dst->bps_min, dst->bps_max,
-                         dst->fps_in_num, dst->fps_out_num, dst->gop);
-        }
-    }
-
-    return ret;
-}
-
 static MPP_RET vp8e_proc_vp8_cfg(MppEncVp8Cfg *dst, MppEncVp8Cfg *src)
 {
     RK_U32 change = src->change;
@@ -317,10 +243,6 @@ static MPP_RET vp8e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
             ret |= vp8e_proc_prep_cfg(&cfg->prep, &src->prep);
             src->prep.change = 0;
         }
-        if (src->rc.change) {
-            ret |= vp8e_proc_rc_cfg(&cfg->rc, &src->rc);
-            src->rc.change = 0;
-        }
         if (src->codec.vp8.change) {
             ret |= vp8e_proc_vp8_cfg(&cfg->codec.vp8, &src->codec.vp8);
             src->codec.vp8.change = 0;
@@ -330,10 +252,6 @@ static MPP_RET vp8e_proc_cfg(void *ctx, MpiCmd cmd, void *param)
             src->split.change = 0;
         }
     } break;
-    case MPP_ENC_SET_RC_CFG : {
-        vp8e_dbg_cfg("update vp8e rc config");
-        ret |= vp8e_proc_rc_cfg(&cfg->rc, &src->rc);
-    } break;
     default: {
         mpp_err("No correspond cmd found, and can not config!");
         ret = MPP_NOK;
diff --git a/mpp/codec/mpp_enc_impl.cpp b/mpp/codec/mpp_enc_impl.cpp
index bb9c04d3..91ad1bad 100644
--- a/mpp/codec/mpp_enc_impl.cpp
+++ b/mpp/codec/mpp_enc_impl.cpp
@@ -264,28 +264,17 @@ static MPP_RET check_enc_task_wait(MppEncImpl *enc, EncTask *task)
 
 static RK_S32 check_codec_to_resend_hdr(MppEncCodecCfg *codec)
 {
-    MppCodingType coding = codec->coding;
-    RK_U32 skip_flag = 0;
-
-    switch (coding) {
+    switch (codec->coding) {
     case MPP_VIDEO_CodingAVC : {
-        MppEncH264Cfg *h264 = &codec->h264;
-
-        skip_flag = MPP_ENC_H264_CFG_CHANGE_QP_LIMIT | MPP_ENC_H264_CFG_CHANGE_MAX_TID;
-
-        if (h264->change & (~skip_flag))
+        if (codec->h264.change)
             return 1;
     } break;
     case MPP_VIDEO_CodingHEVC : {
-        MppEncH265Cfg *h265 = &codec->h265;
-        if (h265->change & (~MPP_ENC_H265_CFG_RC_QP_CHANGE))
+        if (codec->h265.change)
             return 1;
-    }
-    break;
-    case MPP_VIDEO_CodingVP8 : {
-    } break;
-    case MPP_VIDEO_CodingMJPEG : {
     } break;
+    case MPP_VIDEO_CodingVP8 :
+    case MPP_VIDEO_CodingMJPEG :
     default : {
     } break;
     }
@@ -362,39 +351,6 @@ static RK_S32 check_resend_hdr(MpiCmd cmd, void *param, MppEncCfgSet *cfg)
     return resend;
 }
 
-static RK_S32 check_codec_to_rc_cfg_update(MppEncCodecCfg *codec)
-{
-    MppCodingType coding = codec->coding;
-
-    switch (coding) {
-    case MPP_VIDEO_CodingAVC : {
-        MppEncH264Cfg *h264 = &codec->h264;
-        if (h264->change &
-            (MPP_ENC_H264_CFG_CHANGE_QP_LIMIT |
-             MPP_ENC_H264_CFG_CHANGE_QP_LIMIT_I |
-             MPP_ENC_H264_CFG_CHANGE_QP_DELTA))
-            return 1;
-    } break;
-    case MPP_VIDEO_CodingHEVC : {
-        MppEncH265Cfg *h265 = &codec->h265;
-        if (h265->change &
-            (MPP_ENC_H265_CFG_RC_QP_CHANGE |
-             MPP_ENC_H265_CFG_RC_I_QP_CHANGE |
-             MPP_ENC_H265_CFG_RC_MAX_QP_STEP_CHANGE |
-             MPP_ENC_H265_CFG_RC_IP_DELTA_QP_CHANGE))
-            return 1;
-    } break;
-    case MPP_VIDEO_CodingVP8 : {
-    } break;
-    case MPP_VIDEO_CodingMJPEG : {
-    } break;
-    default : {
-    } break;
-    }
-
-    return 0;
-}
-
 static RK_S32 check_rc_cfg_update(MpiCmd cmd, MppEncCfgSet *cfg)
 {
     if (cmd == MPP_ENC_SET_RC_CFG ||
@@ -403,11 +359,6 @@ static RK_S32 check_rc_cfg_update(MpiCmd cmd, MppEncCfgSet *cfg)
         return 1;
     }
 
-    if (cmd == MPP_ENC_SET_CODEC_CFG) {
-        if (check_codec_to_rc_cfg_update(&cfg->codec))
-            return 1;
-    }
-
     if (cmd == MPP_ENC_SET_CFG) {
         RK_U32 change = cfg->prep.change;
         RK_U32 check_flag = MPP_ENC_PREP_CFG_CHANGE_INPUT |
@@ -417,17 +368,13 @@ static RK_S32 check_rc_cfg_update(MpiCmd cmd, MppEncCfgSet *cfg)
             return 1;
 
         change = cfg->rc.change;
-        check_flag = MPP_ENC_RC_CFG_CHANGE_RC_MODE |
-                     MPP_ENC_RC_CFG_CHANGE_BPS |
-                     MPP_ENC_RC_CFG_CHANGE_FPS_IN |
-                     MPP_ENC_RC_CFG_CHANGE_FPS_OUT |
-                     MPP_ENC_RC_CFG_CHANGE_GOP;
+        check_flag = MPP_ENC_RC_CFG_CHANGE_ALL &
+                     (~MPP_ENC_RC_CFG_CHANGE_QUALITY |
+                      MPP_ENC_RC_CFG_CHANGE_AQ_THRD_I |
+                      MPP_ENC_RC_CFG_CHANGE_AQ_THRD_P);
 
         if (change & check_flag)
             return 1;
-
-        if (check_codec_to_rc_cfg_update(&cfg->codec))
-            return 1;
     }
 
     return 0;
@@ -471,6 +418,137 @@ static RK_S32 check_low_delay_part_mode(MppEncImpl *enc)
     return 1;
 }
 
+MPP_RET mpp_enc_proc_rc_cfg(MppEncRcCfg *dst, MppEncRcCfg *src)
+{
+    MPP_RET ret = MPP_OK;
+    RK_U32 change = src->change;
+
+    if (change) {
+        MppEncRcCfg bak = *dst;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_RC_MODE)
+            dst->rc_mode = src->rc_mode;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_QUALITY)
+            dst->quality = src->quality;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_BPS) {
+            dst->bps_target = src->bps_target;
+            dst->bps_max = src->bps_max;
+            dst->bps_min = src->bps_min;
+        }
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_FPS_IN) {
+            dst->fps_in_flex = src->fps_in_flex;
+            dst->fps_in_num = src->fps_in_num;
+            dst->fps_in_denorm = src->fps_in_denorm;
+        }
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_FPS_OUT) {
+            dst->fps_out_flex = src->fps_out_flex;
+            dst->fps_out_num = src->fps_out_num;
+            dst->fps_out_denorm = src->fps_out_denorm;
+        }
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_GOP)
+            dst->gop = src->gop;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_MAX_REENC)
+            dst->max_reenc_times = src->max_reenc_times;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_DROP_FRM) {
+            dst->drop_mode = src->drop_mode;
+            dst->drop_threshold = src->drop_threshold;
+            dst->drop_gap = src->drop_gap;
+        }
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_PRIORITY) {
+            if (src->rc_priority >= MPP_ENC_RC_PRIORITY_BUTT) {
+                mpp_err("invalid rc_priority %d should be[%d, %d] \n",
+                        src->rc_priority, MPP_ENC_RC_BY_BITRATE_FIRST, MPP_ENC_RC_PRIORITY_BUTT);
+                ret = MPP_ERR_VALUE;
+            }
+            dst->rc_priority = src->rc_priority;
+        }
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_SUPER_FRM) {
+            if (src->super_mode >= MPP_ENC_RC_SUPER_FRM_BUTT) {
+                mpp_err("invalid super_mode %d should be[%d, %d] \n",
+                        src->super_mode, MPP_ENC_RC_SUPER_FRM_NONE, MPP_ENC_RC_SUPER_FRM_BUTT);
+                ret = MPP_ERR_VALUE;
+            }
+            dst->super_mode = src->super_mode;
+            dst->super_i_thd = src->super_i_thd;
+            dst->super_p_thd = src->super_p_thd;
+        }
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_MAX_I_PROP)
+            dst->max_i_prop = src->max_i_prop;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_MIN_I_PROP)
+            dst->min_i_prop = src->min_i_prop;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_INIT_IP_RATIO)
+            dst->init_ip_ratio = src->init_ip_ratio;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_QP_INIT)
+            dst->qp_init = src->qp_init;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_QP_RANGE) {
+            dst->qp_min = src->qp_min;
+            dst->qp_max = src->qp_max;
+        }
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_QP_RANGE_I) {
+            dst->qp_min_i = src->qp_min_i;
+            dst->qp_max_i = src->qp_max_i;
+        }
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_QP_MAX_STEP)
+            dst->qp_max_step = src->qp_max_step;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_QP_IP)
+            dst->qp_delta_ip = src->qp_delta_ip;
+
+        if (change & MPP_ENC_RC_CFG_CHANGE_QP_VI)
+            dst->qp_delta_vi = src->qp_delta_vi;
+
+        // parameter checking
+        if (dst->rc_mode >= MPP_ENC_RC_MODE_BUTT) {
+            mpp_err("invalid rc mode %d should be RC_MODE_VBR or RC_MODE_CBR\n",
+                    src->rc_mode);
+            ret = MPP_ERR_VALUE;
+        }
+        if (dst->quality >= MPP_ENC_RC_QUALITY_BUTT) {
+            mpp_err("invalid quality %d should be from QUALITY_WORST to QUALITY_BEST\n",
+                    dst->quality);
+            ret = MPP_ERR_VALUE;
+        }
+        if (dst->rc_mode != MPP_ENC_RC_MODE_FIXQP) {
+            if ((dst->bps_target >= 100 * SZ_1M || dst->bps_target <= 1 * SZ_1K) ||
+                (dst->bps_max    >= 100 * SZ_1M || dst->bps_max    <= 1 * SZ_1K) ||
+                (dst->bps_min    >= 100 * SZ_1M || dst->bps_min    <= 1 * SZ_1K)) {
+                mpp_err("invalid bit per second %d [%d:%d] out of range 1K~100M\n",
+                        dst->bps_target, dst->bps_min, dst->bps_max);
+                ret = MPP_ERR_VALUE;
+            }
+        }
+
+        dst->change |= change;
+
+        if (ret) {
+            mpp_err_f("failed to accept new rc config\n");
+            *dst = bak;
+        } else {
+            mpp_log("MPP_ENC_SET_RC_CFG bps %d [%d : %d] fps [%d:%d] gop %d\n",
+                    dst->bps_target, dst->bps_min, dst->bps_max,
+                    dst->fps_in_num, dst->fps_out_num, dst->gop);
+        }
+    }
+
+    return ret;
+}
+
 MPP_RET mpp_enc_proc_hw_cfg(MppEncHwCfg *dst, MppEncHwCfg *src)
 {
     MPP_RET ret = MPP_OK;
@@ -521,14 +599,26 @@ MPP_RET mpp_enc_proc_cfg(MppEncImpl *enc, MpiCmd cmd, void *param)
             src->base.change = 0;
         }
 
+        /* process rc cfg at mpp_enc module */
+        if (src->rc.change) {
+            ret = mpp_enc_proc_rc_cfg(&enc->cfg.rc, &src->rc);
+            src->rc.change = 0;
+        }
+
         /* process hardware cfg at mpp_enc module */
         if (src->hw.change) {
             ret = mpp_enc_proc_hw_cfg(&enc->cfg.hw, &src->hw);
             src->hw.change = 0;
         }
 
+        /* Then process the rest config */
         ret = enc_impl_proc_cfg(enc->impl, cmd, param);
     } break;
+    case MPP_ENC_SET_RC_CFG : {
+        MppEncRcCfg *src = (MppEncRcCfg *)param;
+        if (src)
+            ret = mpp_enc_proc_rc_cfg(&enc->cfg.rc, src);
+    } break;
     case MPP_ENC_GET_HDR_SYNC :
     case MPP_ENC_GET_EXTRA_INFO : {
         /*
@@ -814,34 +904,16 @@ static void set_rc_cfg(RcCfg *cfg, MppEncCfgSet *cfg_set)
 
     /* quality configure */
     switch (codec->coding) {
-    case MPP_VIDEO_CodingAVC : {
-        MppEncH264Cfg *h264 = &codec->h264;
-
-        cfg->init_quality = h264->qp_init;
-        cfg->max_quality = h264->qp_max;
-        cfg->min_quality = h264->qp_min;
-        cfg->max_i_quality = h264->qp_max_i ? h264->qp_max_i : h264->qp_max;
-        cfg->min_i_quality = h264->qp_min_i ? h264->qp_min_i : h264->qp_min;
-        cfg->i_quality_delta = h264->qp_delta_ip;
-    } break;
-    case MPP_VIDEO_CodingHEVC : {
-        MppEncH265Cfg *h265 = &codec->h265;
-
-        cfg->init_quality = h265->qp_init;
-        cfg->max_quality = h265->max_qp;
-        cfg->min_quality = h265->min_qp;
-        cfg->max_i_quality = h265->max_i_qp;
-        cfg->min_i_quality = h265->min_i_qp;
-        cfg->i_quality_delta = h265->ip_qp_delta;
-    } break;
+    case MPP_VIDEO_CodingAVC :
+    case MPP_VIDEO_CodingHEVC :
     case MPP_VIDEO_CodingVP8 : {
-        MppEncVp8Cfg *vp8 = &codec->vp8;
-
-        cfg->init_quality   = vp8->qp_init;
-        cfg->max_quality    = vp8->qp_max;
-        cfg->min_quality    = vp8->qp_min;
-        cfg->max_i_quality  = vp8->qp_max_i ? vp8->qp_max_i : vp8->qp_max;
-        cfg->min_i_quality  = vp8->qp_min_i ? vp8->qp_min_i : vp8->qp_min;
+        cfg->init_quality = rc->qp_init;
+        cfg->max_quality = rc->qp_max;
+        cfg->min_quality = rc->qp_min;
+        cfg->max_i_quality = rc->qp_max_i ? rc->qp_max_i : rc->qp_max;
+        cfg->min_i_quality = rc->qp_min_i ? rc->qp_min_i : rc->qp_min;
+        cfg->i_quality_delta = rc->qp_delta_ip;
+        cfg->vi_quality_delta = rc->qp_delta_vi;
     } break;
     case MPP_VIDEO_CodingMJPEG : {
         MppEncJpegCfg *jpeg = &codec->jpeg;
diff --git a/mpp/hal/vpu/h265e/hal_h265e_vepu22.c b/mpp/hal/vpu/h265e/hal_h265e_vepu22.c
index 984fe7fb..3e2c7493 100644
--- a/mpp/hal/vpu/h265e/hal_h265e_vepu22.c
+++ b/mpp/hal/vpu/h265e/hal_h265e_vepu22.c
@@ -1368,12 +1368,6 @@ static MPP_RET vepu22_check_code_cfg_change(HalH265eCtx* ctx, MppEncH265Cfg* set
             cfg->intra_qp = set->intra_qp;
         }
 
-        if (set->change & MPP_ENC_H265_CFG_RC_QP_CHANGE) {
-            cfg->max_qp = set->max_qp;
-            cfg->min_qp = set->min_qp;
-            cfg->max_delta_qp = set->max_delta_qp;
-        }
-
         if (set->change & MPP_ENC_H265_CFG_INTRA_REFRESH_CHANGE) {
             cfg->intra_refresh_mode = set->intra_refresh_mode;
             cfg->intra_refresh_arg = set->intra_refresh_arg;
diff --git a/test/mpi_enc_multi_test.c b/test/mpi_enc_multi_test.c
index ec6699a7..c3492107 100644
--- a/test/mpi_enc_multi_test.c
+++ b/test/mpi_enc_multi_test.c
@@ -403,6 +403,34 @@ MPP_RET test_mpp_setup(MpiEncTestData *p)
     rc_cfg->gop              = p->gop;
     rc_cfg->max_reenc_times  = 1;
 
+    if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_FIXQP) {
+        /* constant QP mode qp is fixed */
+        p->qp_max   = p->qp_init;
+        p->qp_min   = p->qp_init;
+        p->qp_step  = 0;
+    } else if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_CBR) {
+        /* constant bitrate do not limit qp range */
+        p->qp_max   = 48;
+        p->qp_min   = 4;
+        p->qp_step  = 16;
+        p->qp_init  = 0;
+    } else if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_VBR) {
+        /* variable bitrate has qp min limit */
+        p->qp_max   = 40;
+        p->qp_min   = 12;
+        p->qp_step  = 8;
+        p->qp_init  = 0;
+    }
+
+    rc_cfg->qp_max          = p->qp_max;
+    rc_cfg->qp_min          = p->qp_min;
+    rc_cfg->qp_max_i        = p->qp_max;
+    rc_cfg->qp_min_i        = p->qp_min;
+    rc_cfg->qp_init         = p->qp_init;
+    rc_cfg->qp_max_step     = p->qp_step;
+    rc_cfg->qp_delta_ip     = 4;
+    rc_cfg->qp_delta_vi     = 2;
+
     mpp_log("mpi_enc_test bps %d fps %d gop %d\n",
             rc_cfg->bps_target, rc_cfg->fps_out_num, rc_cfg->gop);
     ret = mpi->control(ctx, MPP_ENC_SET_RC_CFG, rc_cfg);
@@ -416,8 +444,7 @@ MPP_RET test_mpp_setup(MpiEncTestData *p)
     case MPP_VIDEO_CodingAVC : {
         codec_cfg->h264.change = MPP_ENC_H264_CFG_CHANGE_PROFILE |
                                  MPP_ENC_H264_CFG_CHANGE_ENTROPY |
-                                 MPP_ENC_H264_CFG_CHANGE_TRANS_8x8 |
-                                 MPP_ENC_H264_CFG_CHANGE_QP_LIMIT;
+                                 MPP_ENC_H264_CFG_CHANGE_TRANS_8x8;
         /*
          * H.264 profile_idc parameter
          * 66  - Baseline profile
@@ -437,29 +464,6 @@ MPP_RET test_mpp_setup(MpiEncTestData *p)
         codec_cfg->h264.entropy_coding_mode  = 1;
         codec_cfg->h264.cabac_init_idc  = 0;
         codec_cfg->h264.transform8x8_mode = 1;
-
-        if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_FIXQP) {
-            /* constant QP mode qp is fixed */
-            p->qp_max   = p->qp_init;
-            p->qp_min   = p->qp_init;
-            p->qp_step  = 0;
-        } else if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_CBR) {
-            /* constant bitrate do not limit qp range */
-            p->qp_max   = 48;
-            p->qp_min   = 4;
-            p->qp_step  = 16;
-            p->qp_init  = 0;
-        } else if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_VBR) {
-            /* variable bitrate has qp min limit */
-            p->qp_max   = 40;
-            p->qp_min   = 12;
-            p->qp_step  = 8;
-            p->qp_init  = 0;
-        }
-
-        codec_cfg->h264.qp_max      = p->qp_max;
-        codec_cfg->h264.qp_min      = p->qp_min;
-        codec_cfg->h264.qp_init     = p->qp_init;
     } break;
     case MPP_VIDEO_CodingMJPEG : {
         codec_cfg->jpeg.change      = MPP_ENC_JPEG_CFG_CHANGE_QFACTOR;
@@ -467,14 +471,7 @@ MPP_RET test_mpp_setup(MpiEncTestData *p)
         codec_cfg->jpeg.qf_min      = 1;
         codec_cfg->jpeg.qf_max      = 99;
     } break;
-    case MPP_VIDEO_CodingHEVC : {
-        codec_cfg->h265.change = MPP_ENC_H265_CFG_INTRA_QP_CHANGE | MPP_ENC_H265_CFG_RC_QP_CHANGE;
-        codec_cfg->h265.qp_init = -1;
-        codec_cfg->h265.max_i_qp = 46;
-        codec_cfg->h265.min_i_qp = 24;
-        codec_cfg->h265.max_qp = 51;
-        codec_cfg->h265.min_qp = 10;
-    } break;
+    case MPP_VIDEO_CodingHEVC :
     case MPP_VIDEO_CodingVP8 :
     default : {
         mpp_err_f("support encoder coding type %d\n", codec_cfg->coding);
diff --git a/test/mpi_enc_test.c b/test/mpi_enc_test.c
index dfdf5fc0..6a009462 100644
--- a/test/mpi_enc_test.c
+++ b/test/mpi_enc_test.c
@@ -270,7 +270,6 @@ MPP_RET test_mpp_enc_cfg_setup(MpiEncTestData *p)
     if (!p->bps)
         p->bps = p->width * p->height / 8 * (p->fps_out_num / p->fps_out_den);
 
-
     mpp_enc_cfg_set_s32(cfg, "prep:width", p->width);
     mpp_enc_cfg_set_s32(cfg, "prep:height", p->height);
     mpp_enc_cfg_set_s32(cfg, "prep:hor_stride", p->hor_stride);
@@ -279,27 +278,6 @@ MPP_RET test_mpp_enc_cfg_setup(MpiEncTestData *p)
 
     mpp_enc_cfg_set_s32(cfg, "rc:mode", p->rc_mode);
 
-    switch (p->rc_mode) {
-    case MPP_ENC_RC_MODE_FIXQP : {
-        /* do not set bps on fix qp mode */
-    } break;
-    case MPP_ENC_RC_MODE_CBR : {
-        /* CBR mode has narrow bound */
-        mpp_enc_cfg_set_s32(cfg, "rc:bps_target", p->bps);
-        mpp_enc_cfg_set_s32(cfg, "rc:bps_max", p->bps_max ? p->bps_max : p->bps * 17 / 16);
-        mpp_enc_cfg_set_s32(cfg, "rc:bps_min", p->bps_min ? p->bps_min : p->bps * 15 / 16);
-    } break;
-    case MPP_ENC_RC_MODE_VBR : {
-        /* CBR mode has wide bound */
-        mpp_enc_cfg_set_s32(cfg, "rc:bps_target", p->bps);
-        mpp_enc_cfg_set_s32(cfg, "rc:bps_max", p->bps_max ? p->bps_max : p->bps * 17 / 16);
-        mpp_enc_cfg_set_s32(cfg, "rc:bps_min", p->bps_min ? p->bps_min : p->bps * 1 / 16);
-    } break;
-    default : {
-        mpp_err_f("unsupport encoder rc mode %d\n", p->rc_mode);
-    } break;
-    }
-
     /* fix input / output frame rate */
     mpp_enc_cfg_set_s32(cfg, "rc:fps_in_flex", p->fps_in_flex);
     mpp_enc_cfg_set_s32(cfg, "rc:fps_in_num", p->fps_in_num);
@@ -314,6 +292,77 @@ MPP_RET test_mpp_enc_cfg_setup(MpiEncTestData *p)
     mpp_enc_cfg_set_u32(cfg, "rc:drop_thd", 20);        /* 20% of max bps */
     mpp_enc_cfg_set_u32(cfg, "rc:drop_gap", 1);         /* Do not continuous drop frame */
 
+    /* setup bitrate for different rc_mode */
+    mpp_enc_cfg_set_s32(cfg, "rc:bps_target", p->bps);
+    switch (p->rc_mode) {
+    case MPP_ENC_RC_MODE_FIXQP : {
+        /* do not setup bitrate on FIXQP mode */
+    } break;
+    case MPP_ENC_RC_MODE_CBR : {
+        /* CBR mode has narrow bound */
+        mpp_enc_cfg_set_s32(cfg, "rc:bps_max", p->bps_max ? p->bps_max : p->bps * 17 / 16);
+        mpp_enc_cfg_set_s32(cfg, "rc:bps_min", p->bps_min ? p->bps_min : p->bps * 15 / 16);
+    } break;
+    case MPP_ENC_RC_MODE_VBR :
+    case MPP_ENC_RC_MODE_AVBR : {
+        /* VBR mode has wide bound */
+        mpp_enc_cfg_set_s32(cfg, "rc:bps_max", p->bps_max ? p->bps_max : p->bps * 17 / 16);
+        mpp_enc_cfg_set_s32(cfg, "rc:bps_min", p->bps_min ? p->bps_min : p->bps * 1 / 16);
+    } break;
+    default : {
+        /* default use CBR mode */
+        mpp_enc_cfg_set_s32(cfg, "rc:bps_max", p->bps_max ? p->bps_max : p->bps * 17 / 16);
+        mpp_enc_cfg_set_s32(cfg, "rc:bps_min", p->bps_min ? p->bps_min : p->bps * 15 / 16);
+    } break;
+    }
+
+    /* setup qp for different codec and rc_mode */
+    switch (p->type) {
+    case MPP_VIDEO_CodingAVC :
+    case MPP_VIDEO_CodingHEVC : {
+        switch (p->rc_mode) {
+        case MPP_ENC_RC_MODE_FIXQP : {
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_init", 20);
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_max", 20);
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_min", 20);
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_max_i", 20);
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_min_i", 20);
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_ip", 4);
+        } break;
+        case MPP_ENC_RC_MODE_CBR :
+        case MPP_ENC_RC_MODE_VBR :
+        case MPP_ENC_RC_MODE_AVBR : {
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_init", 26);
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_max", 51);
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_min", 10);
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_max_i", 51);
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_min_i", 10);
+            mpp_enc_cfg_set_s32(cfg, "rc:qp_ip", 4);
+        } break;
+        default : {
+            mpp_err_f("unsupport encoder rc mode %d\n", p->rc_mode);
+        } break;
+        }
+    } break;
+    case MPP_VIDEO_CodingVP8 : {
+        /* vp8 only setup base qp range */
+        mpp_enc_cfg_set_s32(cfg, "rc:qp_init", 40);
+        mpp_enc_cfg_set_s32(cfg, "rc:qp_max",  127);
+        mpp_enc_cfg_set_s32(cfg, "rc:qp_min",  0);
+        mpp_enc_cfg_set_s32(cfg, "rc:qp_max_i", 127);
+        mpp_enc_cfg_set_s32(cfg, "rc:qp_min_i", 0);
+        mpp_enc_cfg_set_s32(cfg, "rc:qp_ip", 6);
+    } break;
+    case MPP_VIDEO_CodingMJPEG : {
+        /* jpeg use special codec config to control qtable */
+        mpp_enc_cfg_set_s32(cfg, "jpeg:q_factor", 80);
+        mpp_enc_cfg_set_s32(cfg, "jpeg:qf_max", 99);
+        mpp_enc_cfg_set_s32(cfg, "jpeg:qf_min", 1);
+    } break;
+    default : {
+    } break;
+    }
+
     /* setup codec  */
     mpp_enc_cfg_set_s32(cfg, "codec:type", p->type);
     switch (p->type) {
@@ -337,40 +386,10 @@ MPP_RET test_mpp_enc_cfg_setup(MpiEncTestData *p)
         mpp_enc_cfg_set_s32(cfg, "h264:cabac_en", 1);
         mpp_enc_cfg_set_s32(cfg, "h264:cabac_idc", 0);
         mpp_enc_cfg_set_s32(cfg, "h264:trans8x8", 1);
-
-        if (p->rc_mode == MPP_ENC_RC_MODE_FIXQP) {
-            mpp_enc_cfg_set_s32(cfg, "h264:qp_init", 20);
-            mpp_enc_cfg_set_s32(cfg, "h264:qp_max", 16);
-            mpp_enc_cfg_set_s32(cfg, "h264:qp_min", 16);
-            mpp_enc_cfg_set_s32(cfg, "h264:qp_max_i", 20);
-            mpp_enc_cfg_set_s32(cfg, "h264:qp_min_i", 20);
-        } else {
-            mpp_enc_cfg_set_s32(cfg, "h264:qp_init", 26);
-            mpp_enc_cfg_set_s32(cfg, "h264:qp_max", 51);
-            mpp_enc_cfg_set_s32(cfg, "h264:qp_min", 10);
-            mpp_enc_cfg_set_s32(cfg, "h264:qp_max_i", 51);
-            mpp_enc_cfg_set_s32(cfg, "h264:qp_min_i", 10);
-        }
-        mpp_enc_cfg_set_s32(cfg, "h264:qp_delta_ip", 4);
-    } break;
-    case MPP_VIDEO_CodingMJPEG : {
-        mpp_enc_cfg_set_s32(cfg, "jpeg:q_factor", 80);
-        mpp_enc_cfg_set_s32(cfg, "jpeg:qf_max", 99);
-        mpp_enc_cfg_set_s32(cfg, "jpeg:qf_min", 1);
     } break;
+    case MPP_VIDEO_CodingHEVC :
+    case MPP_VIDEO_CodingMJPEG :
     case MPP_VIDEO_CodingVP8 : {
-        mpp_enc_cfg_set_s32(cfg, "vp8:qp_init", 40);
-        mpp_enc_cfg_set_s32(cfg, "vp8:qp_max",  127);
-        mpp_enc_cfg_set_s32(cfg, "vp8:qp_min",  0);
-        mpp_enc_cfg_set_s32(cfg, "vp8:qp_max_i", 127);
-        mpp_enc_cfg_set_s32(cfg, "vp8:qp_min_i", 0);
-    } break;
-    case MPP_VIDEO_CodingHEVC : {
-        mpp_enc_cfg_set_s32(cfg, "h265:qp_init", p->rc_mode == MPP_ENC_RC_MODE_FIXQP ? -1 : 26);
-        mpp_enc_cfg_set_s32(cfg, "h265:qp_max", 51);
-        mpp_enc_cfg_set_s32(cfg, "h265:qp_min", 10);
-        mpp_enc_cfg_set_s32(cfg, "h265:qp_max_i", 46);
-        mpp_enc_cfg_set_s32(cfg, "h265:qp_min_i", 24);
     } break;
     default : {
         mpp_err_f("unsupport encoder coding type %d\n", p->type);
@@ -689,7 +708,7 @@ MPP_RET test_mpp_run(MpiEncTestData *p)
                 }
 
                 log_len += snprintf(log_buf + log_len, log_size - log_len,
-                                    " size %-7d", len);
+                                    " size %-7u", len);
 
                 if (mpp_packet_has_meta(packet)) {
                     meta = mpp_packet_get_meta(packet);
diff --git a/test/mpi_rc2_test.c b/test/mpi_rc2_test.c
index 6de4e630..2d73bd64 100644
--- a/test/mpi_rc2_test.c
+++ b/test/mpi_rc2_test.c
@@ -558,6 +558,12 @@ static MPP_RET mpi_rc_enc_init(MpiRc2TestCtx *ctx)
     rc_cfg->fps_out_flex = 0;
     rc_cfg->gop = 60;
     rc_cfg->max_reenc_times = 1;
+    if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_FIXQP) {
+        /* constant QP mode qp is fixed */
+        rc_cfg->qp_max   = 26;
+        rc_cfg->qp_min   = 26;
+        rc_cfg->qp_init  = 26;
+    }
 
     ret = enc_mpi->control(*enc_ctx, MPP_ENC_SET_RC_CFG, rc_cfg);
     if (ret) {
@@ -587,14 +593,6 @@ static MPP_RET mpi_rc_enc_init(MpiRc2TestCtx *ctx)
     codec_cfg->h264.entropy_coding_mode  = 1;
     codec_cfg->h264.cabac_init_idc  = 0;
 
-    if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_FIXQP) {
-        /* constant QP mode qp is fixed */
-        codec_cfg->h264.qp_max   = 26;
-        codec_cfg->h264.qp_min   = 26;
-        codec_cfg->h264.qp_init  = 26;
-        codec_cfg->h264.change |= MPP_ENC_H264_CFG_CHANGE_QP_LIMIT;
-    }
-
     ret = enc_mpi->control(*enc_ctx, MPP_ENC_SET_CODEC_CFG, codec_cfg);
     if (ret) {
         mpp_err("mpi control enc set codec cfg failed ret %d\n", ret);
diff --git a/test/mpi_rc_test.c b/test/mpi_rc_test.c
index 7a706f55..5ff3b2bf 100644
--- a/test/mpi_rc_test.c
+++ b/test/mpi_rc_test.c
@@ -595,6 +595,21 @@ static MPP_RET mpi_rc_codec(MpiRcTestCtx *ctx)
     rc_cfg->fps_out_flex = 0;
     rc_cfg->gop = fps;
     rc_cfg->max_reenc_times = 1;
+    rc_cfg->qp_init = -1;
+    if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_FIXQP) {
+        /* constant QP mode qp is fixed */
+        rc_cfg->qp_init = 26;
+        rc_cfg->qp_max  = 26;
+        rc_cfg->qp_min  = 26;
+    } else if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_CBR) {
+        /* constant bitrate do not limit qp range */
+        rc_cfg->qp_max  = 48;
+        rc_cfg->qp_min  = 4;
+    } else if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_VBR) {
+        /* variable bitrate has qp min limit */
+        rc_cfg->qp_max  = 40;
+        rc_cfg->qp_min  = 12;
+    }
 
     ret = enc_mpi->control(enc_ctx, MPP_ENC_SET_RC_CFG, rc_cfg);
     if (ret) {
@@ -618,8 +633,7 @@ static MPP_RET mpi_rc_codec(MpiRcTestCtx *ctx)
 
     codec_cfg->coding = type;
     codec_cfg->h264.change = MPP_ENC_H264_CFG_CHANGE_PROFILE |
-                             MPP_ENC_H264_CFG_CHANGE_ENTROPY |
-                             MPP_ENC_H264_CFG_CHANGE_QP_LIMIT;
+                             MPP_ENC_H264_CFG_CHANGE_ENTROPY;
     /*
      * H.264 profile_idc parameter
      * 66  - Baseline profile
@@ -639,21 +653,6 @@ static MPP_RET mpi_rc_codec(MpiRcTestCtx *ctx)
     codec_cfg->h264.entropy_coding_mode  = 1;
     codec_cfg->h264.cabac_init_idc  = 0;
 
-    codec_cfg->h264.qp_init = 0;
-    if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_FIXQP) {
-        /* constant QP mode qp is fixed */
-        codec_cfg->h264.qp_init  = 26;
-        codec_cfg->h264.qp_max   = 26;
-        codec_cfg->h264.qp_min   = 26;
-    } else if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_CBR) {
-        /* constant bitrate do not limit qp range */
-        codec_cfg->h264.qp_max   = 48;
-        codec_cfg->h264.qp_min   = 4;
-    } else if (rc_cfg->rc_mode == MPP_ENC_RC_MODE_VBR) {
-        /* variable bitrate has qp min limit */
-        codec_cfg->h264.qp_max   = 40;
-        codec_cfg->h264.qp_min   = 12;
-    }
     ret = enc_mpi->control(enc_ctx, MPP_ENC_SET_CODEC_CFG, codec_cfg);
     if (ret) {
         mpp_err("mpi control enc set codec cfg failed ret %d\n", ret);