/*
  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 <semaphore.h>
#include <pthread.h>
#include <math.h>
#include <limits.h>

#define OT_MACRO_IVE_CANNY_QUERY_SLEEP  100
#define OT_MACRO_IVE_CANNY_HIGH_THR     150
#define OT_MACRO_IVE_CANNY_LOW_THR      50
#define OT_MACRO_IVE_THR_U16_HIGH_THR   100
#define OT_MACRO_IVE_THR_U16_LOW_THR    100
#define OT_MACRO_IVE_THR_U16_MAX_VAL    255
#define OT_MACRO_IVE_CANNY_EDGE_NUM     3
#define OT_MACRO_IVE_D1_WIDTH           720
#define OT_MACRO_IVE_D1_HEIGHT          576

typedef struct {
    ot_svp_src_img src;
    ot_svp_dst_img edge;
    ot_svp_dst_img mag;
    ot_svp_mem_info stack;
    ot_ive_canny_hys_edge_ctrl canny_hys_edge_ctrl;
    ot_ive_mag_and_ang_ctrl mag_and_ang_ctrl;
    ot_ive_threshold_u16_ctrl thr_u16_ctrl;
    void *p_os_src_mem; // 必须是已经分配好得内存
    void *p_os_edge_mem; // 必须是已经分配好得内存
    td_u32 width;
    td_u32 height;
    td_u32 type;
    FILE *fp_src;
    FILE *fp_dst;
} ot_struct_ive_canny_info;

static ot_struct_ive_canny_info g_canny_info;
static td_bool g_stop_signal = TD_FALSE;

/*
 * function : Canny uninit
 */
static td_void _ive_canny_uninit(ot_struct_ive_canny_info *canny_info)
{
    macro_svp_mmz_free(canny_info->src.phys_addr[0], canny_info->src.virt_addr[0]);
    macro_svp_mmz_free(canny_info->edge.phys_addr[0], canny_info->edge.virt_addr[0]);
    macro_svp_mmz_free(canny_info->mag.phys_addr[0], canny_info->mag.virt_addr[0]);
    macro_svp_mmz_free(canny_info->stack.phys_addr, canny_info->stack.virt_addr);
    macro_svp_mmz_free(canny_info->canny_hys_edge_ctrl.mem.phys_addr,
        canny_info->canny_hys_edge_ctrl.mem.virt_addr);

    macro_svp_close_file(canny_info->fp_src);
    macro_svp_close_file(canny_info->fp_dst);
}

static td_void _ive_canny_ctrl_init(ot_struct_ive_canny_info *canny_info)
{
    canny_info->canny_hys_edge_ctrl.high_threshold = OT_MACRO_IVE_CANNY_HIGH_THR;
    canny_info->canny_hys_edge_ctrl.low_threshold = OT_MACRO_IVE_CANNY_LOW_THR;
    canny_info->mag_and_ang_ctrl.out_ctrl = OT_IVE_MAG_AND_ANG_OUT_CTRL_MAG;
    canny_info->mag_and_ang_ctrl.threshold = 0;
    canny_info->thr_u16_ctrl.mode = OT_IVE_THRESHOLD_U16_MODE_U16_TO_U8_MIN_MID_MAX;
    canny_info->thr_u16_ctrl.high_threshold = OT_MACRO_IVE_THR_U16_HIGH_THR;
    canny_info->thr_u16_ctrl.low_threshold = OT_MACRO_IVE_THR_U16_LOW_THR;
    canny_info->thr_u16_ctrl.max_val = OT_MACRO_IVE_THR_U16_MAX_VAL;
    canny_info->thr_u16_ctrl.mid_val = 0;
    canny_info->thr_u16_ctrl.min_val = 0;
}

static td_void _ive_canny_ctrl_init_ex(ot_ive_canny_hys_edge_ctrl *canny_hys_edge_ctrl, 
                                       ot_ive_mag_and_ang_ctrl *mag_and_ang_ctrl,
                                       ot_ive_threshold_u16_ctrl *thr_u16_ctrl)
{
    canny_hys_edge_ctrl->high_threshold = OT_MACRO_IVE_CANNY_HIGH_THR;
    canny_hys_edge_ctrl->low_threshold = OT_MACRO_IVE_CANNY_LOW_THR;
    mag_and_ang_ctrl->out_ctrl = OT_IVE_MAG_AND_ANG_OUT_CTRL_MAG;
    mag_and_ang_ctrl->threshold = 0;
    thr_u16_ctrl->mode = OT_IVE_THRESHOLD_U16_MODE_U16_TO_U8_MIN_MID_MAX;
    thr_u16_ctrl->high_threshold = OT_MACRO_IVE_THR_U16_HIGH_THR;
    thr_u16_ctrl->low_threshold = OT_MACRO_IVE_THR_U16_LOW_THR;
    thr_u16_ctrl->max_val = OT_MACRO_IVE_THR_U16_MAX_VAL;
    thr_u16_ctrl->mid_val = 0;
    thr_u16_ctrl->min_val = 0;
}

/*
 * function : Canny init
 */
static td_s32 _ive_canny_init(ot_struct_ive_canny_info *canny_info, td_u32 width,
    td_u32 height, td_char canny_complete)
{
    td_s32 ret;
    td_u32 size;
    td_char path[PATH_MAX] = {0};
    td_char tmp_file[PATH_MAX] = {0};
    td_s8 mask[OT_IVE_MASK_NUM] =   { 0,  0, 0, 0, 0, 0, -1, 0, 1, 0, 0, -2, 0, 2, 0, 0, -1, 0, 1, 0, 0,  0, 0, 0, 0 };
    const td_char *src_file = "./data/input/canny/canny.yuv";

    macro_svp_check_exps_return((strlen(src_file) > PATH_MAX) || (realpath(src_file, path) == TD_NULL),
        OT_ERR_IVE_ILLEGAL_PARAM, ENUM_SVP_ERR_LEVEL_ERROR, "invalid file!\n");

    (td_void)memset_s(canny_info, sizeof(ot_struct_ive_canny_info), 0, sizeof(ot_struct_ive_canny_info));
    ret = memcpy_s(canny_info->canny_hys_edge_ctrl.mask, OT_IVE_MASK_NUM, mask, OT_IVE_MASK_NUM);
    macro_svp_check_exps_return(ret != EOK, ret, ENUM_SVP_ERR_LEVEL_ERROR, "memcpy_s mask failed!\n");
    ret = memcpy_s(canny_info->mag_and_ang_ctrl.mask, OT_IVE_MASK_NUM, mask, OT_IVE_MASK_NUM);
    macro_svp_check_exps_return(ret != EOK, ret, ENUM_SVP_ERR_LEVEL_ERROR, "memcpy_s mask failed!\n");

    _ive_canny_ctrl_init(canny_info);

    ret = libapi_common_ive_create_image(&canny_info->src, OT_SVP_IMG_TYPE_U8C1, width, height);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR, "Error,create src img failed!\n");

    ret = libapi_common_ive_create_image(&canny_info->edge, OT_SVP_IMG_TYPE_U8C1, width, height);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR, "Error,create edge img failed!\n");

    ret = libapi_common_ive_create_image(&canny_info->mag, OT_SVP_IMG_TYPE_U16C1, width, height);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR, "Error,create mag img failed!\n");

    size = canny_info->src.stride[0] * canny_info->src.height * sizeof(ot_svp_point_u16) +
        sizeof(ot_ive_canny_stack_size);
    ret = libapi_common_ive_create_mem_info(&canny_info->stack, size);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR,
        "Error,create stack mem_info failed!\n");

    size = canny_info->src.stride[0] * canny_info->src.height * OT_MACRO_IVE_CANNY_EDGE_NUM;
    ret = libapi_common_ive_create_mem_info(&canny_info->canny_hys_edge_ctrl.mem, size);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR,
        "Error,create canny_hys_edge_ctrl.mem failed!\n");

    /* src file */
    ret = TD_FAILURE;
    canny_info->fp_src = fopen(path, "rb");
    macro_svp_check_exps_goto(canny_info->fp_src == TD_NULL, fail, ENUM_SVP_ERR_LEVEL_ERROR, "Open file failed!\n");

    /* dst file */
    macro_svp_check_exps_goto(realpath("./data/output/canny", path) == TD_NULL, fail,
        ENUM_SVP_ERR_LEVEL_ERROR, "invalid file!\n");
    ret = snprintf_s(tmp_file, sizeof(tmp_file) - 1, sizeof(tmp_file) - 1, "/cannyout_complete_%c.yuv", canny_complete);
    macro_svp_check_exps_goto((ret < 0) || (ret > (td_s32)(sizeof(tmp_file) - 1)), fail,
        ENUM_SVP_ERR_LEVEL_ERROR, "Error,snprintf_s src file name failed!\n");

    ret = strcat_s(path, PATH_MAX, tmp_file);
    macro_svp_check_exps_goto(ret != EOK, fail, ENUM_SVP_ERR_LEVEL_ERROR, "strcat_s failed!\n");
    ret = TD_FAILURE;
    canny_info->fp_dst = fopen(path, "wb");
    macro_svp_check_exps_goto(canny_info->fp_dst == TD_NULL, fail, ENUM_SVP_ERR_LEVEL_ERROR, "Open file failed!\n");

    return TD_SUCCESS;
fail:
    _ive_canny_uninit(canny_info);
    return ret;
}

/*
 * function : show complete canny demo
 */
static td_s32 _ive_complete_canny(ot_struct_ive_canny_info *canny_info)
{
    td_s32 ret, i;
    td_bool is_instant = TD_TRUE;
    td_bool is_block = TD_TRUE;
    td_bool is_finish = TD_FALSE;
    ot_ive_handle handle;

    for (i = 0; (i < 1) && (g_stop_signal == TD_FALSE); i++) {
        ret = libapi_common_ive_read_file(&(canny_info->src), canny_info->fp_src);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),Read src file failed!\n", ret);

        ret = ss_mpi_ive_canny_hys_edge(&handle, &canny_info->src, &canny_info->edge, &canny_info->stack,
            &canny_info->canny_hys_edge_ctrl, is_instant);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),ss_mpi_ive_canny_hys_edge failed!\n", ret);

        ret = ss_mpi_ive_query(handle, &is_finish, is_block);
        while (ret == OT_ERR_IVE_QUERY_TIMEOUT) {
            usleep(OT_MACRO_IVE_CANNY_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);

        ret = ss_mpi_ive_canny_edge(&canny_info->edge, &canny_info->stack);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),ss_mpi_ive_canny_edge failed!\n", ret);

        ret = libapi_common_ive_write_file(&canny_info->edge, canny_info->fp_dst);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),Write edge file failed!\n", ret);
    }
    return TD_SUCCESS;
}


/*
 * function : show part canny demo
 */
static td_s32 _ive_part_canny(ot_struct_ive_canny_info *canny_info)
{
    td_s32 ret, i;
    td_bool is_instant = TD_FALSE;
    td_bool is_block = TD_TRUE;
    td_bool is_finish = TD_FALSE;
    ot_ive_handle handle;

    for (i = 0; (i < 1) && (g_stop_signal == TD_FALSE); i++) {
        ret = libapi_common_ive_read_file(&canny_info->src, canny_info->fp_src);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),Read src file failed!\n", ret);

        ret = ss_mpi_ive_mag_and_ang(&handle, &canny_info->src, &canny_info->mag, TD_NULL,
            &canny_info->mag_and_ang_ctrl, is_instant);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),ss_mpi_ive_mag_and_ang failed!\n", ret);

        is_instant = TD_TRUE;
        ret = ss_mpi_ive_threshold_u16(&handle, &canny_info->mag, &canny_info->edge,
            &canny_info->thr_u16_ctrl, is_instant);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),ss_mpi_ive_threshold_u16 failed!\n", ret);

        ret = ss_mpi_ive_query(handle, &is_finish, is_block);
        while (ret == OT_ERR_IVE_QUERY_TIMEOUT) {
            usleep(OT_MACRO_IVE_CANNY_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);

        ret = libapi_common_ive_write_file(&canny_info->edge, canny_info->fp_dst);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),Write edge file failed!\n", ret);
    }
    return TD_SUCCESS;
}

static td_void _ive_canny_stop(td_void)
{
    _ive_canny_uninit(&g_canny_info);
    (td_void)memset_s(&g_canny_info, sizeof(g_canny_info), 0, sizeof(g_canny_info));
    libapi_common_ive_mpi_exit();
    printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
}

/*
 * function : show canny demo
 */
static td_void _libapi_ive_canny(td_char canny_complete)
{
    const td_u16 width = OT_MACRO_IVE_D1_WIDTH;
    const td_u16 height = OT_MACRO_IVE_D1_HEIGHT;
    td_s32 ret;

    (td_void)memset_s(&g_canny_info, sizeof(g_canny_info), 0, sizeof(g_canny_info));

    ret = libapi_common_ive_check_mpi_init();
    macro_svp_check_exps_return_void(ret != TD_TRUE, ENUM_SVP_ERR_LEVEL_ERROR, "ive_check_mpi_init failed!\n");

    ret = _ive_canny_init(&g_canny_info, width, height, canny_complete);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, canny_fail, ENUM_SVP_ERR_LEVEL_ERROR,
        "Error(%#x),_ive_canny_init failed!\n", ret);

    if (canny_complete == '0') {
        ret = _ive_part_canny(&g_canny_info);
    } else {
        ret = _ive_complete_canny(&g_canny_info);
    }

    if (g_stop_signal == TD_TRUE) {
        _ive_canny_stop();
        return;
    }

    if (ret == TD_SUCCESS) {
        macro_svp_trace_info("Process success!\n");
    }

    g_stop_signal = TD_TRUE;
    _ive_canny_uninit(&g_canny_info);
    (td_void)memset_s(&g_canny_info, sizeof(g_canny_info), 0, sizeof(g_canny_info));

canny_fail:
    g_stop_signal = TD_TRUE;
    libapi_common_ive_mpi_exit();
}

/*
 * function :Canny demo signal handle
 */
td_void libapi_ive_canny_handle_sig(td_void)
{
    g_stop_signal = TD_TRUE;
}

// 初始化 canny_info
static td_s32 _ive_canny_init_self_define(ot_struct_ive_canny_info *canny_info, td_u32 width,
    td_u32 height, td_u32 type, td_char canny_complete)
{
    td_s32 ret;
    td_u32 size;
    td_char path[PATH_MAX] = {0};
    td_char tmp_file[PATH_MAX] = {0};
    td_s8 mask[OT_IVE_MASK_NUM] =   { 0,  0, 0, 0, 0, 0, -1, 0, 1, 0, 0, -2, 0, 2, 0, 0, -1, 0, 1, 0, 0,  0, 0, 0, 0 };

    (td_void)memset_s(canny_info, sizeof(ot_struct_ive_canny_info), 0, sizeof(ot_struct_ive_canny_info));
    ret = memcpy_s(canny_info->canny_hys_edge_ctrl.mask, OT_IVE_MASK_NUM, mask, OT_IVE_MASK_NUM);
    macro_svp_check_exps_return(ret != EOK, ret, ENUM_SVP_ERR_LEVEL_ERROR, "memcpy_s mask failed!\n");
    ret = memcpy_s(canny_info->mag_and_ang_ctrl.mask, OT_IVE_MASK_NUM, mask, OT_IVE_MASK_NUM);
    macro_svp_check_exps_return(ret != EOK, ret, ENUM_SVP_ERR_LEVEL_ERROR, "memcpy_s mask failed!\n");

    _ive_canny_ctrl_init(canny_info);
    canny_info->width = width;
    canny_info->height = height;
    canny_info->type = type;

    ret = libapi_common_ive_create_image(&canny_info->src, type, width, height);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR, "Error,create src img failed!\n");


    ret = libapi_common_ive_create_image(&canny_info->mag, OT_SVP_IMG_TYPE_U16C1, width, height);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR, "Error,create mag img failed!\n");

    ret = libapi_common_ive_create_image(&canny_info->edge, OT_SVP_IMG_TYPE_U8C1, width, height);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR, "Error,create edge img failed!\n");

    size = canny_info->src.stride[0] * canny_info->src.height * sizeof(ot_svp_point_u16) +
        sizeof(ot_ive_canny_stack_size);
    ret = libapi_common_ive_create_mem_info(&canny_info->stack, size);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR,
        "Error,create stack mem_info failed!\n");

    size = canny_info->src.stride[0] * canny_info->src.height * OT_MACRO_IVE_CANNY_EDGE_NUM;
    ret = libapi_common_ive_create_mem_info(&canny_info->canny_hys_edge_ctrl.mem, size);
    macro_svp_check_exps_goto(ret != TD_SUCCESS, fail, ENUM_SVP_ERR_LEVEL_ERROR,
        "Error,create canny_hys_edge_ctrl.mem failed!\n");

    return TD_SUCCESS;
fail:
    _ive_canny_uninit(canny_info);
    return ret;
}

/*
 * function : show part canny demo
 */
static td_s32 _ive_part_canny_self_define(ot_struct_ive_canny_info *canny_info)
{
    td_s32 ret, i;
    td_bool is_instant = TD_FALSE;
    td_bool is_block = TD_TRUE;
    td_bool is_finish = TD_FALSE;
    ot_ive_handle handle;

    for (i = 0; (i < 1) && (g_stop_signal == TD_FALSE); i++) {
        ret = libapi_common_ive_read_os_mem(&canny_info->src, canny_info->p_os_src_mem, 
            canny_info->width, canny_info->height, canny_info->type);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),Read src os mem failed!\n", ret);

        ret = ss_mpi_ive_mag_and_ang(&handle, &canny_info->src, &canny_info->mag, TD_NULL,
            &canny_info->mag_and_ang_ctrl, is_instant);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),ss_mpi_ive_mag_and_ang failed!\n", ret);

        is_instant = TD_TRUE;
        ret = ss_mpi_ive_threshold_u16(&handle, &canny_info->mag, &canny_info->edge,
            &canny_info->thr_u16_ctrl, is_instant);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),ss_mpi_ive_threshold_u16 failed!\n", ret);

        ret = ss_mpi_ive_query(handle, &is_finish, is_block);
        while (ret == OT_ERR_IVE_QUERY_TIMEOUT) {
            usleep(OT_MACRO_IVE_CANNY_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);

        ret = libapi_common_ive_write_os_mem(&canny_info->edge, canny_info->p_os_edge_mem);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),Write edge mem os failed!\n", ret);
    }
    return TD_SUCCESS;
}

static td_s32 _ive_complete_canny_self_define(ot_struct_ive_canny_info *canny_info)
{
    td_s32 ret, i;
    td_bool is_instant = TD_TRUE;
    td_bool is_block = TD_TRUE;
    td_bool is_finish = TD_FALSE;
    ot_ive_handle handle;

    for (i = 0; (i < 1) && (g_stop_signal == TD_FALSE); i++) {
        ret = libapi_common_ive_read_os_mem(&canny_info->src, canny_info->p_os_src_mem, 
            canny_info->width, canny_info->height, canny_info->type);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),Read src os mem failed!\n", ret);

        ret = ss_mpi_ive_canny_hys_edge(&handle, &canny_info->src, &canny_info->edge, &canny_info->stack,
            &canny_info->canny_hys_edge_ctrl, is_instant);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),ss_mpi_ive_canny_hys_edge failed!\n", ret);

        ret = ss_mpi_ive_query(handle, &is_finish, is_block);
        while (ret == OT_ERR_IVE_QUERY_TIMEOUT) {
            usleep(OT_MACRO_IVE_CANNY_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);

        ret = ss_mpi_ive_canny_edge(&canny_info->edge, &canny_info->stack);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),ss_mpi_ive_canny_edge failed!\n", ret);

        ret = libapi_common_ive_write_os_mem(&canny_info->edge, canny_info->p_os_edge_mem);
        macro_svp_check_exps_return(ret != TD_SUCCESS, ret, ENUM_SVP_ERR_LEVEL_ERROR,
            "Error(%#x),Write edge mem os failed!\n", ret);
    }
    return TD_SUCCESS;
}

static td_void _ive_canny_stop_self_define(ot_struct_ive_canny_info *canny_info)
{
    _ive_canny_uninit(&canny_info);
    (td_void)memset_s(&canny_info, sizeof(canny_info), 0, sizeof(canny_info));
    // libapi_common_ive_mpi_exit(); //for test
    printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
}

/*
 * function :Canny api signal handle
 */
td_u32 libapi_ive_canny(td_void* src, td_u32 width, td_u32 height, td_u32 img_type, 
    td_void* dst, td_char canny_complete)
{
    td_s32 ret = TD_SUCCESS;
    static ot_struct_ive_canny_info canny_info;
    (td_void)memset_s(&canny_info, sizeof(canny_info), 0, sizeof(canny_info));

    //for test
    // ret = libapi_common_ive_check_mpi_init();
    // macro_svp_check_exps_return_void(ret != TD_TRUE, ENUM_SVP_ERR_LEVEL_ERROR, "ive_check_mpi_init failed!\n");

    ret = _ive_canny_init_self_define(&canny_info, width, height, img_type, canny_complete);
    canny_info.p_os_src_mem = src;
    canny_info.p_os_edge_mem = dst;

    macro_svp_check_exps_goto(ret != TD_SUCCESS, canny_fail, ENUM_SVP_ERR_LEVEL_ERROR,
        "Error(%#x),_ive_canny_init failed!\n", ret);

    if (canny_complete == '0') {
        ret = _ive_part_canny_self_define(&canny_info);
    } else {
        ret = _ive_complete_canny_self_define(&canny_info);
    }

    if (g_stop_signal == TD_TRUE) {
        _ive_canny_stop_self_define(&canny_info);
        return ret;
    }

    if (ret == TD_SUCCESS) {
        macro_svp_trace_info("Process success!\n");
    }

    g_stop_signal = TD_TRUE;
    // 删除分配的物理内存
    _ive_canny_uninit(&canny_info);
    (td_void)memset_s(&canny_info, sizeof(canny_info), 0, sizeof(canny_info));

canny_fail:
    g_stop_signal = TD_TRUE;
    // for test
    // libapi_common_ive_mpi_exit();
    return ret;
}