[mpp_buffer]: add output MppBuffer to mpp_buffer_commit interface. Also add misc group internally

git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@969 6e48237b-75ef-9749-8fc9-41990f28c85a

inc/mpp_buffer.h

@@ -181,6 +181,19 @@ typedef struct MppBufferInfo_t {
 
 #define BUFFER_GROUP_SIZE_DEFAULT           (SZ_1M*80)
 
+/*
+ * mpp_buffer_commit usage:
+ *
+ * mpp_buffer_commit(MppBufferGroup group, MppBufferInfo *info, MppBuffer *buffer)
+ *
+ * 1. group - specified the MppBuffer to attach to.
+ *    group can be NULL then this buffer will attached to default legecy group
+ * 2. info  - input information for the output MppBuffer
+ *    info can NOT be NULL. It must contain at least one of ptr/fd.
+ * 3. buffer - generated MppBuffer from MppBufferInfo.
+ *    buffer can be NULL then the buffer is commit to group with a free for get status.
+ *    Otherwise generated buffer will be directly got and ref_count increased.
+ */
 #define mpp_buffer_commit(...) \
         mpp_buffer_commit_with_tag(MODULE_TAG, __FUNCTION__, ## __VA_ARGS__)
 
@@ -201,8 +214,12 @@ extern "C" {
  * MppBuffer interface
  * these interface will change value of group and buffer so before calling functions
  * parameter need to be checked.
+ *
+ * IMPORTANT:
+ * mpp_buffer_commit_with_tag - compounded interface for commit and import
+ *
  */
-MPP_RET mpp_buffer_commit_with_tag(const char *tag, const char *caller, MppBufferGroup group, MppBufferInfo *info);
+MPP_RET mpp_buffer_commit_with_tag(const char *tag, const char *caller, MppBufferGroup group, MppBufferInfo *info, MppBuffer *buffer);
 MPP_RET mpp_buffer_get_with_tag(const char *tag, const char *caller, MppBufferGroup group, MppBuffer *buffer, size_t size);
 MPP_RET mpp_buffer_put(MppBuffer buffer);
 MPP_RET mpp_buffer_inc_ref(MppBuffer buffer);

mpp/base/inc/mpp_buffer_impl.h

@@ -110,7 +110,8 @@ extern RK_U32 mpp_buffer_debug;
 
 /*
  *  mpp_buffer_create       : create a unused buffer with parameter tag/size/data
- *                            buffer will be register to unused list
+ *                            if input buffer is NULL then buffer will be register to unused list
+ *                            otherwise the buffer will be register to used list and set to paramter buffer
  *
  *  mpp_buffer_destroy      : destroy a buffer, it must be on unused status
  *
@@ -131,7 +132,7 @@ extern RK_U32 mpp_buffer_debug;
  * mpp_buffer_ref_inc/dec   - use the buffer
  * mpp_buffer_destory       - destroy the buffer
  */
-MPP_RET mpp_buffer_create(const char *tag, const char *caller, RK_U32 group_id, MppBufferInfo *info);
+MPP_RET mpp_buffer_create(const char *tag, const char *caller, MppBufferGroupImpl *group, MppBufferInfo *info, MppBufferImpl **buffer);
 MPP_RET mpp_buffer_destroy(MppBufferImpl *buffer);
 MPP_RET mpp_buffer_ref_inc(MppBufferImpl *buffer);
 MPP_RET mpp_buffer_ref_dec(MppBufferImpl *buffer);
@@ -143,7 +144,7 @@ MPP_RET mpp_buffer_group_reset(MppBufferGroupImpl *p);
 MPP_RET mpp_buffer_group_set_listener(MppBufferGroupImpl *p, void *listener);
 // mpp_buffer_group helper function
 void mpp_buffer_group_dump(MppBufferGroupImpl *p);
-MppBufferGroupImpl *mpp_buffer_legacy_group();
+MppBufferGroupImpl *mpp_buffer_get_misc_group(MppBufferMode mode, MppBufferType type);
 
 #ifdef __cplusplus
 }

mpp/base/mpp_buffer.cpp

@@ -22,23 +22,41 @@
 #include "mpp_mem.h"
 #include "mpp_buffer_impl.h"
 
-MPP_RET mpp_buffer_commit_with_tag(const char *tag, const char *caller, MppBufferGroup group, MppBufferInfo *info)
+MPP_RET mpp_buffer_commit_with_tag(const char *tag, const char *caller,
+                                    MppBufferGroup group, MppBufferInfo *info,
+                                    MppBuffer *buffer)
 {
-    if (NULL == group || NULL == info) {
+    if (NULL == info) {
-        mpp_err("mpp_buffer_commit input null pointer group %p info %p\n",
+        mpp_err("mpp_buffer_commit input null info\n", info);
-                group, info);
         return MPP_ERR_NULL_PTR;
     }
 
     MppBufferGroupImpl *p = (MppBufferGroupImpl *)group;
-    if (p->type != info->type || p->type >= MPP_BUFFER_TYPE_BUTT ||
+
-        p->mode != MPP_BUFFER_EXTERNAL) {
+    if (p) {
-        mpp_err("mpp_buffer_commit invalid type found group %d info %d group mode %d\n",
+        // if group is specified we need to check the parameter
-                p->type, info->type, p->mode);
+        if (p->type != info->type || p->type >= MPP_BUFFER_TYPE_BUTT ||
-        return MPP_ERR_UNKNOW;
+            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;
+        }
+    } else {
+        // otherwise use default external group to manage them
+        p = mpp_buffer_get_misc_group(MPP_BUFFER_EXTERNAL, info->type);
     }
 
-    return mpp_buffer_create(tag, caller, p->group_id, info);
+    mpp_assert(p);
+
+    MPP_RET ret = MPP_OK;
+    if (buffer) {
+        MppBufferImpl *buf = NULL;
+        ret = mpp_buffer_create(tag, caller, p, info, &buf);
+        *buffer = buf;
+    } else {
+        ret = mpp_buffer_create(tag, caller, p, info, NULL);
+    }
+    return ret;
 }
 
 MPP_RET mpp_buffer_get_with_tag(const char *tag, const char *caller, MppBufferGroup group, MppBuffer *buffer, size_t size)
@@ -51,7 +69,7 @@ MPP_RET mpp_buffer_get_with_tag(const char *tag, const char *caller, MppBufferGr
 
     if (NULL == group) {
         // deprecated, only for libvpu support
-        group = mpp_buffer_legacy_group();
+        group = mpp_buffer_get_misc_group(MPP_BUFFER_INTERNAL, MPP_BUFFER_TYPE_ION);
     }
 
     mpp_assert(group);
@@ -68,8 +86,7 @@ MPP_RET mpp_buffer_get_with_tag(const char *tag, const char *caller, MppBufferGr
             -1,
         };
         // if failed try init a new buffer
-        mpp_buffer_create(tag, caller, p->group_id, &info);
+        mpp_buffer_create(tag, caller, p, &info, &buf);
-        buf = mpp_buffer_get_unused(p, size);
     }
     *buffer = buf;
     return (buf) ? (MPP_OK) : (MPP_NOK);

mpp/base/mpp_buffer_impl.cpp

@@ -70,7 +70,8 @@ private:
     RK_U32              group_id;
     RK_U32              group_count;
 
-    MppBufferGroupImpl  *mLegacyGroup;
+    MppBufferGroupImpl  *misc_ion_int;
+    MppBufferGroupImpl  *misc_ion_ext;
 
     struct list_head    mListGroup;
 
@@ -90,7 +91,7 @@ public:
     }
 
     MppBufferGroupImpl  *get_group(const char *tag, const char *caller, MppBufferMode mode, MppBufferType type);
-    MppBufferGroupImpl  *get_legacy_group();
+    MppBufferGroupImpl  *get_misc_group(MppBufferMode mode, MppBufferType type);
     void                put_group(MppBufferGroupImpl *group);
     MppBufferGroupImpl  *get_group_by_id(RK_U32 id);
 };
@@ -223,7 +224,9 @@ static void dump_buffer_info(MppBufferImpl *buffer)
             buffer->ref_count, buffer->discard, buffer->caller);
 }
 
-MPP_RET mpp_buffer_create(const char *tag, const char *caller, RK_U32 group_id, MppBufferInfo *info)
+MPP_RET mpp_buffer_create(const char *tag, const char *caller,
+                          MppBufferGroupImpl *group, MppBufferInfo *info,
+                          MppBufferImpl **buffer)
 {
     AutoMutex auto_lock(MppBufferService::get_lock());
     MPP_BUF_FUNCTION_ENTER();
@@ -231,7 +234,7 @@ MPP_RET mpp_buffer_create(const char *tag, const char *caller, RK_U32 group_id,
     MPP_RET ret = MPP_OK;
     BufferOp func = NULL;
     MppBufferImpl *p = NULL;
-    MppBufferGroupImpl *group = SEARCH_GROUP_BY_ID(group_id);
+
     if (NULL == group) {
         mpp_err_f("can not create buffer without group\n");
         ret = MPP_NOK;
@@ -275,15 +278,21 @@ MPP_RET mpp_buffer_create(const char *tag, const char *caller, RK_U32 group_id,
 
     strncpy(p->tag, tag, sizeof(p->tag));
     p->caller = caller;
-    p->group_id = group_id;
+    p->group_id = group->group_id;
     p->buffer_id = group->buffer_id;
     INIT_LIST_HEAD(&p->list_status);
     list_add_tail(&p->list_status, &group->list_unused);
+
     group->buffer_id++;
     group->usage += info->size;
     group->buffer_count++;
     group->count_unused++;
 
+    if (buffer) {
+        inc_buffer_ref_no_lock(p);
+        *buffer = p;
+    }
+
     buffer_group_add_log(group, p, (group->mode == MPP_BUFFER_INTERNAL) ? (BUF_CREATE) : (BUF_COMMIT));
 RET:
     MPP_BUF_FUNCTION_LEAVE();
@@ -331,7 +340,7 @@ MPP_RET mpp_buffer_ref_dec(MppBufferImpl *buffer)
         if (0 == buffer->ref_count) {
             buffer->used = 0;
             list_del_init(&buffer->list_status);
-            if (group == MppBufferService::get_instance()->get_legacy_group()) {
+            if (group == MppBufferService::get_instance()->get_misc_group(group->mode, group->type)) {
                 deinit_buffer_no_lock(buffer);
             } else {
                 if (buffer->discard) {
@@ -480,29 +489,38 @@ void mpp_buffer_group_dump(MppBufferGroupImpl *group)
     buffer_group_dump_log(group);
 }
 
-MppBufferGroupImpl *mpp_buffer_legacy_group()
+MppBufferGroupImpl *mpp_buffer_get_misc_group(MppBufferMode mode, MppBufferType type)
 {
     AutoMutex auto_lock(MppBufferService::get_lock());
-    return MppBufferService::get_instance()->get_legacy_group();
+    return MppBufferService::get_instance()->get_misc_group(mode, type);
 }
 
 MppBufferService::MppBufferService()
     : group_id(0),
       group_count(0),
-      mLegacyGroup(NULL)
+      misc_ion_int(NULL),
+      misc_ion_ext(NULL)
 {
     INIT_LIST_HEAD(&mListGroup);
     INIT_LIST_HEAD(&mListOrphan);
+
     // NOTE: here can not call mpp_buffer_group_init for the service is not started
-    mLegacyGroup = get_group("legacy", "MppBufferService", MPP_BUFFER_INTERNAL, MPP_BUFFER_TYPE_ION);
+    //       misc group can accept all kind of buffer which is available
+    misc_ion_int = get_group("misc_ion_int", "MppBufferService", MPP_BUFFER_INTERNAL, MPP_BUFFER_TYPE_ION);
+    misc_ion_ext = get_group("misc_ion_ext", "MppBufferService", MPP_BUFFER_EXTERNAL, MPP_BUFFER_TYPE_ION);
 }
 
 MppBufferService::~MppBufferService()
 {
     // first remove legacy group
-    if (mLegacyGroup) {
+    if (misc_ion_ext) {
-        put_group(mLegacyGroup);
+        put_group(misc_ion_ext);
-        mLegacyGroup = NULL;
+        misc_ion_ext = NULL;
+    }
+
+    if (misc_ion_int) {
+        put_group(misc_ion_int);
+        misc_ion_int = NULL;
     }
 
     // then remove the remaining group
@@ -574,9 +592,14 @@ MppBufferGroupImpl *MppBufferService::get_group(const char *tag, const char *cal
     return p;
 }
 
-MppBufferGroupImpl *MppBufferService::get_legacy_group()
+MppBufferGroupImpl *MppBufferService::get_misc_group(MppBufferMode mode, MppBufferType type)
 {
-    return mLegacyGroup;
+    if (type == MPP_BUFFER_TYPE_NORMAL)
+        return NULL;
+
+    mpp_assert(type == MPP_BUFFER_TYPE_ION);
+    mpp_assert(mode < MPP_BUFFER_MODE_BUTT);
+    return (mode == MPP_BUFFER_INTERNAL) ? (misc_ion_int) : (misc_ion_ext);
 }
 
 void MppBufferService::put_group(MppBufferGroupImpl *p)
@@ -652,13 +675,13 @@ void MppBufferService::destroy_group(MppBufferGroupImpl *group)
     mpp_free(group);
     group_count--;
 
-    if (group == mLegacyGroup) {
+    if (group == misc_ion_int) {
-        mLegacyGroup = NULL;
+        misc_ion_int = NULL;
     } else {
         /* if only legacy group left dump the legacy group */
-        if (group_count == 1 && mLegacyGroup->buffer_count) {
+        if (group_count == 1 && misc_ion_int->buffer_count) {
             mpp_log("found legacy group has buffer remain, start dumping\n");
-            mpp_buffer_group_dump(mLegacyGroup);
+            mpp_buffer_group_dump(misc_ion_int);
             abort();
         }
     }

mpp/legacy/vpu_mem_legacy.c

@@ -32,7 +32,7 @@ static RK_S32 commit_memory_handle(vpu_display_mem_pool *p, RK_S32 mem_hdl, RK_S
     info.size = size;
     p_mempool->size = size;
     p_mempool->buff_size = size;
-    mpp_buffer_commit(p_mempool->group, &info);
+    mpp_buffer_commit(p_mempool->group, &info, NULL);
     return info.fd;
 }
 

osal/window/os_allocator.c

@@ -26,6 +26,7 @@
 
 typedef struct {
     size_t alignment;
+    RK_S32 fd_count;
 } allocator_ctx;
 
 MPP_RET os_allocator_open(void **ctx, size_t alignment)
@@ -45,6 +46,8 @@ MPP_RET os_allocator_open(void **ctx, size_t alignment)
     } else
         p->alignment = alignment;
 
+    p->fd_count = 0;
+
     *ctx = p;
     return ret;
 }
@@ -59,6 +62,7 @@ MPP_RET os_allocator_alloc(void *ctx, MppBufferInfo *info)
     }
 
     p = (allocator_ctx *)ctx;
+    info->fd = p->fd_count++;
     return (MPP_RET)os_malloc(&info->ptr, p->alignment, info->size);
 }
 
@@ -72,11 +76,12 @@ MPP_RET os_allocator_free(void *ctx, MppBufferInfo *info)
 
 MPP_RET os_allocator_import(void *ctx, MppBufferInfo *info)
 {
-    (void) ctx;
+    allocator_ctx *p = (allocator_ctx *)ctx;
+    mpp_assert(ctx);
     mpp_assert(info->ptr);
     mpp_assert(info->size);
     info->hnd   = NULL;
-    info->fd    = -1;
+    info->fd    = p->fd_count++;
     return MPP_OK;
 }
 

test/mpp_buffer_test.c

@@ -59,7 +59,7 @@ int main()
         goto MPP_BUFFER_failed;
     }
 
-    mpp_log("mpp_buffer_test commit mode start\n");
+    mpp_log("mpp_buffer_test commit mode with unused status start\n");
 
     commit.type = MPP_BUFFER_TYPE_NORMAL;
     commit.size = size;
@@ -73,7 +73,7 @@ int main()
 
         commit.ptr = commit_ptr[i];
 
-        ret = mpp_buffer_commit(group, &commit);
+        ret = mpp_buffer_commit(group, &commit, NULL);
         if (MPP_OK != ret) {
             mpp_err("mpp_buffer_test mpp_buffer_commit failed\n");
             goto MPP_BUFFER_failed;
@@ -108,7 +108,54 @@ int main()
 
     mpp_buffer_group_put(group);
 
-    mpp_log("mpp_buffer_test commit mode success\n");
+    mpp_log("mpp_buffer_test commit mode with unused status success\n");
+
+
+    mpp_log("mpp_buffer_test commit mode with used status start\n");
+
+    commit.type = MPP_BUFFER_TYPE_ION;
+    commit.size = size;
+
+    for (i = 0; i < count; i++) {
+        commit_ptr[i] = malloc(size);
+        if (NULL == commit_ptr[i]) {
+            mpp_err("mpp_buffer_test malloc failed\n");
+            goto MPP_BUFFER_failed;
+        }
+
+        commit.ptr = commit_ptr[i];
+
+        /*
+         * NOTE: commit buffer info will be directly return within new MppBuffer
+         *       This mode allow input group is NULL
+         */
+        ret = mpp_buffer_commit(NULL, &commit, &commit_buffer[i]);
+        if (MPP_OK != ret) {
+            mpp_err("mpp_buffer_test mpp_buffer_commit failed\n");
+            goto MPP_BUFFER_failed;
+        }
+    }
+
+    for (i = 0; i < count; i++) {
+        if (commit_buffer[i]) {
+            ret = mpp_buffer_put(commit_buffer[i]);
+            if (MPP_OK != ret) {
+                mpp_err("mpp_buffer_test mpp_buffer_put commit mode failed\n");
+                goto MPP_BUFFER_failed;
+            }
+            commit_buffer[i] = NULL;
+        }
+    }
+
+    for (i = 0; i < count; i++) {
+        if (commit_ptr[i]) {
+            free(commit_ptr[i]);
+            commit_ptr[i] = NULL;
+        }
+    }
+
+    mpp_log("mpp_buffer_test commit mode with used status success\n");
+
 
     mpp_log("mpp_buffer_test normal mode start\n");