diff --git a/inc/rk_venc_cfg.h b/inc/rk_venc_cfg.h
index 16c808ea..cae4a5b5 100644
--- a/inc/rk_venc_cfg.h
+++ b/inc/rk_venc_cfg.h
@@ -15,9 +15,14 @@ typedef void* MppEncCfg;
 extern "C" {
 #endif
 
+/* legacy interface */
 MPP_RET mpp_enc_cfg_init(MppEncCfg *cfg);
 MPP_RET mpp_enc_cfg_deinit(MppEncCfg cfg);
 
+/* new interface */
+RK_S32 mpp_enc_cfg_get(MppEncCfg *cfg, const char *name, void *val);
+RK_S32 mpp_enc_cfg_put(MppEncCfg cfg);
+
 MPP_RET mpp_enc_cfg_set_s32(MppEncCfg cfg, const char *name, RK_S32 val);
 MPP_RET mpp_enc_cfg_set_u32(MppEncCfg cfg, const char *name, RK_U32 val);
 MPP_RET mpp_enc_cfg_set_s64(MppEncCfg cfg, const char *name, RK_S64 val);
diff --git a/kmpp/kmpp.c b/kmpp/kmpp.c
index ceee5110..2c64c3e4 100644
--- a/kmpp/kmpp.c
+++ b/kmpp/kmpp.c
@@ -457,7 +457,18 @@ static MPP_RET control(Kmpp *ctx, MpiCmd cmd, MppParam param)
     switch (cmd) {
     case MPP_ENC_SET_CFG :
     case MPP_ENC_GET_CFG : {
-        size = sizeof(MppEncCfgSet);
+        MppEncCfgImpl *impl = (MppEncCfgImpl *)param;
+
+        mpp_assert(impl->is_kobj);
+        if (impl->is_kobj) {
+            KmppObj obj = impl->obj;
+
+            arg = kmpp_obj_to_shm(obj);
+            size = kmpp_obj_to_shm_size(obj);
+        } else {
+            mpp_loge("can not set non-kobj %p to kmpp\n", impl);
+            return MPP_NOK;
+        }
     } break;
     case MPP_ENC_SET_HEADER_MODE :
     case MPP_ENC_SET_SEI_CFG : {
diff --git a/mpp/base/mpp_enc_cfg.c b/mpp/base/mpp_enc_cfg.c
index 80e23424..d6a5b2be 100644
--- a/mpp/base/mpp_enc_cfg.c
+++ b/mpp/base/mpp_enc_cfg.c
@@ -358,7 +358,8 @@ static void mpp_enc_cfg_set_default(MppEncCfgSet *cfg)
 
 MPP_RET mpp_enc_cfg_init(MppEncCfg *cfg)
 {
-    MppEncCfgSet *p = NULL;
+    MppEncCfgImpl *impl = NULL;
+    MPP_RET ret = MPP_OK;
 
     if (!cfg) {
         mpp_err_f("invalid NULL input config\n");
@@ -367,52 +368,138 @@ MPP_RET mpp_enc_cfg_init(MppEncCfg *cfg)
 
     mpp_env_get_u32("mpp_enc_cfg_debug", &mpp_enc_cfg_debug, 0);
 
-    p = mpp_calloc(MppEncCfgSet, 1);
-    if (!p) {
-        mpp_err_f("create encoder config failed %p\n", p);
-        *cfg = NULL;
-        return MPP_ERR_NOMEM;
+    *cfg = NULL;
+
+    do {
+        impl = mpp_calloc(MppEncCfgImpl, 1);
+        if (!impl) {
+            mpp_err_f("create MppEncCfgImpl failed\n");
+            ret = MPP_ERR_NOMEM;
+            break;
+        }
+
+        impl->cfg = mpp_calloc(MppEncCfgSet, 1);
+        if (!impl->cfg) {
+            mpp_err_f("create MppEncCfgSet failed\n");
+            ret = MPP_ERR_NOMEM;
+            break;
+        }
+
+        /* NOTE: compatible to old struct size */
+        impl->cfg->size = sizeof(*impl->cfg);
+        mpp_enc_cfg_set_default(impl->cfg);
+
+        *cfg = impl;
+    } while (0);
+
+    if (ret) {
+        if (impl) {
+            MPP_FREE(impl->cfg);
+            MPP_FREE(impl);
+        }
     }
 
-    /* NOTE: compatible to old struct size */
-    p->size = sizeof(*p);
-    mpp_enc_cfg_set_default(p);
-
-    *cfg = p;
-
-    return MPP_OK;
+    return ret;
 }
 
 MPP_RET mpp_enc_cfg_deinit(MppEncCfg cfg)
 {
+    return mpp_enc_cfg_put(cfg);
+}
+
+RK_S32 mpp_enc_cfg_get(MppEncCfg *cfg, const char *name, void *val)
+{
+    static const char *kcfg_name = "KmppVencStCfg";
+    (void)val;
+
     if (!cfg) {
         mpp_err_f("invalid NULL input config\n");
         return MPP_ERR_NULL_PTR;
     }
 
-    MPP_FREE(cfg);
+    mpp_env_get_u32("mpp_enc_cfg_debug", &mpp_enc_cfg_debug, 0);
+
+    *cfg = NULL;
+
+    if (!name || !strcmp(name, "MppEncCfg")) {
+        return mpp_enc_cfg_init(cfg);
+    } else if (!strcmp(name, kcfg_name)) {
+        MppEncCfgImpl *impl = NULL;
+
+        impl = mpp_calloc(MppEncCfgImpl, 1);
+        if (!impl) {
+            mpp_err_f("create MppEncCfgImpl failed\n");
+            return MPP_ERR_NOMEM;
+        }
+        impl->is_kobj = 1;
+        kmpp_obj_get_by_name_f(&impl->obj, kcfg_name);
+        if (!impl->obj) {
+            mpp_err_f("failed to get obj by name %s\n", kcfg_name);
+            MPP_FREE(impl);
+            return MPP_ERR_NOMEM;
+        }
+        *cfg = impl;
+        return MPP_OK;
+    }
+
+    mpp_loge_f("invalid cfg %s\n", name);
+
+    return MPP_NOK;
+}
+
+RK_S32 mpp_enc_cfg_put(MppEncCfg cfg)
+{
+    MppEncCfgImpl *impl = (MppEncCfgImpl *)cfg;
+
+    if (!impl) {
+        mpp_err_f("invalid NULL input config\n");
+        return MPP_ERR_NULL_PTR;
+    }
+
+    if (!impl->is_kobj) {
+        MPP_FREE(impl->cfg);
+    } else {
+        kmpp_obj_put_f(impl->obj);
+    }
+
+    MPP_FREE(impl);
 
     return MPP_OK;
 }
 
+#define kmpp_obj_set_S32(obj, name, val) \
+    kmpp_obj_set_s32(obj, name, val)
+#define kmpp_obj_set_U32(obj, name, val) \
+    kmpp_obj_set_u32(obj, name, val)
+#define kmpp_obj_set_S64(obj, name, val) \
+    kmpp_obj_set_s64(obj, name, val)
+#define kmpp_obj_set_U64(obj, name, val) \
+    kmpp_obj_set_u64(obj, name, val)
+#define kmpp_obj_set_Ptr(obj, name, val) \
+    kmpp_obj_set_ptr(obj, name, val)
+#define kmpp_obj_set_St(obj, name, val) \
+    kmpp_obj_set_st(obj, name, val)
+
 #define ENC_CFG_SET_ACCESS(func_name, in_type, cfg_type) \
     MPP_RET func_name(MppEncCfg cfg, const char *name, in_type val) \
     { \
-        MppEncCfgSet *p = (MppEncCfgSet *)cfg; \
-        MppTrieInfo *node; \
-        MppCfgInfo *info; \
-        if (!p || !name) { \
+        MppEncCfgImpl *impl = (MppEncCfgImpl *)cfg; \
+        if (!impl || !impl->cfg || !name) { \
             mpp_err_f("invalid input cfg %p name %p\n", cfg, name); \
             return MPP_ERR_NULL_PTR; \
         } \
-        node = service_get_info(name); \
-        info = (MppCfgInfo *)mpp_trie_info_ctx(node); \
-        if (CHECK_CFG_INFO(info, name, CFG_FUNC_TYPE_##cfg_type)) { \
-            return MPP_NOK; \
+        if (impl->is_kobj) { \
+            return kmpp_obj_set_##cfg_type(impl->obj, name, val); \
+        } else { \
+            MppEncCfgSet *p = impl->cfg; \
+            MppTrieInfo *node = service_get_info(name); \
+            MppCfgInfo *info = (MppCfgInfo *)mpp_trie_info_ctx(node); \
+            if (CHECK_CFG_INFO(info, name, CFG_FUNC_TYPE_##cfg_type)) { \
+                return MPP_NOK; \
+            } \
+            enc_cfg_dbg_set("name %s type %s\n", mpp_trie_info_name(node), strof_cfg_type(info->data_type)); \
+            return MPP_CFG_SET_##cfg_type(info, p, val); \
         } \
-        enc_cfg_dbg_set("name %s type %s\n", mpp_trie_info_name(node), strof_cfg_type(info->data_type)); \
-        MPP_RET ret = MPP_CFG_SET_##cfg_type(info, p, val); \
-        return ret; \
     }
 
 ENC_CFG_SET_ACCESS(mpp_enc_cfg_set_s32, RK_S32, S32);
@@ -422,24 +509,39 @@ ENC_CFG_SET_ACCESS(mpp_enc_cfg_set_u64, RK_U64, U64);
 ENC_CFG_SET_ACCESS(mpp_enc_cfg_set_ptr, void *, Ptr);
 ENC_CFG_SET_ACCESS(mpp_enc_cfg_set_st,  void *, St);
 
+#define kmpp_obj_get_S32(obj, name, val) \
+    kmpp_obj_get_s32(obj, name, val)
+#define kmpp_obj_get_U32(obj, name, val) \
+    kmpp_obj_get_u32(obj, name, val)
+#define kmpp_obj_get_S64(obj, name, val) \
+    kmpp_obj_get_s64(obj, name, val)
+#define kmpp_obj_get_U64(obj, name, val) \
+    kmpp_obj_get_u64(obj, name, val)
+#define kmpp_obj_get_Ptr(obj, name, val) \
+    kmpp_obj_get_ptr(obj, name, val)
+#define kmpp_obj_get_St(obj, name, val) \
+    kmpp_obj_get_st(obj, name, val)
+
 #define ENC_CFG_GET_ACCESS(func_name, in_type, cfg_type) \
     MPP_RET func_name(MppEncCfg cfg, const char *name, in_type *val) \
     { \
-        MppEncCfgSet *p = (MppEncCfgSet *)cfg; \
-        MppTrieInfo *node; \
-        MppCfgInfo *info; \
-        if (!p || !name) { \
+        MppEncCfgImpl *impl = (MppEncCfgImpl *)cfg; \
+        if (!impl || !impl->cfg || !name) { \
             mpp_err_f("invalid input cfg %p name %p\n", cfg, name); \
             return MPP_ERR_NULL_PTR; \
         } \
-        node = service_get_info(name); \
-        info = (MppCfgInfo *)mpp_trie_info_ctx(node); \
-        if (CHECK_CFG_INFO(info, name, CFG_FUNC_TYPE_##cfg_type)) { \
-            return MPP_NOK; \
+        if (impl->is_kobj) { \
+            return kmpp_obj_get_##cfg_type(impl->obj, name, val); \
+        } else { \
+            MppEncCfgSet *p = impl->cfg; \
+            MppTrieInfo *node = service_get_info(name); \
+            MppCfgInfo *info = (MppCfgInfo *)mpp_trie_info_ctx(node); \
+            if (CHECK_CFG_INFO(info, name, CFG_FUNC_TYPE_##cfg_type)) { \
+                return MPP_NOK; \
+            } \
+            enc_cfg_dbg_set("name %s type %s\n", mpp_trie_info_name(node), strof_cfg_type(info->data_type)); \
+            return MPP_CFG_GET_##cfg_type(info, p, val); \
         } \
-        enc_cfg_dbg_set("name %s type %s\n", mpp_trie_info_name(node), strof_cfg_type(info->data_type)); \
-        MPP_RET ret = MPP_CFG_GET_##cfg_type(info, p, val); \
-        return ret; \
     }
 
 ENC_CFG_GET_ACCESS(mpp_enc_cfg_get_s32, RK_S32, S32);
diff --git a/mpp/codec/mpp_enc_v2.cpp b/mpp/codec/mpp_enc_v2.cpp
index b33f0af1..09116c15 100644
--- a/mpp/codec/mpp_enc_v2.cpp
+++ b/mpp/codec/mpp_enc_v2.cpp
@@ -345,7 +345,16 @@ MPP_RET mpp_enc_control_v2(MppEnc ctx, MpiCmd cmd, void *param)
 
     switch (cmd) {
     case MPP_ENC_GET_CFG : {
-        MppEncCfgSet *cfg = (MppEncCfgSet *)param;
+        MppEncCfgImpl *impl = (MppEncCfgImpl *)param;
+        MppEncCfgSet *cfg;
+
+        if (impl->is_kobj) {
+            mpp_loge("can not MPP_ENC_GET_CFG by kobj %p\n", impl);
+            ret = MPP_NOK;
+            break;
+        }
+
+        cfg = impl->cfg;
 
         enc_dbg_ctrl("get all config\n");
         memcpy(cfg, &enc->cfg, sizeof(enc->cfg));
@@ -361,17 +370,24 @@ MPP_RET mpp_enc_control_v2(MppEnc ctx, MpiCmd cmd, void *param)
         cfg->split.change = 0;
         cfg->tune.change = 0;
     } break;
-    case MPP_ENC_GET_PREP_CFG : {
-        enc_dbg_ctrl("get prep config\n");
-        memcpy(param, &enc->cfg.prep, sizeof(enc->cfg.prep));
-    } break;
-    case MPP_ENC_GET_RC_CFG : {
-        enc_dbg_ctrl("get rc config\n");
-        memcpy(param, &enc->cfg.rc, sizeof(enc->cfg.rc));
-    } break;
-    case MPP_ENC_GET_CODEC_CFG : {
-        enc_dbg_ctrl("get codec config\n");
-        memcpy(param, &enc->cfg.codec, sizeof(enc->cfg.codec));
+    case MPP_ENC_SET_PREP_CFG :
+    case MPP_ENC_GET_PREP_CFG :
+    case MPP_ENC_SET_RC_CFG :
+    case MPP_ENC_GET_RC_CFG :
+    case MPP_ENC_SET_CODEC_CFG :
+    case MPP_ENC_GET_CODEC_CFG :
+    case MPP_ENC_SET_SPLIT :
+    case MPP_ENC_GET_SPLIT : {
+        mpp_loge("deprecated %s control use MPP_ENC_GET_CFG / MPP_ENC_SET_CFG instead\n",
+                 cmd == MPP_ENC_SET_PREP_CFG ? "MPP_ENC_SET_PREP_CFG" :
+                 cmd == MPP_ENC_GET_PREP_CFG ? "MPP_ENC_GET_PREP_CFG" :
+                 cmd == MPP_ENC_SET_RC_CFG ? "MPP_ENC_SET_RC_CFG" :
+                 cmd == MPP_ENC_GET_RC_CFG ? "MPP_ENC_GET_RC_CFG" :
+                 cmd == MPP_ENC_SET_CODEC_CFG ? "MPP_ENC_SET_CODEC_CFG" :
+                 cmd == MPP_ENC_GET_CODEC_CFG ? "MPP_ENC_GET_CODEC_CFG" :
+                 cmd == MPP_ENC_SET_SPLIT ? "MPP_ENC_SET_SPLIT" :
+                 cmd == MPP_ENC_GET_SPLIT ? "MPP_ENC_GET_SPLIT" : "unknown");
+        ret = MPP_NOK;
     } break;
     case MPP_ENC_GET_HEADER_MODE : {
         enc_dbg_ctrl("get header mode\n");
@@ -383,6 +399,17 @@ MPP_RET mpp_enc_control_v2(MppEnc ctx, MpiCmd cmd, void *param)
     } break;
     default : {
         // Cmd which is not get configure will handle by enc_impl
+        if (cmd == MPP_ENC_SET_CFG) {
+            MppEncCfgImpl *impl = (MppEncCfgImpl *)param;
+
+            if (impl->is_kobj) {
+                mpp_loge("can not MPP_ENC_SET_CFG by kobj %p\n", impl);
+                ret = MPP_NOK;
+                break;
+            }
+            param = impl->cfg;
+        }
+
         enc->cmd = cmd;
         enc->param = param;
         enc->cmd_ret = &ret;
diff --git a/mpp/inc/mpp_enc_cfg.h b/mpp/inc/mpp_enc_cfg.h
index 75d935ad..1ae05987 100644
--- a/mpp/inc/mpp_enc_cfg.h
+++ b/mpp/inc/mpp_enc_cfg.h
@@ -49,4 +49,14 @@ typedef struct MppEncCfgSet_t {
     MppEncFineTuneCfg   tune;
 } MppEncCfgSet;
 
+#include "kmpp_obj.h"
+
+typedef struct MppEncCfgImpl_t {
+    RK_U32              is_kobj;
+    union {
+        MppEncCfgSet    *cfg;
+        KmppObj         obj;
+    };
+} MppEncCfgImpl;
+
 #endif /*__MPP_ENC_CFG_H__*/
diff --git a/test/mpi_enc_test.c b/test/mpi_enc_test.c
index 514eca4d..6c6bae7a 100644
--- a/test/mpi_enc_test.c
+++ b/test/mpi_enc_test.c
@@ -1140,9 +1140,9 @@ void *enc_test(void *arg)
         goto MPP_TEST_OUT;
     }
 
-    ret = mpp_enc_cfg_init(&p->cfg);
+    ret = mpp_enc_cfg_get(&p->cfg, cmd->kmpp_en ? "KmppVencStCfg" : "MppEncCfg", NULL);
     if (ret) {
-        mpp_err_f("mpp_enc_cfg_init failed ret %d\n", ret);
+        mpp_err_f("mpp_enc_cfg_get failed ret %d\n", ret);
         goto MPP_TEST_OUT;
     }