diff --git a/inc/mpp_buffer.h b/inc/mpp_buffer.h
index 6d54a298..0aa38210 100644
--- a/inc/mpp_buffer.h
+++ b/inc/mpp_buffer.h
@@ -134,8 +134,8 @@ typedef void* MppBufferGroup;
  *       limit  mode is recommanded to work with commit flow, working with normal mode is not.
  */
 typedef enum {
-    MPP_BUFFER_MODE_NORMAL,
-    MPP_BUFFER_MODE_LIMIT,
+    MPP_BUFFER_INTERNAL,
+    MPP_BUFFER_EXTERNAL,
     MPP_BUFFER_MODE_BUTT,
 } MppBufferMode;
 
@@ -185,10 +185,10 @@ typedef struct MppBufferInfo_t {
         mpp_buffer_get_with_tag(MODULE_TAG, ## __VA_ARGS__)
 
 #define mpp_buffer_group_normal_get(...) \
-        mpp_buffer_group_get(MODULE_TAG, MPP_BUFFER_MODE_NORMAL, ## __VA_ARGS__)
+        mpp_buffer_group_get(MODULE_TAG, MPP_BUFFER_INTERNAL, ## __VA_ARGS__)
 
 #define mpp_buffer_group_limited_get(...) \
-        mpp_buffer_group_get(MODULE_TAG, MPP_BUFFER_MODE_LIMIT, ## __VA_ARGS__)
+        mpp_buffer_group_get(MODULE_TAG, MPP_BUFFER_EXTERNAL, ## __VA_ARGS__)
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/mpp/mpp.cpp b/mpp/mpp.cpp
index 2be06e58..c5e7e2c3 100644
--- a/mpp/mpp.cpp
+++ b/mpp/mpp.cpp
@@ -67,10 +67,10 @@ Mpp::Mpp(MppCtxType type, MppCodingType coding)
 
         mpp_buffer_group_normal_get(&mInternalGroup, MPP_BUFFER_TYPE_ION);
 
-        mpp_buffer_group_limited_get(&mPacketGroup, MPP_BUFFER_TYPE_ION);
+        mpp_buffer_group_normal_get(&mPacketGroup, MPP_BUFFER_TYPE_ION);
         mpp_buffer_group_limit_config(mPacketGroup, MPP_TEST_PACKET_SIZE, 4);
 
-        mpp_buffer_group_limited_get(&mFrameGroup, MPP_BUFFER_TYPE_ION);
+        mpp_buffer_group_normal_get(&mFrameGroup, MPP_BUFFER_TYPE_ION);
         mpp_buffer_group_limit_config(mFrameGroup, MPP_TEST_FRAME_SIZE, 4);
     } break;
     case MPP_CTX_ENC : {
diff --git a/mpp/mpp_buffer.cpp b/mpp/mpp_buffer.cpp
index 00e1e99e..7786f00a 100644
--- a/mpp/mpp_buffer.cpp
+++ b/mpp/mpp_buffer.cpp
@@ -31,9 +31,10 @@ MPP_RET mpp_buffer_commit(MppBufferGroup group, MppBufferInfo *info)
     }
 
     MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
-    if (p->type != info->type || p->type >= MPP_BUFFER_TYPE_BUTT) {
-        mpp_err("mpp_buffer_commit invalid type found group %d info %d\n",
-                p->type, info->type);
+    if (p->type != info->type || p->type >= MPP_BUFFER_TYPE_BUTT ||
+        p->mode != MPP_BUFFER_EXTERNAL) {
+        mpp_err("mpp_buffer_commit invalid type found group %d info %d group mode %d\n",
+                p->type, info->type, p->mode);
         return MPP_ERR_UNKNOW;
     }
 
@@ -48,12 +49,12 @@ MPP_RET mpp_buffer_get_with_tag(const char *tag, MppBufferGroup group, MppBuffer
         return MPP_ERR_UNKNOW;
     }
 
-    MppBufferGroupImpl *tmp = (MppBufferGroupImpl *)group;
+    MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
     // try unused buffer first
-    MppBufferImpl *buf = mpp_buffer_get_unused(tmp, size);
-    if (NULL == buf) {
+    MppBufferImpl *buf = mpp_buffer_get_unused(p, size);
+    if (NULL == buf && MPP_BUFFER_INTERNAL == p->mode) {
         MppBufferInfo info = {
-            tmp->type,
+            p->type,
             size,
             NULL,
             NULL,
@@ -61,8 +62,8 @@ MPP_RET mpp_buffer_get_with_tag(const char *tag, MppBufferGroup group, MppBuffer
             NULL,
         };
         // if failed try init a new buffer
-        mpp_buffer_create(tag, tmp->group_id, &info);
-        buf = mpp_buffer_get_unused(tmp, size);
+        mpp_buffer_create(tag, p->group_id, &info);
+        buf = mpp_buffer_get_unused(p, size);
     }
     *buffer = buf;
     return (buf) ? (MPP_OK) : (MPP_NOK);
@@ -203,7 +204,7 @@ MPP_RET mpp_buffer_group_limit_config(MppBufferGroup group, size_t size, RK_S32
     }
 
     MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
-    mpp_assert(p->mode == MPP_BUFFER_MODE_LIMIT);
+    mpp_assert(p->mode == MPP_BUFFER_INTERNAL);
     p->limit_size     = size;
     p->limit_count    = count;
     return MPP_OK;
diff --git a/mpp/mpp_buffer_impl.cpp b/mpp/mpp_buffer_impl.cpp
index a320be11..f9195ee7 100644
--- a/mpp/mpp_buffer_impl.cpp
+++ b/mpp/mpp_buffer_impl.cpp
@@ -25,6 +25,8 @@
 #define SEARCH_GROUP_NORMAL(id)         search_group_by_id_no_lock(&service.mListGroup,  id)
 #define SEARCH_GROUP_ORPHAN(id)         search_group_by_id_no_lock(&service.mListOrphan, id)
 
+typedef MPP_RET (*BufferOp)(MppAllocator allocator, MppBufferInfo *data);
+
 class MppBufferService
 {
 public:
@@ -71,17 +73,16 @@ MPP_RET deinit_buffer_no_lock(MppBufferImpl *buffer)
     list_del_init(&buffer->list_status);
     MppBufferGroupImpl *group = SEARCH_GROUP_NORMAL(buffer->group_id);
     if (group) {
-        if (buffer->internal)
-            group->alloc_api->free(group->allocator, &buffer->info);
-        else
-            group->alloc_api->release(group->allocator, &buffer->info);
-
+        BufferOp func = (group->mode == MPP_BUFFER_INTERNAL) ?
+                        (group->alloc_api->free) :
+                        (group->alloc_api->release);
+        func(group->allocator, &buffer->info);
         group->usage -= buffer->info.size;
         group->count--;
     } else {
         group = SEARCH_GROUP_ORPHAN(buffer->group_id);
         mpp_assert(group);
-        mpp_assert(buffer->mode == MPP_BUFFER_MODE_NORMAL);
+        mpp_assert(buffer->mode == MPP_BUFFER_INTERNAL);
         group->alloc_api->free(group->allocator, &buffer->info);
         group->usage -= buffer->info.size;
         group->count--;
@@ -120,7 +121,7 @@ static MPP_RET inc_buffer_ref_no_lock(MppBufferImpl *buffer)
             group->count_used++;
             group->count_unused--;
         } else {
-            mpp_err("mpp_buffer_ref_inc unused buffer without group\n");
+            mpp_err_f("unused buffer without group\n");
             ret = MPP_NOK;
         }
     }
@@ -132,7 +133,7 @@ MPP_RET mpp_buffer_create(const char *tag, RK_U32 group_id, MppBufferInfo *info)
 {
     MppBufferImpl *p = mpp_calloc(MppBufferImpl, 1);
     if (NULL == p) {
-        mpp_err("mpp_buffer_create failed to allocate context\n");
+        mpp_err_f("failed to allocate context\n");
         return MPP_ERR_MALLOC;
     }
 
@@ -140,21 +141,14 @@ MPP_RET mpp_buffer_create(const char *tag, RK_U32 group_id, MppBufferInfo *info)
 
     MppBufferGroupImpl *group = SEARCH_GROUP_NORMAL(group_id);
     if (group) {
-        if (info->fd == -1) {
-            MPP_RET ret = group->alloc_api->alloc(group->allocator, info);
-            if (MPP_OK != ret) {
-                mpp_err("mpp_buffer_create failed to create buffer with size %d\n", info->size);
-                mpp_free(p);
-                return MPP_ERR_MALLOC;
-            }
-            p->internal = 1;
-        } else {
-            MPP_RET ret = group->alloc_api->import(group->allocator, info);
-            if (MPP_OK != ret) {
-                mpp_err("mpp_buffer_create failed to create buffer with size %d\n", info->size);
-                mpp_free(p);
-                return MPP_ERR_MALLOC;
-            }
+        BufferOp func = (group->mode == MPP_BUFFER_INTERNAL) ?
+                        (group->alloc_api->alloc) :
+                        (group->alloc_api->import);
+        MPP_RET ret = func(group->allocator, info);
+        if (MPP_OK != ret) {
+            mpp_err_f("failed to create buffer with size %d\n", info->size);
+            mpp_free(p);
+            return MPP_ERR_MALLOC;
         }
 
         p->info = *info;
@@ -171,7 +165,7 @@ MPP_RET mpp_buffer_create(const char *tag, RK_U32 group_id, MppBufferInfo *info)
         group->count++;
         group->count_unused++;
     } else {
-        mpp_err("mpp_buffer_create can not create buffer without group\n");
+        mpp_err_f("can not create buffer without group\n");
         mpp_free(p);
         p = NULL;
     }
@@ -198,7 +192,7 @@ MPP_RET mpp_buffer_ref_inc(MppBufferImpl *buffer)
 MPP_RET mpp_buffer_ref_dec(MppBufferImpl *buffer)
 {
     if (buffer->ref_count <= 0) {
-        mpp_err("mpp_buffer_ref_dec found non-positive ref_count %d\n", buffer->ref_count);
+        mpp_err_f("found non-positive ref_count %d\n", buffer->ref_count);
         return MPP_NOK;
     }
 
@@ -244,7 +238,7 @@ MPP_RET mpp_buffer_group_init(MppBufferGroupImpl **group, const char *tag, MppBu
 {
     MppBufferGroupImpl *p = mpp_calloc(MppBufferGroupImpl, 1);
     if (NULL == p) {
-        mpp_err("mpp_buffer_group_get failed to allocate context\n");
+        mpp_err_f("failed to allocate context\n");
         *group = NULL;
         return MPP_ERR_MALLOC;
     }
@@ -282,7 +276,7 @@ MPP_RET mpp_buffer_group_init(MppBufferGroupImpl **group, const char *tag, MppBu
 MPP_RET mpp_buffer_group_deinit(MppBufferGroupImpl *p)
 {
     if (NULL == p) {
-        mpp_err("mpp_buffer_group_deinit found NULL pointer\n");
+        mpp_err_f("found NULL pointer\n");
         return MPP_ERR_NULL_PTR;
     }
 
@@ -302,7 +296,7 @@ MPP_RET mpp_buffer_group_deinit(MppBufferGroupImpl *p)
         // otherwise move the group to list_orphan and wait for buffer release
         list_del_init(&p->list_group);
         list_add_tail(&p->list_group, &service.mListOrphan);
-        mpp_err("mpp_group %p tag %s deinit with %d bytes buffer not released\n", p, p->tag, p->usage);
+        mpp_err_f("mpp_group %p tag %s deinit with %d bytes buffer not released\n", p, p->tag, p->usage);
         // if any buffer with mode MPP_BUFFER_MODE_COMMIT found it should be error
         MppBufferImpl *pos, *n;
         list_for_each_entry_safe(pos, n, &p->list_used, MppBufferImpl, list_status) {
diff --git a/test/mpp_buffer_test.c b/test/mpp_buffer_test.c
index d70a84a3..d7d0ba5d 100644
--- a/test/mpp_buffer_test.c
+++ b/test/mpp_buffer_test.c
@@ -49,8 +49,6 @@ int main()
         goto MPP_BUFFER_failed;
     }
 
-    mpp_buffer_group_limit_config(group, size, count);
-
     mpp_log("mpp_buffer_test commit mode start\n");
 
     commit.type = MPP_BUFFER_TYPE_NORMAL;
@@ -110,7 +108,11 @@ int main()
         goto MPP_BUFFER_failed;
     }
 
-    for (i = 0; i < MPP_BUFFER_TEST_NORMAL_COUNT; i++) {
+    count = MPP_BUFFER_TEST_NORMAL_COUNT;
+
+    mpp_buffer_group_limit_config(group, size, count);
+
+    for (i = 0; i < count; i++) {
         ret = mpp_buffer_get(group, &normal_buffer[i], (i + 1) * SZ_1K);
         if (MPP_OK != ret) {
             mpp_err("mpp_buffer_test mpp_buffer_get mode normal failed\n");
@@ -118,7 +120,7 @@ int main()
         }
     }
 
-    for (i = 0; i < MPP_BUFFER_TEST_NORMAL_COUNT; i++) {
+    for (i = 0; i < count; i++) {
         if (normal_buffer[i]) {
             ret = mpp_buffer_put(normal_buffer[i]);
             if (MPP_OK != ret) {