From d4b871ef154fbd38aad2530ce62b133fc29884e7 Mon Sep 17 00:00:00 2001 From: ChenHengming Date: Tue, 24 May 2016 08:41:18 +0000 Subject: [PATCH] [oasl]: move ion allocator to new directory for linux reuse git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@808 6e48237b-75ef-9749-8fc9-41990f28c85a --- osal/CMakeLists.txt | 5 + osal/allocator/allocator_ion.c | 357 +++++++++++++++++++++++++++++++++ osal/allocator/allocator_ion.h | 20 ++ osal/android/os_allocator.c | 328 +----------------------------- 4 files changed, 383 insertions(+), 327 deletions(-) create mode 100644 osal/allocator/allocator_ion.c create mode 100644 osal/allocator/allocator_ion.h diff --git a/osal/CMakeLists.txt b/osal/CMakeLists.txt index 5570588f..16a10832 100644 --- a/osal/CMakeLists.txt +++ b/osal/CMakeLists.txt @@ -1,15 +1,19 @@ # vim: syntax=cmake if(${ANDROID}) set(OS_DIR android) +set(MPP_ALLOCATOR allocator/allocator_ion.c) elseif(${UNIX}) set(OS_DIR linux) +set(MPP_ALLOCATOR allocator/allocator_ion.c) elseif(${WIN32}) set(OS_DIR window) +set(MPP_ALLOCATOR ) else() message(SEND_ERROR "Can not found platform definistion ${CMAKE_SYSTEM}") endif() include_directories(.) +include_directories(./allocator) add_library(osal STATIC mpp_allocator.cpp @@ -24,6 +28,7 @@ add_library(osal STATIC ${OS_DIR}/os_mem.c ${OS_DIR}/os_env.c ${OS_DIR}/os_log.c + ${MPP_ALLOCATOR} ) if(ANDROID) diff --git a/osal/allocator/allocator_ion.c b/osal/allocator/allocator_ion.c new file mode 100644 index 00000000..496ef6a3 --- /dev/null +++ b/osal/allocator/allocator_ion.c @@ -0,0 +1,357 @@ +/* + * Copyright 2010 Rockchip Electronics S.LSI Co. LTD + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include + +#include + +#include "os_mem.h" +#include "allocator_ion.h" + +#include "mpp_mem.h" +#include "mpp_log.h" + +static RK_U32 ion_debug = 0; + +#define ION_FUNCTION (0x00000001) +#define ION_DEVICE (0x00000002) +#define ION_CLINET (0x00000004) +#define ION_IOCTL (0x00000008) + +#define ION_DETECT_IOMMU_DISABLE (0x0) /* use ION_HEAP_TYPE_DMA */ +#define ION_DETECT_IOMMU_ENABLE (0x1) /* use ION_HEAP_TYPE_SYSTEM */ +#define ION_DETECT_NO_DTS (0x2) /* use ION_HEAP_TYPE_CARVEOUT */ + +#define ion_dbg(flag, fmt, ...) _mpp_dbg(ion_debug, flag, fmt, ## __VA_ARGS__) + +static int ion_ioctl(int fd, int req, void *arg) +{ + int ret = ioctl(fd, req, arg); + if (ret < 0) { + mpp_err("ion_ioctl %x failed with code %d: %s\n", req, + ret, strerror(errno)); + return -errno; + } + return ret; +} + +static int ion_alloc(int fd, size_t len, size_t align, unsigned int heap_mask, + unsigned int flags, ion_user_handle_t *handle) +{ + int ret; + struct ion_allocation_data data = { + .len = len, + .align = align, + .heap_id_mask = heap_mask, + .flags = flags, + }; + + if (handle == NULL) + return -EINVAL; + + ret = ion_ioctl(fd, ION_IOC_ALLOC, &data); + if (ret < 0) + return ret; + *handle = data.handle; + return ret; +} + +static int ion_free(int fd, ion_user_handle_t handle) +{ + struct ion_handle_data data = { + .handle = handle, + }; + return ion_ioctl(fd, ION_IOC_FREE, &data); +} + +static int ion_map(int fd, ion_user_handle_t handle, size_t length, int prot, + int flags, off_t offset, unsigned char **ptr, int *map_fd) +{ + int ret; + struct ion_fd_data data = { + .handle = handle, + }; + + if (map_fd == NULL) + return -EINVAL; + if (ptr == NULL) + return -EINVAL; + + ret = ion_ioctl(fd, ION_IOC_MAP, &data); + if (ret < 0) + return ret; + *map_fd = data.fd; + if (*map_fd < 0) { + mpp_err("map ioctl returned negative fd\n"); + return -EINVAL; + } + *ptr = mmap(NULL, length, prot, flags, *map_fd, offset); + if (*ptr == MAP_FAILED) { + mpp_err("mmap failed: %s\n", strerror(errno)); + return -errno; + } + return ret; +} + +#include + +static const char *search_name = NULL; + +int _compare_name(const struct dirent *dir) +{ + if (search_name && strstr(dir->d_name, search_name)) + return 1; + + return 0; +} + +/* + * directory search function: + * search directory with dir_name on path. + * if found match dir append name on path and return + * + * return 0 for failure + * return positive value for length of new path + */ +RK_S32 find_dir_in_path(char *path, const char *dir_name, size_t max_length) +{ + struct dirent **dir; + RK_S32 path_len = strnlen(path, max_length); + RK_S32 new_path_len = 0; + RK_S32 n; + + search_name = dir_name; + n = scandir(path, &dir, _compare_name, alphasort); + if (n < 0) { + mpp_err("scan %s for %s failed\n", path, dir_name); + } else { + while (n > 1) { + free(dir[--n]); + } + + new_path_len = path_len; + new_path_len += snprintf(path + path_len, max_length - path_len - 1, + "/%s", dir[0]->d_name); + + free(dir[0]); + free(dir); + } + search_name = NULL; + return new_path_len; +} + +RK_S32 check_sysfs_iommu() +{ + RK_S32 ret = ION_DETECT_IOMMU_DISABLE; + char path[256]; + + snprintf(path, sizeof(path), "/proc/device-tree"); + if (find_dir_in_path(path, "vpu_service", sizeof(path))) { + if (find_dir_in_path(path, "iommu_enabled", sizeof(path))) { + FILE *iommu_fp = fopen(path, "rb"); + + if (iommu_fp) { + RK_U32 iommu_enabled = 0; + fread(&iommu_enabled, sizeof(RK_U32), 1, iommu_fp); + mpp_log("vpu_service iommu_enabled %d\n", (iommu_enabled > 0)); + fclose(iommu_fp); + if (iommu_enabled) + ret = ION_DETECT_IOMMU_ENABLE; + } + } else { + mpp_err("can not find dts for iommu_enabled\n"); + } + } else { + mpp_err("can not find dts for vpu_service\n"); + ret = ION_DETECT_NO_DTS; + } + + return ret; +} + +typedef struct { + RK_U32 alignment; + RK_S32 ion_device; +} allocator_ctx_ion; + +#define VPU_IOC_MAGIC 'l' +#define VPU_IOC_PROBE_IOMMU_STATUS _IOR(VPU_IOC_MAGIC, 5, unsigned long) +#define VPU_IOC_PROBE_HEAP_STATUS _IOR(VPU_IOC_MAGIC, 6, unsigned long) +const char *dev_ion = "/dev/ion"; +static RK_S32 ion_heap_id = -1; +static RK_U32 ion_heap_mask = ION_HEAP_SYSTEM_MASK; + +MPP_RET os_allocator_ion_open(void **ctx, size_t alignment) +{ + RK_S32 fd; + allocator_ctx_ion *p; + + if (NULL == ctx) { + mpp_err("os_allocator_open Android do not accept NULL input\n"); + return MPP_ERR_NULL_PTR; + } + + *ctx = NULL; + + fd = open(dev_ion, O_RDWR); + if (fd < 0) { + mpp_err("open %s failed!\n", dev_ion); + return MPP_ERR_UNKNOW; + } + + ion_dbg(ION_DEVICE, "open ion dev fd %d\n", fd); + + p = mpp_malloc(allocator_ctx_ion, 1); + if (NULL == p) { + close(fd); + mpp_err("os_allocator_open Android failed to allocate context\n"); + return MPP_ERR_MALLOC; + } else { + /* + * do heap id detection here: + * if there is no vpu_service use default ION_HEAP_TYPE_SYSTEM_CONTIG + * if there is vpu_service then check the iommu_enable status + */ + if (ion_heap_id < 0) { + int detect_result = check_sysfs_iommu(); + const char *heap_name = NULL; + + switch (detect_result) { + case ION_DETECT_IOMMU_DISABLE : { + ion_heap_mask = (1 << ION_HEAP_TYPE_DMA); + ion_heap_id = ION_HEAP_TYPE_DMA; + heap_name = "ION_HEAP_TYPE_DMA"; + } break; + case ION_DETECT_IOMMU_ENABLE : { + ion_heap_mask = (1 << ION_HEAP_TYPE_SYSTEM); + ion_heap_id = ION_HEAP_TYPE_SYSTEM; + heap_name = "ION_HEAP_TYPE_SYSTEM"; + } break; + case ION_DETECT_NO_DTS : { + ion_heap_mask = (1 << ION_HEAP_TYPE_CARVEOUT); + ion_heap_id = ION_HEAP_TYPE_CARVEOUT; + heap_name = "ION_HEAP_TYPE_CARVEOUT"; + } break; + default : { + mpp_err("invalid detect result %d\n", detect_result); + ion_heap_mask = (1 << ION_HEAP_TYPE_DMA); + ion_heap_id = ION_HEAP_TYPE_DMA; + heap_name = "ION_HEAP_TYPE_DMA"; + } break; + } + mpp_log("using ion heap %s\n", heap_name); + } + p->alignment = alignment; + p->ion_device = fd; + *ctx = p; + } + + return MPP_OK; +} + +MPP_RET os_allocator_ion_alloc(void *ctx, MppBufferInfo *info) +{ + MPP_RET ret = MPP_OK; + allocator_ctx_ion *p = NULL; + + if (NULL == ctx) { + mpp_err("os_allocator_close Android do not accept NULL input\n"); + return MPP_ERR_NULL_PTR; + } + + p = (allocator_ctx_ion *)ctx; + ret = ion_alloc(p->ion_device, info->size, p->alignment, + ion_heap_mask, 0, + (ion_user_handle_t *)&info->hnd); + if (ret) { + mpp_err("os_allocator_ion_alloc ion_alloc failed ret %d\n", ret); + return ret; + } + ret = ion_map(p->ion_device, (ion_user_handle_t)info->hnd, info->size, + PROT_READ | PROT_WRITE, MAP_SHARED, (off_t)0, + (unsigned char**)&info->ptr, &info->fd); + if (ret) { + mpp_err("os_allocator_ion_alloc ion_map failed ret %d\n", ret); + return ret; + } + return ret; +} + +MPP_RET os_allocator_ion_import(void *ctx, MppBufferInfo *data) +{ + (void)ctx; + // NOTE: do not use the original buffer fd, + // use dup fd to avoid unexpected external fd close + data->fd = dup(data->fd); + data->ptr = mmap(NULL, data->size, PROT_READ | PROT_WRITE, MAP_SHARED, data->fd, 0); + return (data->ptr) ? (MPP_OK) : (MPP_NOK); +} + +MPP_RET os_allocator_ion_release(void *ctx, MppBufferInfo *data) +{ + (void)ctx; + munmap(data->ptr, data->size); + close(data->fd); + return MPP_OK; +} + +MPP_RET os_allocator_ion_free(void *ctx, MppBufferInfo *data) +{ + allocator_ctx_ion *p = NULL; + if (NULL == ctx) { + mpp_err("os_allocator_close Android do not accept NULL input\n"); + return MPP_ERR_NULL_PTR; + } + + p = (allocator_ctx_ion *)ctx; + munmap(data->ptr, data->size); + close(data->fd); + ion_free(p->ion_device, (ion_user_handle_t)data->hnd); + return MPP_OK; +} + +MPP_RET os_allocator_ion_close(void *ctx) +{ + int ret; + allocator_ctx_ion *p; + + if (NULL == ctx) { + mpp_err("os_allocator_close Android do not accept NULL input\n"); + return MPP_ERR_NULL_PTR; + } + + p = (allocator_ctx_ion *)ctx; + ret = close(p->ion_device); + mpp_free(p); + if (ret < 0) + return (MPP_RET) - errno; + return MPP_OK; +} + +os_allocator allocator_ion = { + os_allocator_ion_open, + os_allocator_ion_alloc, + os_allocator_ion_free, + os_allocator_ion_import, + os_allocator_ion_release, + os_allocator_ion_close, +}; + diff --git a/osal/allocator/allocator_ion.h b/osal/allocator/allocator_ion.h new file mode 100644 index 00000000..dffa15f2 --- /dev/null +++ b/osal/allocator/allocator_ion.h @@ -0,0 +1,20 @@ +/* + * Copyright 2010 Rockchip Electronics S.LSI Co. LTD + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "os_allocator.h" + +extern os_allocator allocator_ion; + diff --git a/osal/android/os_allocator.c b/osal/android/os_allocator.c index 3fce60cc..b11de3bf 100644 --- a/osal/android/os_allocator.c +++ b/osal/android/os_allocator.c @@ -23,6 +23,7 @@ #include "os_mem.h" #include "os_allocator.h" +#include "allocator_ion.h" #include "mpp_mem.h" #include "mpp_log.h" @@ -92,333 +93,6 @@ static os_allocator allocator_normal = { os_allocator_normal_close, }; -static RK_U32 ion_debug = 0; - -#define ION_FUNCTION (0x00000001) -#define ION_DEVICE (0x00000002) -#define ION_CLINET (0x00000004) -#define ION_IOCTL (0x00000008) - -#define ION_DETECT_IOMMU_DISABLE (0x0) /* use ION_HEAP_TYPE_DMA */ -#define ION_DETECT_IOMMU_ENABLE (0x1) /* use ION_HEAP_TYPE_SYSTEM */ -#define ION_DETECT_NO_DTS (0x2) /* use ION_HEAP_TYPE_CARVEOUT */ - -#define ion_dbg(flag, fmt, ...) _mpp_dbg(ion_debug, flag, fmt, ## __VA_ARGS__) - -static int ion_ioctl(int fd, int req, void *arg) -{ - int ret = ioctl(fd, req, arg); - if (ret < 0) { - mpp_err("ion_ioctl %x failed with code %d: %s\n", req, - ret, strerror(errno)); - return -errno; - } - return ret; -} - -static int ion_alloc(int fd, size_t len, size_t align, unsigned int heap_mask, - unsigned int flags, ion_user_handle_t *handle) -{ - int ret; - struct ion_allocation_data data = { - .len = len, - .align = align, - .heap_id_mask = heap_mask, - .flags = flags, - }; - - if (handle == NULL) - return -EINVAL; - - ret = ion_ioctl(fd, ION_IOC_ALLOC, &data); - if (ret < 0) - return ret; - *handle = data.handle; - return ret; -} - -static int ion_free(int fd, ion_user_handle_t handle) -{ - struct ion_handle_data data = { - .handle = handle, - }; - return ion_ioctl(fd, ION_IOC_FREE, &data); -} - -static int ion_map(int fd, ion_user_handle_t handle, size_t length, int prot, - int flags, off_t offset, unsigned char **ptr, int *map_fd) -{ - int ret; - struct ion_fd_data data = { - .handle = handle, - }; - - if (map_fd == NULL) - return -EINVAL; - if (ptr == NULL) - return -EINVAL; - - ret = ion_ioctl(fd, ION_IOC_MAP, &data); - if (ret < 0) - return ret; - *map_fd = data.fd; - if (*map_fd < 0) { - mpp_err("map ioctl returned negative fd\n"); - return -EINVAL; - } - *ptr = mmap(NULL, length, prot, flags, *map_fd, offset); - if (*ptr == MAP_FAILED) { - mpp_err("mmap failed: %s\n", strerror(errno)); - return -errno; - } - return ret; -} - -#include - -static const char *search_name = NULL; - -int _compare_name(const struct dirent *dir) -{ - if (search_name && strstr(dir->d_name, search_name)) - return 1; - - return 0; -} - -/* - * directory search function: - * search directory with dir_name on path. - * if found match dir append name on path and return - * - * return 0 for failure - * return positive value for length of new path - */ -RK_S32 find_dir_in_path(char *path, const char *dir_name, size_t max_length) -{ - struct dirent **dir; - RK_S32 path_len = strnlen(path, max_length); - RK_S32 new_path_len = 0; - RK_S32 n; - - search_name = dir_name; - n = scandir(path, &dir, _compare_name, alphasort); - if (n < 0) { - mpp_err("scan %s for %s failed\n", path, dir_name); - } else { - while (n > 1) { - free(dir[--n]); - } - - new_path_len = path_len; - new_path_len += snprintf(path + path_len, max_length - path_len - 1, - "/%s", dir[0]->d_name); - - free(dir[0]); - free(dir); - } - search_name = NULL; - return new_path_len; -} - -RK_S32 check_sysfs_iommu() -{ - RK_S32 ret = ION_DETECT_IOMMU_DISABLE; - char path[256]; - - snprintf(path, sizeof(path), "/proc/device-tree"); - if (find_dir_in_path(path, "vpu_service", sizeof(path))) { - if (find_dir_in_path(path, "iommu_enabled", sizeof(path))) { - FILE *iommu_fp = fopen(path, "rb"); - - if (iommu_fp) { - RK_U32 iommu_enabled = 0; - fread(&iommu_enabled, sizeof(RK_U32), 1, iommu_fp); - mpp_log("vpu_service iommu_enabled %d\n", (iommu_enabled > 0)); - fclose(iommu_fp); - if (iommu_enabled) - ret = ION_DETECT_IOMMU_ENABLE; - } - } else { - mpp_err("can not find dts for iommu_enabled\n"); - } - } else { - mpp_err("can not find dts for vpu_service\n"); - ret = ION_DETECT_NO_DTS; - } - - return ret; -} - -typedef struct { - RK_U32 alignment; - RK_S32 ion_device; -} allocator_ctx_ion; - -#define VPU_IOC_MAGIC 'l' -#define VPU_IOC_PROBE_IOMMU_STATUS _IOR(VPU_IOC_MAGIC, 5, unsigned long) -#define VPU_IOC_PROBE_HEAP_STATUS _IOR(VPU_IOC_MAGIC, 6, unsigned long) -const char *dev_ion = "/dev/ion"; -const char *dev_vpu = "/dev/vpu_service"; -static RK_S32 ion_heap_id = -1; -static RK_U32 ion_heap_mask = ION_HEAP_SYSTEM_MASK; - -MPP_RET os_allocator_ion_open(void **ctx, size_t alignment) -{ - RK_S32 fd; - allocator_ctx_ion *p; - - if (NULL == ctx) { - mpp_err("os_allocator_open Android do not accept NULL input\n"); - return MPP_ERR_NULL_PTR; - } - - *ctx = NULL; - - fd = open(dev_ion, O_RDWR); - if (fd < 0) { - mpp_err("open %s failed!\n", dev_ion); - return MPP_ERR_UNKNOW; - } - - ion_dbg(ION_DEVICE, "open ion dev fd %d\n", fd); - - p = mpp_malloc(allocator_ctx_ion, 1); - if (NULL == p) { - close(fd); - mpp_err("os_allocator_open Android failed to allocate context\n"); - return MPP_ERR_MALLOC; - } else { - /* - * do heap id detection here: - * if there is no vpu_service use default ION_HEAP_TYPE_SYSTEM_CONTIG - * if there is vpu_service then check the iommu_enable status - */ - if (ion_heap_id < 0) { - int detect_result = check_sysfs_iommu(); - const char *heap_name = NULL; - - switch (detect_result) { - case ION_DETECT_IOMMU_DISABLE : { - ion_heap_mask = (1 << ION_HEAP_TYPE_DMA); - ion_heap_id = ION_HEAP_TYPE_DMA; - heap_name = "ION_HEAP_TYPE_DMA"; - } break; - case ION_DETECT_IOMMU_ENABLE : { - ion_heap_mask = (1 << ION_HEAP_TYPE_SYSTEM); - ion_heap_id = ION_HEAP_TYPE_SYSTEM; - heap_name = "ION_HEAP_TYPE_SYSTEM"; - } break; - case ION_DETECT_NO_DTS : { - ion_heap_mask = (1 << ION_HEAP_TYPE_CARVEOUT); - ion_heap_id = ION_HEAP_TYPE_CARVEOUT; - heap_name = "ION_HEAP_TYPE_CARVEOUT"; - } break; - default : { - mpp_err("invalid detect result %d\n", detect_result); - ion_heap_mask = (1 << ION_HEAP_TYPE_DMA); - ion_heap_id = ION_HEAP_TYPE_DMA; - heap_name = "ION_HEAP_TYPE_DMA"; - } break; - } - mpp_log("using ion heap %s\n", heap_name); - } - p->alignment = alignment; - p->ion_device = fd; - *ctx = p; - } - - return MPP_OK; -} - -MPP_RET os_allocator_ion_alloc(void *ctx, MppBufferInfo *info) -{ - MPP_RET ret = MPP_OK; - allocator_ctx_ion *p = NULL; - - if (NULL == ctx) { - mpp_err("os_allocator_close Android do not accept NULL input\n"); - return MPP_ERR_NULL_PTR; - } - - p = (allocator_ctx_ion *)ctx; - ret = ion_alloc(p->ion_device, info->size, p->alignment, - ion_heap_mask, 0, - (ion_user_handle_t *)&info->hnd); - if (ret) { - mpp_err("os_allocator_ion_alloc ion_alloc failed ret %d\n", ret); - return ret; - } - ret = ion_map(p->ion_device, (ion_user_handle_t)info->hnd, info->size, - PROT_READ | PROT_WRITE, MAP_SHARED, (off_t)0, - (unsigned char**)&info->ptr, &info->fd); - if (ret) { - mpp_err("os_allocator_ion_alloc ion_map failed ret %d\n", ret); - return ret; - } - return ret; -} - -MPP_RET os_allocator_ion_import(void *ctx, MppBufferInfo *data) -{ - (void)ctx; - // NOTE: do not use the original buffer fd, - // use dup fd to avoid unexpected external fd close - data->fd = dup(data->fd); - data->ptr = mmap(NULL, data->size, PROT_READ | PROT_WRITE, MAP_SHARED, data->fd, 0); - return (data->ptr) ? (MPP_OK) : (MPP_NOK); -} - -MPP_RET os_allocator_ion_release(void *ctx, MppBufferInfo *data) -{ - (void)ctx; - munmap(data->ptr, data->size); - close(data->fd); - return MPP_OK; -} - -MPP_RET os_allocator_ion_free(void *ctx, MppBufferInfo *data) -{ - allocator_ctx_ion *p = NULL; - if (NULL == ctx) { - mpp_err("os_allocator_close Android do not accept NULL input\n"); - return MPP_ERR_NULL_PTR; - } - - p = (allocator_ctx_ion *)ctx; - munmap(data->ptr, data->size); - close(data->fd); - ion_free(p->ion_device, (ion_user_handle_t)data->hnd); - return MPP_OK; -} - -MPP_RET os_allocator_ion_close(void *ctx) -{ - int ret; - allocator_ctx_ion *p; - - if (NULL == ctx) { - mpp_err("os_allocator_close Android do not accept NULL input\n"); - return MPP_ERR_NULL_PTR; - } - - p = (allocator_ctx_ion *)ctx; - ret = close(p->ion_device); - mpp_free(p); - if (ret < 0) - return (MPP_RET) - errno; - return MPP_OK; -} - -static os_allocator allocator_ion = { - os_allocator_ion_open, - os_allocator_ion_alloc, - os_allocator_ion_free, - os_allocator_ion_import, - os_allocator_ion_release, - os_allocator_ion_close, -}; - MPP_RET os_allocator_get(os_allocator *api, MppBufferType type) { MPP_RET ret = MPP_OK;