/*
  Copyright (c), 2001-2022, Shenshu Tech. Co., Ltd.
 */
#include "libapi_common_ive.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

#include "ot_common.h"
#include "ot_common_video.h"
#include "ot_common_sys.h"
#include "ot_common_vgs.h"
#include "ot_common_vi.h"
#include "ot_common_vo.h"
#include "ss_mpi_sys.h"
#include <arm_neon.h>

#define OT_SAMPLE_IVE_QUERY_SLEEP   100
#define OT_SAMPLE_IVE_MAX_WIDTH     4096
#define OT_SAMPLE_IVE_MAX_HEIGHT    4096


// 在一个进程内，MPI初始化是否只能执行一次，如果只能执行一次，那么这里可以设置为全局变量
// for test
static td_bool g_is_mpi_init = TD_FALSE;

/*
 * function : Mpi check init
 */
td_s32 libapi_common_ive_check_mpi_init(td_void)
{
    if (g_is_mpi_init == TD_FALSE) {
        if (libapi_common_ive_mpi_init() != TD_SUCCESS) {
            macro_svp_trace_err("Ive mpi init failed!\n");
            return TD_FALSE;
        }
        g_is_mpi_init = TD_TRUE;
    }
    return TD_TRUE;
}

/*
 * function :mpi_init
 */
td_s32 libapi_common_ive_mpi_init(td_void)
{
    td_s32 ret;

    ss_mpi_sys_exit();

    ret = ss_mpi_sys_init();
    if (ret != TD_SUCCESS) {
        macro_svp_trace_err("ss_mpi_sys_init fail,Error(%#x)\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

/*
 * function : Mpi exit
 */
td_void libapi_common_ive_mpi_exit(td_void)
{
    if (g_is_mpi_init == TD_TRUE) {
        if (ss_mpi_sys_exit() != TD_SUCCESS) {
            macro_svp_trace_err("Sys exit failed!\n");
            return;
        }
    }
    g_is_mpi_init = TD_FALSE;
    macro_svp_trace_info("ive mpi exit ok!\n");
}

static td_void _comm_ive_get_loop_info(const ot_svp_img *img, ot_struct_rw_image_loop_info *loop_info)
{
    loop_info->ele_size = 1;
    loop_info->loop_c = 1;
    loop_info->loop_h[0] = img->height;
    switch (img->type) {
        case OT_SVP_IMG_TYPE_U8C1:
        case OT_SVP_IMG_TYPE_S8C1: {
        }
        break;
        case OT_SVP_IMG_TYPE_YUV420SP: {
            loop_info->ele_size = 1;
            loop_info->loop_c = OT_MACRO_IVE_IMAGE_CHN_TWO;
            loop_info->loop_h[1] = img->height / OT_MACRO_IVE_DIV_TWO;
        }
        break;
        case OT_SVP_IMG_TYPE_YUV422SP: {
            loop_info->loop_c = OT_MACRO_IVE_IMAGE_CHN_TWO;
            loop_info->loop_h[1] = img->height;
        }
        break;
        case OT_SVP_IMG_TYPE_U8C3_PACKAGE: {
            loop_info->ele_size = sizeof(td_u8) + sizeof(td_u16);
        }
        break;
        case OT_SVP_IMG_TYPE_U8C3_PLANAR: {
            loop_info->loop_c = OT_MACRO_IVE_IMAGE_CHN_THREE;
            loop_info->loop_h[1] = img->height;
            loop_info->loop_h[OT_MACRO_IVE_IMAGE_CHN_TWO] = img->height;
        }
        break;
        case OT_SVP_IMG_TYPE_S16C1:
        case OT_SVP_IMG_TYPE_U16C1: {
            loop_info->ele_size = sizeof(td_u16);
        }
        break;
        case OT_SVP_IMG_TYPE_U32C1:
        case OT_SVP_IMG_TYPE_S32C1: {
            loop_info->ele_size = sizeof(td_u32);
        }
        break;
        case OT_SVP_IMG_TYPE_S64C1:
        case OT_SVP_IMG_TYPE_U64C1: {
            loop_info->ele_size = sizeof(td_u64);
        }
        break;
        default:
            break;
    }
}

/*
 * function :Read file
 */
td_s32 libapi_common_ive_read_file(ot_svp_img *img, FILE *fp)
{
    td_u8 *ptr_tmp = TD_NULL;
    td_u16 c, h;
    td_s32 ret = OT_ERR_IVE_NULL_PTR;
    ot_struct_rw_image_loop_info loop_info = {0};

    macro_svp_check_exps_return(img == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "img can't be null\n");
    macro_svp_check_exps_return(fp == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "fp can't be null\n");

    ret = fgetc(fp);
    macro_svp_check_exps_return(ret == EOF, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "fgetc fp failed!\n");
    if (feof(fp)) {
        macro_svp_trace_err("end of file!\n");
        ret = fseek(fp, 0, SEEK_SET);
        if (ret != 0) {
            macro_svp_trace_err("fseek failed!\n");
            return ret;
        }
    } else {
        ret = fseek(fp, -1, SEEK_CUR);
        if (ret != 0) {
            macro_svp_trace_err("fseek failed!\n");
            return ret;
        }
    }
    _comm_ive_get_loop_info(img, &loop_info);
    for (c = 0; (c < loop_info.loop_c) && (c < OT_SVP_IMG_STRIDE_NUM) && (c < OT_SVP_IMG_ADDR_NUM); c++) {
        ptr_tmp = macro_svp_convert_addr_to_ptr(td_u8, img->virt_addr[c]);
        macro_svp_check_exps_return(ptr_tmp == 0, OT_ERR_IVE_ILLEGAL_PARAM,
            ENUM_SVP_ERR_LEVEL_DEBUG, "ptr_tmp can't be 0\n");
        for (h = 0; h < loop_info.loop_h[c]; h++) {
            if (fread(ptr_tmp, img->width * loop_info.ele_size, 1, fp) != 1) {
                macro_svp_trace_err("Read file fail\n");
                return OT_ERR_IVE_ILLEGAL_PARAM;
            }
            ptr_tmp += img->stride[c] * loop_info.ele_size;
        }
    }

    return TD_SUCCESS;
}

/*
 * function :Write file
 */
td_s32 libapi_common_ive_write_file(ot_svp_img *img, FILE *fp)
{
    td_u16 c, h;
    td_u8 *ptr_tmp = TD_NULL;
    td_s32 ret = OT_ERR_IVE_NULL_PTR;
    ot_struct_rw_image_loop_info loop_info = {0};

    macro_svp_check_exps_return(img == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "img can't be null\n");
    macro_svp_check_exps_return(fp == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "fp can't be null\n");
    ret = OT_ERR_IVE_ILLEGAL_PARAM;
    macro_svp_check_exps_return(img->phys_addr == 0, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "img->phys_addr can't be 0\n");
    macro_svp_check_exps_return(img->virt_addr == 0, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "img->phys_addr can't be 0\n");

    _comm_ive_get_loop_info(img, &loop_info);
    for (c = 0; (c < loop_info.loop_c) && (c < OT_SVP_IMG_STRIDE_NUM) && (c < OT_SVP_IMG_ADDR_NUM); c++) {
        ptr_tmp = macro_svp_convert_addr_to_ptr(td_u8, img->virt_addr[c]);
        macro_svp_check_exps_return(ptr_tmp == 0, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "ptr_tmp can't be 0\n");
        for (h = 0; h < loop_info.loop_h[c]; h++) {
            if (fwrite(ptr_tmp, img->width * loop_info.ele_size, 1, fp) != 1) {
                macro_svp_trace_err("Write file fail\n");
                return ret;
            }
            ptr_tmp += img->stride[c] * loop_info.ele_size;
        }
    }
    return TD_SUCCESS;
}

// static void *memcpy_128(void *dest, void *src, size_t count)
// {
//         int i;
//         unsigned long *s = (unsigned long *)src;
//         unsigned long *d = (unsigned long *)dest;
//         for (i = 0; i < count / 64; i++) {
//                 vst1q_u64(&d[0], vld1q_u64(&s[0])); 
//                 vst1q_u64(&d[2], vld1q_u64(&s[2])); 
//                 vst1q_u64(&d[4], vld1q_u64(&s[4])); 
//                 vst1q_u64(&d[6], vld1q_u64(&s[6]));
//                 d += 8; s += 8;
//         }
//         return dest;
// }

/*
 * 先执行
 * ret = libapi_common_ive_create_image(img, img_type, width, height);
 * macro_svp_check_exps_return(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR, "Error,create src img failed!\n");
 * function :Read os_mem
 */
td_s32 libapi_common_ive_read_os_mem(ot_svp_img *img, td_void *src, td_u32 whidh, td_u32 height, td_u32 img_type)
{
    td_u8 *ptr_tmp = TD_NULL;
    td_u16 c, h;
    td_s32 ret = OT_ERR_IVE_NULL_PTR;
    ot_struct_rw_image_loop_info loop_info = {0};

    macro_svp_check_exps_return(img == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "img can't be null\n");
    macro_svp_check_exps_return(src == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "src can't be null\n");

    _comm_ive_get_loop_info(img, &loop_info);
    td_void *_tmp_src = src;
    for (c = 0; (c < loop_info.loop_c) && (c < OT_SVP_IMG_STRIDE_NUM) && (c < OT_SVP_IMG_ADDR_NUM); c++) {
        ptr_tmp = macro_svp_convert_addr_to_ptr(td_u8, img->virt_addr[c]);
        macro_svp_check_exps_return(ptr_tmp == 0, OT_ERR_IVE_ILLEGAL_PARAM,
            ENUM_SVP_ERR_LEVEL_DEBUG, "ptr_tmp can't be 0\n");
        td_u32 len = img->width * loop_info.ele_size;
        if (len == img->stride[c] * loop_info.ele_size) {
            memcpy(ptr_tmp, _tmp_src, len * loop_info.loop_h[c]);
        }
        else
        {
            for (h = 0; h < loop_info.loop_h[c]; h++) {
                memcpy(ptr_tmp, _tmp_src, len);
                _tmp_src += len;
                ptr_tmp += img->stride[c] * loop_info.ele_size;
            }
        }
    }

    return TD_SUCCESS;
}

/*
 * function :Write os_mem
 */
td_s32 libapi_common_ive_write_os_mem(ot_svp_img *img, td_void *tar)
{
    td_u16 c, h;
    td_u8 *ptr_tmp = TD_NULL;
    td_s32 ret = OT_ERR_IVE_NULL_PTR;
    ot_struct_rw_image_loop_info loop_info = {0};

    macro_svp_check_exps_return(img == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "img can't be null\n");
    macro_svp_check_exps_return(tar == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "tar can't be null\n");
    ret = OT_ERR_IVE_ILLEGAL_PARAM;
    macro_svp_check_exps_return(img->phys_addr == 0, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "img->phys_addr can't be 0\n");
    macro_svp_check_exps_return(img->virt_addr == 0, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "img->phys_addr can't be 0\n");

    _comm_ive_get_loop_info(img, &loop_info);
    td_void *_tmp_tar = tar;
    for (c = 0; (c < loop_info.loop_c) && (c < OT_SVP_IMG_STRIDE_NUM) && (c < OT_SVP_IMG_ADDR_NUM); c++) {
        ptr_tmp = macro_svp_convert_addr_to_ptr(td_u8, img->virt_addr[c]);
        macro_svp_check_exps_return(ptr_tmp == 0, ret, ENUM_SVP_ERR_LEVEL_DEBUG, "ptr_tmp can't be 0\n");
        td_u32 len = img->width * loop_info.ele_size;
        if (len == img->stride[c] * loop_info.ele_size) {
            memcpy(_tmp_tar, ptr_tmp, len * loop_info.loop_h[c]);
            // macro_svp_trace_info("len is %d, len2 is %d\n", len, img->stride[c] * loop_info.ele_size);
        }
        else {
            for (h = 0; h < loop_info.loop_h[c]; h++) {
                memcpy(_tmp_tar, ptr_tmp, len);
                _tmp_tar += len;
                ptr_tmp += img->stride[c] * loop_info.ele_size;
            }
        }
    }
    return TD_SUCCESS;
}

/*
 * function :Calc stride
 */
td_u32 libapi_common_ive_calc_stride(td_u32 width, td_u8 align)
{
    macro_svp_check_exps_return(align == 0, OT_ERR_IVE_ILLEGAL_PARAM,
        ENUM_SVP_ERR_LEVEL_DEBUG, "align can't be 0\n");
    macro_svp_check_exps_return((width > OT_SAMPLE_IVE_MAX_WIDTH) || (width < 1), OT_ERR_IVE_ILLEGAL_PARAM,
        ENUM_SVP_ERR_LEVEL_DEBUG, "width(%u) must be in [1, %u]", width, OT_SAMPLE_IVE_MAX_WIDTH);
    return (width + (align - width % align) % align);
}

static td_void _comm_ive_get_thresh(ot_ive_ccblob *blob, td_u16 area_thr_step, td_u16 rect_max_num,
    td_u16 *thresh)
{
    td_u32 i;
    td_u16 num;
    td_u16 thr = blob->info.bits.cur_area_threshold;
    do {
        num = 0;
        thr += area_thr_step;
        for (i = 0; i < blob->info.bits.rgn_num; i++) {
            if (blob->rgn[i].area > thr) {
                num++;
            }
        }
    } while (num > rect_max_num);

    *thresh = thr;
}

/*
 * function : judge if rect is valid
 */
static td_void _common_ive_is_rect_valid(ot_struct_svp_rect_info *rect, td_u32 num, td_bool *valid)
{
    td_u32 j, k;
    for (j = 0; j < (OT_POINT_NUM - 1); j++) {
        for (k = j + 1; k < OT_POINT_NUM; k++) {
            if ((rect->rect[num].point[j].x == rect->rect[num].point[k].x) &&
                (rect->rect[num].point[j].y == rect->rect[num].point[k].y)) {
                *valid = TD_FALSE;
                break;
            }
        }
    }
}

/*
 * function : Copy blob to rect
 */
td_s32 libapi_common_ive_blob_to_rect(ot_ive_ccblob *blob, ot_struct_svp_rect_info *rect,
    td_u16 rect_max_num, td_u16 area_thr_step, ot_struct_src_dst_size src_dst_size)
{
    td_u16 num, i;
    td_u16 thr = 0;
    td_bool valid;
    macro_svp_check_exps_return(blob == TD_NULL, OT_ERR_IVE_NULL_PTR,
        ENUM_SVP_ERR_LEVEL_DEBUG, "blob can't be null\n");
    macro_svp_check_exps_return(rect == TD_NULL, OT_ERR_IVE_NULL_PTR,
        ENUM_SVP_ERR_LEVEL_DEBUG, "rect can't be null\n");

    if (blob->info.bits.rgn_num > rect_max_num) {
        _comm_ive_get_thresh(blob, area_thr_step, rect_max_num, &thr);
    }

    num = 0;
    for (i = 0; i < blob->info.bits.rgn_num; i++) {
        if (blob->rgn[i].area <= thr) {
            continue;
        }
        macro_svp_check_exps_return(num > (OT_SVP_RECT_NUM - 1), TD_FAILURE,
            ENUM_SVP_ERR_LEVEL_ERROR, "num is larger than %u\n", OT_SVP_RECT_NUM - 1);
        rect->rect[num].point[OT_MACRO_POINT_IDX_ZERO].x = (td_u32)((td_float)blob->rgn[i].left /
            (td_float)src_dst_size.src.width * (td_float)src_dst_size.dst.width) & (~1);
        rect->rect[num].point[OT_MACRO_POINT_IDX_ZERO].y = (td_u32)((td_float)blob->rgn[i].top /
            (td_float)src_dst_size.src.height * (td_float)src_dst_size.dst.height) & (~1);

        rect->rect[num].point[OT_MACRO_POINT_IDX_ONE].x = (td_u32)((td_float)blob->rgn[i].right /
            (td_float)src_dst_size.src.width * (td_float)src_dst_size.dst.width) & (~1);
        rect->rect[num].point[OT_MACRO_POINT_IDX_ONE].y = (td_u32)((td_float)blob->rgn[i].top /
            (td_float)src_dst_size.src.height * (td_float)src_dst_size.dst.height) & (~1);

        rect->rect[num].point[OT_MACRO_POINT_IDX_TWO].x = (td_u32)((td_float)blob->rgn[i].right /
            (td_float)src_dst_size.src.width * (td_float)src_dst_size.dst.width) & (~1);
        rect->rect[num].point[OT_MACRO_POINT_IDX_TWO].y = (td_u32)((td_float)blob->rgn[i].bottom /
            (td_float)src_dst_size.src.height * (td_float)src_dst_size.dst.height) & (~1);

        rect->rect[num].point[OT_MACRO_POINT_IDX_THREE].x = (td_u32)((td_float)blob->rgn[i].left /
            (td_float)src_dst_size.src.width * (td_float)src_dst_size.dst.width) & (~1);
        rect->rect[num].point[OT_MACRO_POINT_IDX_THREE].y = (td_u32)((td_float)blob->rgn[i].bottom /
            (td_float)src_dst_size.src.height * (td_float)src_dst_size.dst.height) & (~1);

        valid = TD_TRUE;
        _common_ive_is_rect_valid(rect, num, &valid);
        if (valid == TD_TRUE) {
            num++;
        }
    }

    rect->num = num;
    return TD_SUCCESS;
}


static td_s32 _comm_ive_set_image_addr(ot_svp_img *img, const ot_struct_rw_image_loop_info *loop_info,
    td_bool is_mmz_cached)
{
    td_u32 c;
    td_u32 size = 0;
    td_s32 ret;
    td_void *virt_addr = TD_NULL;
    for (c = 0; (c < loop_info->loop_c) && (c < OT_MAX_LOOP_IMG_H) && (c < OT_SVP_IMG_STRIDE_NUM); c++) {
        size += img->stride[0] * loop_info->loop_h[c] * loop_info->ele_size;
        img->stride[c] = img->stride[0];
    }

    if (is_mmz_cached == TD_FALSE) {
        ret = ss_mpi_sys_mmz_alloc((td_phys_addr_t *)&img->phys_addr[0], (td_void **)&virt_addr,
            TD_NULL, TD_NULL, size);
    } else {
        ret = ss_mpi_sys_mmz_alloc_cached((td_phys_addr_t *)&img->phys_addr[0], (td_void **)&virt_addr,
            TD_NULL, TD_NULL, size);
    }
    macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR, "mmz malloc fail\n");
    img->virt_addr[OT_MACRO_ADDR_IDX_ZERO] = macro_svp_convert_ptr_to_addr(td_u64, virt_addr);

    if (img->type != OT_SVP_IMG_TYPE_U8C3_PACKAGE) {
        for (c = 1; (c < loop_info->loop_c) && (c < OT_MAX_LOOP_IMG_H) && (c < OT_SVP_IMG_STRIDE_NUM); c++) {
            img->phys_addr[c] = img->phys_addr[c - 1] + img->stride[c - 1] * img->height;
            img->virt_addr[c] = img->virt_addr[c - 1] + img->stride[c - 1] * img->height;
        }
    } else {
        img->virt_addr[OT_MACRO_ADDR_IDX_ONE] = img->virt_addr[OT_MACRO_ADDR_IDX_ZERO] + 1;
        img->virt_addr[OT_MACRO_ADDR_IDX_TWO] = img->virt_addr[OT_MACRO_ADDR_IDX_ONE] + 1;
        img->phys_addr[OT_MACRO_ADDR_IDX_ONE] = img->phys_addr[OT_MACRO_ADDR_IDX_ZERO] + 1;
        img->phys_addr[OT_MACRO_ADDR_IDX_TWO] = img->phys_addr[OT_MACRO_ADDR_IDX_ONE] + 1;
    }
    return TD_SUCCESS;
}

/*
 * function : Create ive image
 */
static td_s32 _common_ive_create_image_flag(ot_svp_img *img, ot_svp_img_type type,
    td_u32 width, td_u32 height, td_bool is_mmz_cached)
{
    td_s32 ret = OT_ERR_IVE_ILLEGAL_PARAM;
    ot_struct_rw_image_loop_info loop_info = {0};
    macro_svp_check_exps_return(img == TD_NULL, OT_ERR_IVE_NULL_PTR, ENUM_SVP_ERR_LEVEL_ERROR, "img can't be null\n");
    macro_svp_check_exps_return((type < 0) || (type >= OT_SVP_IMG_TYPE_BUTT), ret, ENUM_SVP_ERR_LEVEL_ERROR,
        "type(%u) must be in [0, %u)!\n", type, OT_SVP_IMG_TYPE_BUTT);
    macro_svp_check_exps_return(width > OT_SAMPLE_IVE_MAX_WIDTH, ret, ENUM_SVP_ERR_LEVEL_ERROR,
        "width(%u) must be in [1, %u]!\n", width, OT_SAMPLE_IVE_MAX_WIDTH);
    macro_svp_check_exps_return(width > OT_SAMPLE_IVE_MAX_HEIGHT, ret, ENUM_SVP_ERR_LEVEL_ERROR,
        "width(%u) must be in [1, %u]!\n", width, OT_SAMPLE_IVE_MAX_HEIGHT);

    img->type = type;
    img->width = width;
    img->height = height;
    img->stride[0] = libapi_common_ive_calc_stride(img->width, OT_IVE_ALIGN);

    switch (type) {
        case OT_SVP_IMG_TYPE_U8C1:
        case OT_SVP_IMG_TYPE_S8C1:
        case OT_SVP_IMG_TYPE_YUV420SP:
        case OT_SVP_IMG_TYPE_YUV422SP:
        case OT_SVP_IMG_TYPE_S16C1:
        case OT_SVP_IMG_TYPE_U16C1:
        case OT_SVP_IMG_TYPE_U8C3_PACKAGE:
        case OT_SVP_IMG_TYPE_S32C1:
        case OT_SVP_IMG_TYPE_U32C1:
        case OT_SVP_IMG_TYPE_S64C1:
        case OT_SVP_IMG_TYPE_U64C1: {
            _comm_ive_get_loop_info(img, &loop_info);
            ret = _comm_ive_set_image_addr(img, &loop_info, is_mmz_cached);
            macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
                "Err:%#x,_comm_ive_set_image_addr failed\n", ret);
            break;
            }
        case OT_SVP_IMG_TYPE_YUV420P:
            break;
        case OT_SVP_IMG_TYPE_YUV422P:
            break;
        case OT_SVP_IMG_TYPE_S8C2_PACKAGE:
            break;
        case OT_SVP_IMG_TYPE_S8C2_PLANAR:
            break;
        case OT_SVP_IMG_TYPE_U8C3_PLANAR:
            break;
        default:
            break;
    }


    return TD_SUCCESS;
}

td_s32 libapi_common_ive_create_image(ot_svp_img *img, ot_svp_img_type type,
    td_u32 width, td_u32 height)
{
    return _common_ive_create_image_flag(img, type, width, height, TD_FALSE);
}

td_s32 libapi_common_ive_destroy_image(ot_svp_img *img)
{
    if (TD_NULL != img) macro_svp_mmz_free(img->phys_addr[0], img->virt_addr[0]);
    return TD_SUCCESS;
}

/*
 * function : Create memory info
 */
td_s32 libapi_common_ive_create_mem_info(ot_svp_mem_info *mem_info, td_u32 size)
{
    td_s32 ret = OT_ERR_IVE_NULL_PTR;
    td_void *virt_addr = TD_NULL;

    macro_svp_check_exps_return(mem_info == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_ERROR, "mem_info can't be null\n");

    mem_info->size = size;
    ret = ss_mpi_sys_mmz_alloc((td_phys_addr_t *)&mem_info->phys_addr, (td_void **)&virt_addr, TD_NULL, TD_NULL, size);
    macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
        "Mmz Alloc fail,Error(%#x)\n", ret);
    mem_info->virt_addr = macro_svp_convert_ptr_to_addr(td_u64, virt_addr);

    return TD_SUCCESS;
}

/*
 * function : Destroy memory info
 */
td_s32 libapi_common_ive_destroy_mem_info(ot_svp_mem_info *mem_info)
{
    if (TD_NULL != mem_info) macro_svp_mmz_free(mem_info->phys_addr, mem_info->virt_addr);
    return TD_SUCCESS;
}

/*
 * function : Create ive image by cached
 */
td_s32 libapi_common_ive_create_image_by_cached(ot_svp_img *img, ot_svp_img_type type,
    td_u32 width, td_u32 height)
{
    return _common_ive_create_image_flag(img, type, width, height, TD_TRUE);
}

/*
 * function : Dma frame info to ive image
 */
td_s32 libapi_common_ive_dma_image(ot_video_frame_info *frame_info, ot_svp_dst_img *dst,
    td_bool is_instant)
{
    td_s32 ret = OT_ERR_IVE_NULL_PTR;
    ot_ive_handle handle;
    ot_svp_src_data src_data;
    ot_svp_dst_data dst_data;
    ot_ive_dma_ctrl ctrl = { OT_IVE_DMA_MODE_DIRECT_COPY, 0, 0, 0, 0 };
    td_bool is_finish = TD_FALSE;
    td_bool is_block = TD_TRUE;

    macro_svp_check_exps_return(frame_info == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_ERROR, "frame_info can't be null\n");
    macro_svp_check_exps_return(dst == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_ERROR, "dst can't be null\n");
    macro_svp_check_exps_return(frame_info->video_frame.virt_addr == TD_NULL, ret, ENUM_SVP_ERR_LEVEL_ERROR,
        "frame_info->video_frame.virt_addr can't be null\n");
    ret = OT_ERR_IVE_ILLEGAL_PARAM;
    macro_svp_check_exps_return(frame_info->video_frame.phys_addr == 0, ret, ENUM_SVP_ERR_LEVEL_ERROR,
        "frame_info->video_frame.virt_addr can't be 0\n");
    macro_svp_check_exps_return(dst->virt_addr == 0, ret, ENUM_SVP_ERR_LEVEL_ERROR, "dst->virt_addr can't be 0\n");
    macro_svp_check_exps_return(dst->phys_addr == 0, ret, ENUM_SVP_ERR_LEVEL_ERROR, "dst->phys_addr can't be 0\n");

    /* fill src */
    src_data.virt_addr = macro_svp_convert_ptr_to_addr(td_u64, frame_info->video_frame.virt_addr[0]);
    src_data.phys_addr = frame_info->video_frame.phys_addr[0];
    src_data.width = frame_info->video_frame.width;
    src_data.height = frame_info->video_frame.height;
    src_data.stride = frame_info->video_frame.stride[0];

    /* fill dst */
    dst_data.virt_addr = dst->virt_addr[0];
    dst_data.phys_addr = dst->phys_addr[0];
    dst_data.width = dst->width;
    dst_data.height = dst->height;
    dst_data.stride = dst->stride[0];

    ret = ss_mpi_ive_dma(&handle, &src_data, &dst_data, &ctrl, is_instant);
    macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
        "Error(%#x),ss_mpi_ive_dma failed!\n", ret);

    if (is_instant == TD_TRUE) {
        ret = ss_mpi_ive_query(handle, &is_finish, is_block);
        while (ret == OT_ERR_IVE_QUERY_TIMEOUT) {
            usleep(OT_SAMPLE_IVE_QUERY_SLEEP);
            ret = ss_mpi_ive_query(handle, &is_finish, is_block);
        }
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),ss_mpi_ive_query failed!\n", ret);
    }

    return TD_SUCCESS;
}