// SPDX-License-Identifier: (GPL-2.0-only OR MIT)
/*
 * Copyright (C) 2025 Amlogic, Inc. All rights reserved
 */
#include "lib_cve.h"
#include "cve.h"
#include "cve_check_params.h"
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#define CVE_MIN(a, b) ((a) < (b) ? (a) : (b))
#define CVE_MAX(a, b) ((a) > (b) ? (a) : (b))
#define CVE_CLIP3(low, high, x) (CVE_MAX(CVE_MIN(x, high), low))

#define CVE_DEV "/dev/cve"
static pthread_mutex_t g_stCveMutex = PTHREAD_MUTEX_INITIALIZER;
static int g_s32CveFd = -1;

static int cve_check_fd_open()
{
    int s32Ret = 0;

    pthread_mutex_lock(&g_stCveMutex);
    if (g_s32CveFd < 0) {
        g_s32CveFd = open(CVE_DEV, O_RDWR);
        if (g_s32CveFd < 0) {
            CVE_ERR_LOG("cve dev open failed\n");
            s32Ret = CVE_ERR_NOTREADY;
        }
    }
    pthread_mutex_unlock(&g_stCveMutex);

    return s32Ret;
}

static int cve_norm_grad(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDstH,
                         CVE_DST_IMAGE_T *pstDstV, CVE_DST_IMAGE_T *pstDstHV,
                         CVE_NORM_GRAD_CTRL_T *pstNormGradCtrl, bool bInstant)
{
    CVE_OP_NORM_GRAD_T stOpNormGrad;
    int s32Ret = 0;

    s32Ret = cve_check_norm_grad_param_user(pCveHandle, pstSrc, pstDstH, pstDstV, pstDstHV,
                                            pstNormGradCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check NormGrad parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpNormGrad, 0, sizeof(CVE_OP_NORM_GRAD_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpNormGrad.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));

    switch (pstNormGradCtrl->enOutCtrl) {
    case CVE_NORM_GRAD_OUT_CTRL_HOR_AND_VER:
        memcpy(&stOpNormGrad.stDstH, pstDstH, sizeof(CVE_DST_IMAGE_T));
        memcpy(&stOpNormGrad.stDstV, pstDstV, sizeof(CVE_DST_IMAGE_T));
        break;
    case CVE_NORM_GRAD_OUT_CTRL_HOR:
        memcpy(&stOpNormGrad.stDstH, pstDstH, sizeof(CVE_DST_IMAGE_T));
        break;
    case CVE_NORM_GRAD_OUT_CTRL_VER:
        memcpy(&stOpNormGrad.stDstV, pstDstV, sizeof(CVE_DST_IMAGE_T));
        break;
    case CVE_NORM_GRAD_OUT_CTRL_COMBINE:
        memcpy(&stOpNormGrad.stDstHV, pstDstHV, sizeof(CVE_DST_IMAGE_T));
        break;
    default:
        break;
    }

    memcpy(&stOpNormGrad.stNormGradCtrl, pstNormGradCtrl, sizeof(CVE_NORM_GRAD_CTRL_T));

    stOpNormGrad.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_NORM_GRAD, &stOpNormGrad);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpNormGrad.cveHandle;

    return s32Ret;
}

int CVE_DMA(CVE_HANDLE *pCveHandle, CVE_DATA_T *pstSrc, CVE_DST_DATA_T *pstDst,
            CVE_DMA_CTRL_T *pstDmaCtrl, bool bInstant)
{
    CVE_OP_DMA_T stOpDMA;
    int s32Ret = 0;

    s32Ret = cve_check_dma_param_user(pCveHandle, pstSrc, pstDst, pstDmaCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check DMA parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpDMA, 0, sizeof(CVE_OP_DMA_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    if (pstDmaCtrl->enMode <= CVE_DMA_MODE_INTERVAL_COPY ||
        pstDmaCtrl->enMode == CVE_DMA_MODE_NOT || pstDmaCtrl->enMode == CVE_DMA_MODE_COL2IM ||
        pstDmaCtrl->enMode == CVE_DMA_MODE_DIRECT_COPY_TO_LINE) {
        memcpy(&stOpDMA.stSrcDATA, pstSrc, sizeof(CVE_SRC_DATA_T));
    }
    memcpy(&stOpDMA.stDstDATA, pstDst, sizeof(CVE_DST_DATA_T));
    memcpy(&stOpDMA.stDmaCtrl, pstDmaCtrl, sizeof(CVE_DMA_CTRL_T));
    stOpDMA.bInstant = bInstant;
    s32Ret = ioctl(g_s32CveFd, CVE_OP_DMA, &stOpDMA);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpDMA.cveHandle;

    return s32Ret;
}

int CVE_LumaStatArray(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_MEM_INFO_T *pstDst,
                      const CVE_RECT_U16_T astCveLumaRect[],
                      CVE_LUMA_STAT_ARRAY_CTRL_T *pstLumaStatArrayCtrl, bool bInstant)
{
    CVE_OP_LUAM_STAT_ARRAY_T stOpLuamStat;
    int s32Ret = 0;

    s32Ret = cve_check_luamStat_param_user(pCveHandle, pstSrc, pstDst, astCveLumaRect,
                                           pstLumaStatArrayCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check LuamStat parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpLuamStat, 0, sizeof(CVE_OP_LUAM_STAT_ARRAY_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpLuamStat.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpLuamStat.stDstMem, pstDst, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpLuamStat.stLumaStatArrayCtrl, pstLumaStatArrayCtrl,
           sizeof(CVE_LUMA_STAT_ARRAY_CTRL_T));
    memcpy(stOpLuamStat.astCveLumaRect, astCveLumaRect,
           sizeof(CVE_RECT_U16_T) * pstLumaStatArrayCtrl->u8MaxLumaRect);
    stOpLuamStat.bInstant = bInstant;
    s32Ret = ioctl(g_s32CveFd, CVE_OP_LUMA_STAT, &stOpLuamStat);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpLuamStat.cveHandle;

    return s32Ret;
}

int CVE_Filter(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
               CVE_DST_MEM_INFO_T *pstDstMem, CVE_FILTER_CTRL_T *pstFltCtrl, bool bInstant)
{
    CVE_OP_FILTER_T stOpFilter;
    int s32Ret = 0;

    s32Ret = cve_check_filter_param_user(pCveHandle, pstSrc, pstDst, pstDstMem, pstFltCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Filter parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }
    memset((void *)&stOpFilter, 0, sizeof(CVE_OP_FILTER_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpFilter.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpFilter.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    if (pstFltCtrl->filter_mode == CVE_FILTER_CLARITY) {
        memcpy(&stOpFilter.stDstMem, pstDstMem, sizeof(CVE_DST_MEM_INFO_T));
    }
    memcpy(&stOpFilter.stFilterCtrl, pstFltCtrl, sizeof(CVE_FILTER_CTRL_T));
    stOpFilter.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_FILTER, &stOpFilter);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpFilter.cveHandle;

    return s32Ret;
}

int CVE_CSC(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
            CVE_CSC_CTRL_T *pstCscCtrl, bool bInstant)
{
    CVE_OP_CSC_T stOpCsc;
    int s32Ret = 0;

    s32Ret = cve_check_csc_param_user(pCveHandle, pstSrc, pstDst, pstCscCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check CSC parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpCsc, 0, sizeof(CVE_OP_CSC_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpCsc.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpCsc.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpCsc.stCscCtrl, pstCscCtrl, sizeof(CVE_CSC_CTRL_T));
    stOpCsc.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_CSC, &stOpCsc);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpCsc.cveHandle;

    return s32Ret;
}

int CVE_FilterAndCSC(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
                     CVE_FILTER_AND_CSC_CTRL_T *pstFltCscCtrl, bool bInstant)
{

    CVE_OP_FILTER_AND_CSC_T stOpFilterAndCsc;
    int s32Ret = 0;

    s32Ret = cve_check_filter_and_csc_param_user(pCveHandle, pstSrc, pstDst, pstFltCscCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check FilterAndCSC parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpFilterAndCsc, 0, sizeof(CVE_OP_FILTER_AND_CSC_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpFilterAndCsc.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpFilterAndCsc.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpFilterAndCsc.stFilterCscCtrl, pstFltCscCtrl, sizeof(CVE_FILTER_AND_CSC_CTRL_T));
    stOpFilterAndCsc.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_FILTER_AND_CSC, &stOpFilterAndCsc);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpFilterAndCsc.cveHandle;

    return s32Ret;
}

int CVE_Sobel(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDstH,
              CVE_DST_IMAGE_T *pstDstV, CVE_SOBEL_CTRL_T *pstSobelCtrl, bool bInstant)
{
    CVE_OP_SOBEL_T stOpSobel;
    int s32Ret = 0;

    s32Ret = cve_check_sobel_param_user(pCveHandle, pstSrc, pstDstH, pstDstV, pstSobelCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Sobel parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpSobel, 0, sizeof(CVE_OP_SOBEL_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpSobel.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    switch (pstSobelCtrl->enOutCtrl) {
    case CVE_SOBEL_OUT_CTRL_BOTH:
        memcpy(&stOpSobel.stDstH, pstDstH, sizeof(CVE_DST_IMAGE_T));
        memcpy(&stOpSobel.stDstV, pstDstV, sizeof(CVE_DST_IMAGE_T));
        break;
    case CVE_SOBEL_OUT_CTRL_HOR:
        memcpy(&stOpSobel.stDstH, pstDstH, sizeof(CVE_DST_IMAGE_T));
        break;
    case CVE_SOBEL_OUT_CTRL_VER:
        memcpy(&stOpSobel.stDstV, pstDstV, sizeof(CVE_DST_IMAGE_T));
        break;
    default:
        break;
    }

    memcpy(&stOpSobel.stSobelCtrl, pstSobelCtrl, sizeof(CVE_SOBEL_CTRL_T));
    stOpSobel.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_SOBEL, &stOpSobel);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpSobel.cveHandle;

    return s32Ret;
}

int CVE_MagAndAng(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDstMag,
                  CVE_DST_IMAGE_T *pstDstAng, CVE_MAG_AND_ANG_CTRL_T *pstMagAndAngCtrl,
                  bool bInstant)
{
    CVE_OP_MAG_AND_ANG_T stOpMagAndAng;
    int s32Ret = 0;

    s32Ret = cve_check_mag_and_ang_param_user(pCveHandle, pstSrc, pstDstMag, pstDstAng,
                                              pstMagAndAngCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check MagAndAng parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpMagAndAng, 0, sizeof(CVE_OP_MAG_AND_ANG_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpMagAndAng.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    if ((pstMagAndAngCtrl->enOutCtrl == CVE_MAG_AND_ANG_OUT_CTRL_MAG_AND_ANG) ||
        (pstMagAndAngCtrl->enOutCtrl == CVE_MAG_AND_ANG_OUT_CTRL_HOG)) {
        memcpy(&stOpMagAndAng.stDstMag, pstDstMag, sizeof(CVE_DST_IMAGE_T));
        memcpy(&stOpMagAndAng.stDstAng, pstDstAng, sizeof(CVE_DST_IMAGE_T));
    } else {
        memcpy(&stOpMagAndAng.stDstMag, pstDstMag, sizeof(CVE_DST_IMAGE_T));
    }
    memcpy(&stOpMagAndAng.stMagAndAngCtrl, pstMagAndAngCtrl, sizeof(CVE_MAG_AND_ANG_CTRL_T));
    stOpMagAndAng.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_MAG_AND_ANG, &stOpMagAndAng);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpMagAndAng.cveHandle;

    return s32Ret;
}

int CVE_MatchBgModel(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstCurImg, CVE_SRC_IMAGE_T *pstPreImg,
                     CVE_MEM_INFO_T *pstBgModel, CVE_DST_IMAGE_T *pstFg, CVE_DST_IMAGE_T *pstBg,
                     CVE_DST_IMAGE_T *pstCurDiffBg, CVE_DST_IMAGE_T *pstFrmDiff,
                     CVE_MATCH_BG_MODEL_CTRL_T *pstMatchBgModelCtrl, bool bInstant)
{
    CVE_OP_MATCH_BG_MODEL_T stOpMatchBgModel;
    int s32Ret = 0;

    s32Ret =
        cve_check_match_bg_model_param_user(pCveHandle, pstCurImg, pstPreImg, pstBgModel, pstFg,
                                            pstBg, pstCurDiffBg, pstFrmDiff, pstMatchBgModelCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check MatchBgModel parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpMatchBgModel, 0, sizeof(CVE_OP_MATCH_BG_MODEL_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpMatchBgModel.stCurImg, pstCurImg, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpMatchBgModel.stPreImg, pstPreImg, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpMatchBgModel.stBgModel, pstBgModel, sizeof(CVE_MEM_INFO_T));
    memcpy(&stOpMatchBgModel.stFg, pstFg, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpMatchBgModel.stBg, pstBg, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpMatchBgModel.stCurDiffBg, pstCurDiffBg, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpMatchBgModel.stFrmDiff, pstFrmDiff, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpMatchBgModel.stMatchBgModelCtrl, pstMatchBgModelCtrl,
           sizeof(CVE_MATCH_BG_MODEL_CTRL_T));
    stOpMatchBgModel.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_MATCH_BG_MODEL, &stOpMatchBgModel);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpMatchBgModel.cveHandle;

    return s32Ret;
}

int CVE_UpdateBgModel(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstCurImg,
                      CVE_MEM_INFO_T *pstBgModel1, CVE_MEM_INFO_T *pstBgModel2,
                      CVE_DST_MEM_INFO_T *pstStatData,
                      CVE_UPDATE_BG_MODEL_CTRL_T *pstUpdateBgModelCtrl, bool bInstant)
{
    CVE_OP_UPDATE_BG_MODEL_T stOpUpdateBgModel;
    int s32Ret = 0;

    s32Ret = cve_check_update_bg_model_param_user(pCveHandle, pstCurImg, pstBgModel1, pstBgModel2,
                                                  pstStatData, pstUpdateBgModelCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check UpdateBgModel parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpUpdateBgModel, 0, sizeof(CVE_OP_UPDATE_BG_MODEL_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }
    memcpy(&stOpUpdateBgModel.stCurImg, pstCurImg, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpUpdateBgModel.stBgModel1, pstBgModel1, sizeof(CVE_MEM_INFO_T));
    memcpy(&stOpUpdateBgModel.stBgModel2, pstBgModel2, sizeof(CVE_MEM_INFO_T));
    memcpy(&stOpUpdateBgModel.stStatData, pstStatData, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpUpdateBgModel.stUpdateBgModelCtrl, pstUpdateBgModelCtrl,
           sizeof(CVE_UPDATE_BG_MODEL_CTRL_T));
    stOpUpdateBgModel.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_UPDATE_BG_MODEL, &stOpUpdateBgModel);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpUpdateBgModel.cveHandle;

    return s32Ret;
}

int CVE_Dilate(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
               CVE_DILATE_CTRL_T *pstDilateCtrl, bool bInstant)
{
    CVE_OP_DILATE_T stOpDilate;
    int s32Ret = 0;

    s32Ret = cve_check_dilate_param_user(pCveHandle, pstSrc, pstDst, pstDilateCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Dilate parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpDilate, 0, sizeof(CVE_OP_DILATE_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpDilate.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpDilate.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpDilate.stDilateCtrl, pstDilateCtrl, sizeof(CVE_DILATE_CTRL_T));
    stOpDilate.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_DILATE, &stOpDilate);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpDilate.cveHandle;

    return s32Ret;
}

int CVE_Erode(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
              CVE_ERODE_CTRL_T *pstErodeCtrl, bool bInstant)
{

    CVE_OP_ERODE_T stOpErode;
    int s32Ret = 0;

    s32Ret = cve_check_erode_param_user(pCveHandle, pstSrc, pstDst, pstErodeCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Erode parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpErode, 0, sizeof(CVE_OP_ERODE_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpErode.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpErode.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpErode.stErodeCtrl, pstErodeCtrl, sizeof(CVE_ERODE_CTRL_T));
    stOpErode.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_ERODE, &stOpErode);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpErode.cveHandle;

    return s32Ret;
}

int CVE_Bernsen(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
                CVE_BERNSEN_CTRL_T *pstBernsenCtrl, bool bInstant)
{

    CVE_OP_BERNSEN_T stOpBernsen;
    int s32Ret = 0;

    s32Ret = cve_check_bernsen_param_user(pCveHandle, pstSrc, pstDst, pstBernsenCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Erode parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpBernsen, 0, sizeof(CVE_OP_BERNSEN_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpBernsen.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpBernsen.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpBernsen.stBernsenCtrl, pstBernsenCtrl, sizeof(CVE_BERNSEN_CTRL_T));
    stOpBernsen.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_BERNSEN, &stOpBernsen);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpBernsen.cveHandle;

    return s32Ret;
}

int CVE_Thresh(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
               CVE_THRESH_CTRL_T *pstThrCtrl, bool bInstant)
{
    CVE_OP_THRESH_T stOpThresh;
    int s32Ret = 0;

    s32Ret = cve_check_thresh_param_user(pCveHandle, pstSrc, pstDst, pstThrCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Thresh parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpThresh, 0, sizeof(CVE_OP_THRESH_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpThresh.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpThresh.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpThresh.stThreshCtrl, pstThrCtrl, sizeof(CVE_THRESH_CTRL_T));
    stOpThresh.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_THRESH, &stOpThresh);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpThresh.cveHandle;

    return s32Ret;
}

int CVE_Sub(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc0, CVE_SRC_IMAGE_T *pstSrc1,
            CVE_DST_IMAGE_T *pstDst, CVE_DST_MEM_INFO_T *pstDstMem, CVE_SUB_CTRL_T *pstSubCtrl,
            bool bInstant)
{
    CVE_OP_SUB_T stOpSub;
    int s32Ret = 0;

    s32Ret = cve_check_sub_param_user(pCveHandle, pstSrc0, pstSrc1, pstDst, pstDstMem, pstSubCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Sub parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpSub, 0, sizeof(CVE_OP_SUB_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpSub.stSrcImage0, pstSrc0, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpSub.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpSub.stDst, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpSub.stSubCtrl, pstSubCtrl, sizeof(CVE_SUB_CTRL_T));
    memcpy(&stOpSub.stDstMem, pstDstMem, sizeof(CVE_DST_MEM_INFO_T));
    stOpSub.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_SUB, &stOpSub);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpSub.cveHandle;

    return s32Ret;
}

int CVE_Or(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc0, CVE_SRC_IMAGE_T *pstSrc1,
           CVE_DST_IMAGE_T *pstDst, CVE_OR_CTRL_T *pstOrCtrl, bool bInstant)
{
    CVE_OP_OR_T stOpOr;
    int s32Ret = 0;

    s32Ret = cve_check_or_param_user(pCveHandle, pstSrc0, pstSrc1, pstDst);
    if (s32Ret) {
        CVE_ERR_LOG("check Or parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpOr, 0, sizeof(CVE_OP_OR_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpOr.stSrcImage0, pstSrc0, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpOr.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpOr.stDst, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpOr.stOrCtrl, pstOrCtrl, sizeof(CVE_OR_CTRL_T));
    stOpOr.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_OR, &stOpOr);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpOr.cveHandle;

    return s32Ret;
}

int CVE_And(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc0, CVE_SRC_IMAGE_T *pstSrc1,
            CVE_DST_IMAGE_T *pstDst, CVE_AND_CTRL_T *pstAndCtrl, bool bInstant)
{

    CVE_OP_AND_T stOpAnd;
    int s32Ret = 0;

    s32Ret = cve_check_and_param_user(pCveHandle, pstSrc0, pstSrc1, pstDst);
    if (s32Ret) {
        CVE_ERR_LOG("check And parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpAnd, 0, sizeof(CVE_OP_AND_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpAnd.stSrcImage0, pstSrc0, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpAnd.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpAnd.stDst, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpAnd.stAndCtrl, pstAndCtrl, sizeof(CVE_AND_CTRL_T));
    stOpAnd.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_AND, &stOpAnd);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpAnd.cveHandle;

    return s32Ret;
}

int CVE_Xor(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc0, CVE_SRC_IMAGE_T *pstSrc1,
            CVE_DST_IMAGE_T *pstDst, CVE_XOR_CTRL_T *pstXorCtrl, bool bInstant)
{
    CVE_OP_XOR_T stOpXor;
    int s32Ret = 0;

    s32Ret = cve_check_xor_param_user(pCveHandle, pstSrc0, pstSrc1, pstDst);
    if (s32Ret) {
        CVE_ERR_LOG("check Xor parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpXor, 0, sizeof(CVE_OP_XOR_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpXor.stSrcImage0, pstSrc0, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpXor.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpXor.stDst, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpXor.stXorCtrl, pstXorCtrl, sizeof(CVE_XOR_CTRL_T));
    stOpXor.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_XOR, &stOpXor);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpXor.cveHandle;

    return s32Ret;
}

int CVE_Add(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc0, CVE_SRC_IMAGE_T *pstSrc1,
            CVE_DST_IMAGE_T *pstDst, CVE_DST_MEM_INFO_T *pstDstMem, CVE_ADD_CTRL_T *pstAddCtrl,
            bool bInstant)
{
    CVE_OP_ADD_T stOpAdd;
    int s32Ret = 0;

    s32Ret = cve_check_add_param_user(pCveHandle, pstSrc0, pstSrc1, pstDst, pstDstMem, pstAddCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Add parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpAdd, 0, sizeof(CVE_OP_ADD_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpAdd.stSrcImage0, pstSrc0, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpAdd.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpAdd.stDst, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpAdd.stAddCtrl, pstAddCtrl, sizeof(CVE_ADD_CTRL_T));
    memcpy(&stOpAdd.stDstMem, pstDstMem, sizeof(CVE_DST_MEM_INFO_T));
    stOpAdd.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_ADD, &stOpAdd);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpAdd.cveHandle;

    return s32Ret;
}

int CVE_AddMap255To1(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc0, CVE_SRC_IMAGE_T *pstSrc1,
                     CVE_DST_IMAGE_T *pstDst, CVE_DST_MEM_INFO_T *pstDstMem,
                     CVE_ADD_MAP_255_TO_1_CTRL_T *pstAddMap255To1Ctrl, bool bInstant)

{
    CVE_OP_ADD_MAP255TO1_T stOpAddMap255To1;
    int s32Ret = 0;

    s32Ret = cve_check_add_map_255_to_1_param_user(pCveHandle, pstSrc0, pstSrc1, pstDst, pstDstMem,
                                                   pstAddMap255To1Ctrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Add parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpAddMap255To1, 0, sizeof(CVE_OP_ADD_MAP255TO1_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpAddMap255To1.stSrcImage0, pstSrc0, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpAddMap255To1.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpAddMap255To1.stDst, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpAddMap255To1.stAddMap255To1Ctrl, pstAddMap255To1Ctrl,
           sizeof(CVE_ADD_MAP_255_TO_1_CTRL_T));
    memcpy(&stOpAddMap255To1.stDstMem, pstDstMem, sizeof(CVE_DST_MEM_INFO_T));
    stOpAddMap255To1.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_ADD_MAP255TO1, &stOpAddMap255To1);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpAddMap255To1.cveHandle;

    return s32Ret;
}

int CVE_Dot(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc0, CVE_SRC_IMAGE_T *pstSrc1,
            CVE_DST_IMAGE_T *pstDst, CVE_DOT_CTRL_T *pstDotCtrl, bool bInstant)
{

    CVE_OP_XOR_T stOpDot;
    int s32Ret = 0;

    s32Ret = cve_check_dot_param_user(pCveHandle, pstSrc0, pstSrc1, pstDst);
    if (s32Ret) {
        CVE_ERR_LOG("check And parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpDot, 0, sizeof(CVE_OP_AND_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpDot.stSrcImage0, pstSrc0, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpDot.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpDot.stDst, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpDot.stDotCtrl, pstDotCtrl, sizeof(CVE_AND_CTRL_T));
    stOpDot.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_DOT, &stOpDot);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpDot.cveHandle;

    return s32Ret;
}

int CVE_Integ(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
              CVE_INTEG_CTRL_T *pstIntegCtrl, bool bInstant)
{
    CVE_OP_INTEG_T stOpInteg;
    int s32Ret = 0;

    s32Ret = cve_check_integ_param_user(pCveHandle, pstSrc, pstDst, pstIntegCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Integ parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpInteg, 0, sizeof(CVE_OP_INTEG_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpInteg.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpInteg.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpInteg.stIntegCtrl, pstIntegCtrl, sizeof(CVE_INTEG_CTRL_T));
    stOpInteg.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_INTEG, &stOpInteg);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpInteg.cveHandle;

    return s32Ret;
}

int CVE_Hist(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_MEM_INFO_T *pstDst,
             CVE_HIST_CTRL_T *pstHistCtrl, bool bInstant)
{
    CVE_OP_HIST_T stOpHist;
    int s32Ret = 0;

    s32Ret = cve_check_hist_param_user(pCveHandle, pstSrc, pstDst);
    if (s32Ret) {
        CVE_ERR_LOG("check Hist parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpHist, 0, sizeof(CVE_OP_HIST_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpHist.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpHist.stDstMem, pstDst, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpHist.stHistCtrl, pstHistCtrl, sizeof(CVE_HIST_CTRL_T));
    stOpHist.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_HIST, &stOpHist);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpHist.cveHandle;

    return s32Ret;
}

int CVE_Thresh_S16(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
                   CVE_THRESH_S16_CTRL_T *pstThrS16Ctrl, bool bInstant)
{
    CVE_OP_THRESH_S16_T stOpThreshS16;
    int s32Ret = 0;

    s32Ret = cve_check_thresh_s16_param_user(pCveHandle, pstSrc, pstDst, pstThrS16Ctrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Thresh_S16 parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpThreshS16, 0, sizeof(CVE_OP_THRESH_S16_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpThreshS16.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpThreshS16.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpThreshS16.stThreshS16Ctrl, pstThrS16Ctrl, sizeof(CVE_THRESH_S16_CTRL_T));
    stOpThreshS16.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_THRESH_S16, &stOpThreshS16);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpThreshS16.cveHandle;

    return s32Ret;
}

int CVE_Thresh_U16(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
                   CVE_THRESH_U16_CTRL_T *pstThrU16Ctrl, bool bInstant)
{
    CVE_OP_THRESH_U16_T stOpThreshU16;
    int s32Ret = 0;

    s32Ret = cve_check_thresh_u16_param_user(pCveHandle, pstSrc, pstDst, pstThrU16Ctrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Thresh_U16 parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpThreshU16, 0, sizeof(CVE_OP_THRESH_U16_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpThreshU16.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpThreshU16.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpThreshU16.stThreshU16Ctrl, pstThrU16Ctrl, sizeof(CVE_THRESH_U16_CTRL_T));
    stOpThreshU16.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_THRESH_U16, &stOpThreshU16);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpThreshU16.cveHandle;

    return s32Ret;
}

int CVE_16BitTo8Bit(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
                    CVE_16BIT_TO_8BIT_CTRL_T *pst16BitTo8BitCtrl, bool bInstant)
{
    CVE_OP_16BIT_TO_8BIT_T stOp16bitTo8bit;
    int s32Ret = 0;

    s32Ret = cve_check_16bit_to_8bit_param_user(pCveHandle, pstSrc, pstDst, pst16BitTo8BitCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check 16BitTo8Bit parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOp16bitTo8bit, 0, sizeof(CVE_OP_16BIT_TO_8BIT_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOp16bitTo8bit.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOp16bitTo8bit.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOp16bitTo8bit.st16BitTo8BitCtrl, pst16BitTo8BitCtrl,
           sizeof(CVE_16BIT_TO_8BIT_CTRL_T));
    stOp16bitTo8bit.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_16BIT_TO_8BIT, &stOp16bitTo8bit);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOp16bitTo8bit.cveHandle;

    return s32Ret;
}

int CVE_OrdStatFilter(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
                      CVE_ORD_STAT_FILTER_CTRL_T *pstOrdStatFltCtrl, bool bInstant)
{

    CVE_OP_ORD_STAT_FILTER_T stOpOrdStatFilter;
    int s32Ret = 0;

    s32Ret = cve_check_ord_stat_filter_param_user(pCveHandle, pstSrc, pstDst, pstOrdStatFltCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check OrdStatFilter parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpOrdStatFilter, 0, sizeof(CVE_OP_ORD_STAT_FILTER_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpOrdStatFilter.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpOrdStatFilter.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpOrdStatFilter.stOrdStatFltCtrl, pstOrdStatFltCtrl,
           sizeof(CVE_ORD_STAT_FILTER_CTRL_T));
    stOpOrdStatFilter.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_ORD_STAT_FILTER, &stOpOrdStatFilter);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpOrdStatFilter.cveHandle;

    return s32Ret;
}

int CVE_Map(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_SRC_MEM_INFO_T *pstMap,
            CVE_DST_IMAGE_T *pstDst, CVE_MAP_CTRL_T *pstMapCtrl, bool bInstant)
{

    CVE_OP_MAP_T stOpMap;
    int s32Ret = 0;

    s32Ret = cve_check_map_param_user(pCveHandle, pstSrc, pstMap, pstDst, pstMapCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check Map parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpMap, 0, sizeof(CVE_OP_MAP_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpMap.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpMap.stMap, pstMap, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpMap.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpMap.stMapCtrl, pstMapCtrl, sizeof(CVE_MAP_CTRL_T));
    stOpMap.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_MAP, &stOpMap);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpMap.cveHandle;

    return s32Ret;
}

int CVE_EqualizeHist(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
                     CVE_EQUALIZE_HIST_CTRL_T *pstEqualizeHistCtrl, bool bInstant)
{
    CVE_OP_EQUALIZE_HIST_T stOpEqualizeHist;
    int s32Ret = 0;

    s32Ret = cve_check_equalize_hist_param_user(pCveHandle, pstSrc, pstDst, pstEqualizeHistCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check EqulizeHist parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpEqualizeHist, 0, sizeof(CVE_OP_EQUALIZE_HIST_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpEqualizeHist.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpEqualizeHist.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpEqualizeHist.stEqualizeHistCtrl, pstEqualizeHistCtrl,
           sizeof(CVE_EQUALIZE_HIST_CTRL_T));
    stOpEqualizeHist.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_EQUALIZE_HIST, &stOpEqualizeHist);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpEqualizeHist.cveHandle;

    return s32Ret;
}

int CVE_NCC(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc1, CVE_SRC_IMAGE_T *pstSrc2,
            CVE_DST_MEM_INFO_T *pstDst, CVE_NCC_CTRL_T *pstNccCtrl, bool bInstant)
{
    CVE_OP_NCC_T stOpNcc;
    int s32Ret = 0;

    s32Ret = cve_check_ncc_param_user(pCveHandle, pstSrc1, pstSrc2, pstDst, pstNccCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check NCC parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpNcc, 0, sizeof(CVE_OP_NCC_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpNcc.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpNcc.stSrcImage2, pstSrc2, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpNcc.stDstmem, pstDst, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpNcc.stNccCtrl, pstNccCtrl, sizeof(CVE_NCC_CTRL_T));
    stOpNcc.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_NCC, &stOpNcc);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpNcc.cveHandle;

    return s32Ret;
}

int CVE_CCL(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
            CVE_DST_MEM_INFO_T *pstBlob, CVE_CCL_CTRL_T *pstCclCtrl, bool bInstant)
{
    CVE_OP_CCL_T stOpCcl;
    int s32Ret = 0;

    s32Ret = cve_check_ccl_param_user(pCveHandle, pstSrc, pstDst, pstBlob, pstCclCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check CCL parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpCcl, 0, sizeof(CVE_OP_CCL_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpCcl.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpCcl.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpCcl.stBlob, pstBlob, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpCcl.stCclCtrl, pstCclCtrl, sizeof(CVE_CCL_CTRL_T));
    stOpCcl.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_CCL, &stOpCcl);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpCcl.cveHandle;

    return s32Ret;
}

int CVE_GMM(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_SRC_IMAGE_T *pstFactor,
            CVE_DST_IMAGE_T *pstFg, CVE_DST_IMAGE_T *pstBg, CVE_MEM_INFO_T *pstModel,
            CVE_GMM_CTRL_T *pstGmmCtrl, bool bInstant)
{
    CVE_OP_GMM_T stOpGmm;
    int s32Ret = 0;

    s32Ret =
        cve_check_gmm_param_user(pCveHandle, pstSrc, pstFactor, pstFg, pstBg, pstModel, pstGmmCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check GMM parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpGmm, 0, sizeof(CVE_OP_GMM_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpGmm.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpGmm.stFactor, pstFactor, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpGmm.stFg, pstFg, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpGmm.stBg, pstBg, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpGmm.stModel, pstModel, sizeof(CVE_MEM_INFO_T));
    memcpy(&stOpGmm.stGmmCtrl, pstGmmCtrl, sizeof(CVE_GMM_CTRL_T));
    stOpGmm.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_GMM, &stOpGmm);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpGmm.cveHandle;

    return s32Ret;
}

int CVE_CannyHysEdge(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstEdge,
                     CVE_DST_MEM_INFO_T *pstStack, CVE_CANNY_HYS_EDGE_CTRL_T *pstCannyHysEdgeCtrl,
                     bool bInstant)
{
    CVE_OP_CANNY_HYS_EDGE_T stOpCannyHysEdge;
    int s32Ret = 0;

    s32Ret = cve_check_canny_hys_edge_param_user(pCveHandle, pstSrc, pstEdge, pstStack,
                                                 pstCannyHysEdgeCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check CCL parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpCannyHysEdge, 0, sizeof(CVE_OP_CANNY_HYS_EDGE_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }
    memcpy(&stOpCannyHysEdge.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpCannyHysEdge.stEdge, pstEdge, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpCannyHysEdge.stStack, pstStack, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpCannyHysEdge.stCannyHysEdgeCtrl, pstCannyHysEdgeCtrl,
           sizeof(CVE_CANNY_HYS_EDGE_CTRL_T));
    stOpCannyHysEdge.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_CANNY_HYS_EDGE, &stOpCannyHysEdge);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpCannyHysEdge.cveHandle;

    return s32Ret;
}

int CVE_CannyEdge(CVE_IMAGE_T *pstEdge, CVE_MEM_INFO_T *pstStack,
                  CVE_CANNY_EDGE_CTRL_T *pstCannyEdgeCtrl)
{
    CVE_POINT_U16_T *pstStackPoints;
    U16 au16Xi[3];
    U16 au16Yi[3];
    U8 *ps32Edge;
    int i, j, m, n, num;
    U16 s32Row;
    U16 s32Col;
    int s32Ret = 0;

    s32Ret = cve_check_canny_edge_param_user(pstEdge, pstStack, pstCannyEdgeCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check cannyEdge parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    ps32Edge = (U8 *)(uintptr_t)pstEdge->au64VirAddr[0];
    pstStackPoints = (CVE_POINT_U16_T *)(uintptr_t)pstStack->u64VirAddr;
    num = pstCannyEdgeCtrl->u32CannyCount;

    for (i = 0; i < num; i++) {
        s32Row = pstStackPoints[i].u16X;
        s32Col = pstStackPoints[i].u16Y;

        for (j = -1; j <= 1; ++j) {
            au16Yi[j + 1] = CVE_CLIP3(0, pstEdge->u32Height - 1, j + s32Row);
        }

        for (j = -1; j <= 1; ++j) {
            au16Xi[j + 1] = CVE_CLIP3(0, pstEdge->u32Width - 1, j + s32Col);
        }

        for (m = 0; m < 3; m++) {
            for (n = 0; n < 3; n++) {
                if ((m == 1) && (n == 1))
                    continue;
                if (ps32Edge[au16Yi[m] * pstEdge->au32Stride[0] + au16Xi[n]] == 0) {
                    ps32Edge[au16Yi[m] * pstEdge->au32Stride[0] + au16Xi[n]] = 2;
                    pstStackPoints[num].u16X = au16Yi[m];
                    pstStackPoints[num].u16Y = au16Xi[n];
                    num++;
                }
            }
        }
    }

    for (i = 0; i < pstEdge->u32Height * pstEdge->au32Stride[0]; i++) {
        if (ps32Edge[i] == 2)
            ps32Edge[i] = (pstCannyEdgeCtrl->enOutputDataMode == CVE_CANNY_EDGE_OUTPUT_DATA_MODE_U1)
                              ? 1
                              : 255;
        else
            ps32Edge[i] = 0;
    }

    return s32Ret;
}

int CVE_LBP(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
            CVE_LBP_CTRL_T *pstLbpCtrl, bool bInstant)
{
    CVE_OP_LBP_T stOpLbp;
    int s32Ret = 0;

    s32Ret = cve_check_lbp_param_user(pCveHandle, pstSrc, pstDst, pstLbpCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check LBP parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpLbp, 0, sizeof(CVE_OP_LBP_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpLbp.stSrcImage, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpLbp.stDstImage, pstDst, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpLbp.stLbpCtrl, pstLbpCtrl, sizeof(CVE_LBP_CTRL_T));
    stOpLbp.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_LBP, &stOpLbp);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpLbp.cveHandle;

    return s32Ret;
}

int CVE_NormGrad(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDstH,
                 CVE_DST_IMAGE_T *pstDstV, CVE_DST_IMAGE_T *pstDstHV,
                 CVE_NORM_GRAD_CTRL_T *pstNormGradCtrl, bool bInstant)
{
    return cve_norm_grad(pCveHandle, pstSrc, pstDstH, pstDstV, pstDstHV, pstNormGradCtrl, bInstant);
}

int CVE_BuildLKOpticalFlowPyr(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcPrevPyr,
                              CVE_DST_IMAGE_T astDstPyr[],
                              CVE_BUILD_LK_OPTICAL_FLOW_PYR_CTRL_T *pstBuildLkOptiFlowPyrCtrl,
                              bool bInstant)
{
    CVE_OP_BUILD_LK_OPTICAL_FLOW_PYR_T stOpBuildLkOpticalFlowPyr;
    int s32Ret = 0;

    s32Ret = cve_check_buildlkoptionalflowpyr_param_user(pCveHandle, pstSrcPrevPyr,
                                                         pstBuildLkOptiFlowPyrCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check LKOpticalFlowPyr parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpBuildLkOpticalFlowPyr, 0, sizeof(CVE_OP_BUILD_LK_OPTICAL_FLOW_PYR_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpBuildLkOpticalFlowPyr.stSrcPyr, pstSrcPrevPyr, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpBuildLkOpticalFlowPyr.astDstPyr, astDstPyr,
           (pstBuildLkOptiFlowPyrCtrl->u8MaxLevel + 1) * sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpBuildLkOpticalFlowPyr.stLkBuildOptiFlowPyrCtrl, pstBuildLkOptiFlowPyrCtrl,
           sizeof(CVE_BUILD_LK_OPTICAL_FLOW_PYR_CTRL_T));

    stOpBuildLkOpticalFlowPyr.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_BUILD_LK_OPTICAL_FLOW_PYR, &stOpBuildLkOpticalFlowPyr);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpBuildLkOpticalFlowPyr.cveHandle;

    return s32Ret;
}

int CVE_LKOpticalFlowPyr(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T astSrcPrevPyr[],
                         CVE_SRC_IMAGE_T astSrcNextPyr[], CVE_SRC_MEM_INFO_T *pstPrevPts,
                         CVE_MEM_INFO_T *pstNextPts, CVE_DST_MEM_INFO_T *pstStatus,
                         CVE_LK_OPTICAL_FLOW_PYR_CTRL_T *pstLkOptiFlowPyrCtrl, bool bInstant)
{
    CVE_OP_LK_OPTICAL_FLOW_PYR_T stOpLkOpticalFlowPyr;
    int s32Ret = 0;

    s32Ret = cve_check_lk_optical_flow_pyr_param_user(pCveHandle, pstPrevPts, pstNextPts, pstStatus,
                                                      pstLkOptiFlowPyrCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check LKOpticalFlowPyr parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpLkOpticalFlowPyr, 0, sizeof(CVE_OP_LK_OPTICAL_FLOW_PYR_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpLkOpticalFlowPyr.astSrcPrevPyr, astSrcPrevPyr,
           (pstLkOptiFlowPyrCtrl->u8MaxLevel + 1) * sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpLkOpticalFlowPyr.astSrcNextPyr, astSrcNextPyr,
           (pstLkOptiFlowPyrCtrl->u8MaxLevel + 1) * sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpLkOpticalFlowPyr.stPrevPts, pstPrevPts, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpLkOpticalFlowPyr.stNextPts, pstNextPts, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpLkOpticalFlowPyr.stStatus, pstStatus, sizeof(CVE_DST_MEM_INFO_T));
    /*if ((pstLkOptiFlowPyrCtrl->enOutMode == CVE_LK_OPTICAL_FLOW_PYR_OUT_MODE_ERR) ||
        (pstLkOptiFlowPyrCtrl->enOutMode == CVE_LK_OPTICAL_FLOW_PYR_OUT_MODE_BOTH)) {
        memcpy(&stOpLkOpticalFlowPyr.stErr, pstErr, sizeof(CVE_DST_MEM_INFO_T));
    }*/
    memcpy(&stOpLkOpticalFlowPyr.stLkOptiFlowPyrCtrl, pstLkOptiFlowPyrCtrl,
           sizeof(CVE_LK_OPTICAL_FLOW_PYR_CTRL_T));

    stOpLkOpticalFlowPyr.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_LK_OPTICAL_FLOW_PYR, &stOpLkOpticalFlowPyr);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpLkOpticalFlowPyr.cveHandle;

    return s32Ret;
}

int CVE_STCandiCorner(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstLabel,
                      CVE_DST_IMAGE_T *pstCandiCorner, CVE_DST_MEM_INFO_T *pstCandiCornerPoint,
                      CVE_ST_CANDI_CORNER_CTRL_T *pstStCandiCornerCtrl, bool bInstant)
{
    CVE_OP_ST_CANDI_CORNER_T stOpSTCandiCorner;
    int s32Ret = 0;

    s32Ret = cve_check_st_candi_corner_param_user(pCveHandle, pstSrc, pstLabel, pstCandiCorner,
                                                  pstCandiCornerPoint, pstStCandiCornerCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check STCandiCorner parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpSTCandiCorner, 0, sizeof(CVE_OP_ST_CANDI_CORNER_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpSTCandiCorner.stSrc, pstSrc, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpSTCandiCorner.stLabel, pstLabel, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpSTCandiCorner.stCandiCorner, pstCandiCorner, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpSTCandiCorner.stCandiCornerPoint, pstCandiCornerPoint, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpSTCandiCorner.stStCandiCornerCtrl, pstStCandiCornerCtrl,
           sizeof(CVE_ST_CANDI_CORNER_CTRL_T));
    stOpSTCandiCorner.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_ST_CANDI_CORNER, &stOpSTCandiCorner);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpSTCandiCorner.cveHandle;

    return s32Ret;
}

int CVE_STCorner(CVE_SRC_MEM_INFO_T *pstCandiCornerPoint, CVE_DST_MEM_INFO_T *pstCornerPoint,
                 CVE_ST_CORNER_CTRL_T *pstStCornerCtrl)
{
    CVE_POINT_U16_T *pstCorner = (CVE_POINT_U16_T *)(uintptr_t)pstCornerPoint->u64VirAddr;
    CVE_POINT_U16_T *ptrCandiCorner = (CVE_POINT_U16_T *)(uintptr_t)pstCandiCornerPoint->u64VirAddr;
    int i, dist, cnt = 0, point = 0;
    int s32Ret = 0;

    s32Ret = cve_check_st_corner_param_user(pstCandiCornerPoint, pstCornerPoint, pstStCornerCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check STCorner parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    while ((cnt < pstStCornerCtrl->u32MaxCornerNum) && (point < pstStCornerCtrl->u32CornerNum)) {
        for (i = 0; i < cnt; i++) {
            dist = (pstCorner[i].u16X - ptrCandiCorner[point].u16X) *
                       (pstCorner[i].u16X - ptrCandiCorner[point].u16X) +
                   (pstCorner[i].u16Y - ptrCandiCorner[point].u16Y) *
                       (pstCorner[i].u16Y - ptrCandiCorner[point].u16Y);
            if (dist < pstStCornerCtrl->u32MinDist)
                break;
        }

        if (i == cnt) {
            pstCorner[cnt].u16X = ptrCandiCorner[point].u16X;
            pstCorner[cnt].u16Y = ptrCandiCorner[point].u16Y;
            cnt++;
        }
        point++;
    }

    return s32Ret;
}

int CVE_SAD(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc1, CVE_SRC_IMAGE_T *pstSrc2,
            CVE_DST_IMAGE_T *pstSad, CVE_DST_IMAGE_T *pstThr, CVE_SAD_CTRL_T *pstSadCtrl,
            bool bInstant)
{
    CVE_OP_SAD_T stOpSad;
    int s32Ret = 0;

    s32Ret = cve_check_sad_param_user(pCveHandle, pstSrc1, pstSrc2, pstSad, pstThr, pstSadCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check SAD parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpSad, 0, sizeof(CVE_OP_SAD_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpSad.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpSad.stSrcImage2, pstSrc2, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpSad.stSad, pstSad, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpSad.stThr, pstThr, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpSad.stSadCtrl, pstSadCtrl, sizeof(CVE_SAD_CTRL_T));

    stOpSad.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_SAD, &stOpSad);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpSad.cveHandle;

    return s32Ret;
}

int CVE_GradFg(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstFg, CVE_SRC_IMAGE_T *pstCurGrad,
               CVE_SRC_IMAGE_T *pstBgGrad, CVE_DST_IMAGE_T *pstGradFg,
               CVE_GRAD_FG_CTRL_T *pstGradFgCtrl, bool bInstant)
{
    CVE_OP_GRAD_FG_T stOpGradFg;
    int s32Ret = 0;

    s32Ret = cve_check_grad_fg_param_user(pCveHandle, pstFg, pstCurGrad, pstBgGrad, pstGradFg,
                                          pstGradFgCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check GradFg parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpGradFg, 0, sizeof(CVE_OP_GRAD_FG_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpGradFg.stFg, pstFg, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpGradFg.stCurGrad, pstCurGrad, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpGradFg.stBgGrad, pstBgGrad, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpGradFg.stGradFg, pstGradFg, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpGradFg.stGradFgCtrl, pstGradFgCtrl, sizeof(CVE_GRAD_FG_CTRL_T));
    stOpGradFg.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_GRAD_FG, &stOpGradFg);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpGradFg.cveHandle;

    return s32Ret;
}

int CVE_KCF_GET_YF(CVE_HANDLE *pCveHandle, CVE_SRC_MEM_INFO_T *pstSrcMem,
                   CVE_DST_MEM_INFO_T *pstDstMem, CVE_KCF_GET_YF_CTRL_T *pstKcfGetYfCtrl,
                   bool bInstant)
{
    CVE_OP_KCF_GET_YF_T stOpKCFGETYF;
    int s32Ret = 0;

    s32Ret = cve_check_kcf_get_yf_user(pCveHandle, pstSrcMem, pstDstMem, pstKcfGetYfCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check KCF GET YF parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpKCFGETYF, 0, sizeof(CVE_OP_KCF_GET_YF_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpKCFGETYF.stSrcMem, pstSrcMem, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpKCFGETYF.stDstMem, pstDstMem, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpKCFGETYF.stKcfGetYfCtrl, pstKcfGetYfCtrl, sizeof(CVE_KCF_GET_YF_CTRL_T));
    stOpKCFGETYF.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_KCF_GET_YF, &stOpKCFGETYF);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpKCFGETYF.cveHandle;

    return s32Ret;
}

int CVE_KCF_GET_FEATURE(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage,
                        CVE_DST_MEM_INFO_T *pstDstMem0, CVE_DST_MEM_INFO_T *pstDstMem1,
                        CVE_KCF_GET_FEATURE_CTRL_T *pstKcfGetFeatureCtrl, bool bInstant)
{
    CVE_OP_KCF_GET_FEATURE_T stOpKcfGetFeature;
    int s32Ret = 0;

    s32Ret = cve_check_kcf_get_feature_user(pCveHandle, pstSrcImage, pstDstMem0, pstDstMem1,
                                            pstKcfGetFeatureCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check KCF GET FEATURE parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpKcfGetFeature, 0, sizeof(CVE_OP_KCF_GET_FEATURE_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpKcfGetFeature.stSrcImage, pstSrcImage, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpKcfGetFeature.stDstMem0, pstDstMem0, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpKcfGetFeature.stDstMem1, pstDstMem1, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpKcfGetFeature.stKcfGetFeatureCtrl, pstKcfGetFeatureCtrl,
           sizeof(CVE_KCF_GET_FEATURE_CTRL_T));
    stOpKcfGetFeature.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_KCF_GET_FEATURE, &stOpKcfGetFeature);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpKcfGetFeature.cveHandle;

    return s32Ret;
}

int CVE_KCF_GET_TRAIN_AND_TRACK(CVE_HANDLE *pCveHandle, CVE_SRC_MEM_INFO_T *pstSrcMem1,
                                CVE_SRC_MEM_INFO_T *pstSrcMem2, CVE_SRC_MEM_INFO_T *pstSrcMem3,
                                CVE_DST_MEM_INFO_T *pstDstMem0, CVE_DST_MEM_INFO_T *pstDstMem1,
                                CVE_DST_MEM_INFO_T *pstDstMem2,
                                CVE_KCF_TRAIN_AND_TRACK_CTRL_T *pstKcfTrainAndTrackCtrl,
                                bool bInstant)
{
    CVE_OP_KCF_TRAIN_AND_TRACK_T stOpKcfTrainAndTrack;
    int s32Ret = 0;

    s32Ret = cve_check_kcf_get_train_and_track_user(pCveHandle, pstSrcMem1, pstSrcMem2, pstSrcMem3,
                                                    pstDstMem0, pstDstMem1, pstDstMem2,
                                                    pstKcfTrainAndTrackCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check KCF GET TRAIN AND TRACK parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpKcfTrainAndTrack, 0, sizeof(CVE_OP_KCF_TRAIN_AND_TRACK_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpKcfTrainAndTrack.stSrcMem1, pstSrcMem1, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpKcfTrainAndTrack.stSrcMem2, pstSrcMem2, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpKcfTrainAndTrack.stSrcMem3, pstSrcMem3, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpKcfTrainAndTrack.stDstMem0, pstDstMem0, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpKcfTrainAndTrack.stDstMem1, pstDstMem1, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpKcfTrainAndTrack.stDstMem2, pstDstMem2, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpKcfTrainAndTrack.stKcfTrainAndTrackCtrl, pstKcfTrainAndTrackCtrl,
           sizeof(CVE_KCF_TRAIN_AND_TRACK_CTRL_T));
    stOpKcfTrainAndTrack.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_KCF_TRAIN_AND_TRACK, &stOpKcfTrainAndTrack);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpKcfTrainAndTrack.cveHandle;

    return s32Ret;
}

int CVE_LINE_FILTER(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage,
                    CVE_DST_IMAGE_T *pstDstImage, CVE_LINE_FILTER_CTRL_T *pstLineFilterCtrl,
                    bool bInstant)
{
    CVE_OP_LINE_FILTER_T stOpLineFilter;
    int s32Ret = 0;

    s32Ret = cve_check_line_filter_user(pCveHandle, pstSrcImage, pstDstImage, pstLineFilterCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check LINE FILTER parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpLineFilter, 0, sizeof(CVE_OP_LINE_FILTER_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpLineFilter.stSrcImage, pstSrcImage, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpLineFilter.stDstImage, pstDstImage, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpLineFilter.stLineFilterCtrl, pstLineFilterCtrl, sizeof(CVE_LINE_FILTER_CTRL_T));
    stOpLineFilter.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_LINE_FILTER, &stOpLineFilter);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpLineFilter.cveHandle;

    return s32Ret;
}

int CVE_NOISE_REMOVE(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage,
                     CVE_DST_IMAGE_T *pstDstImage, CVE_NOISE_REMOVE_CTRL_T *pstNoiseRemoveCtrl,
                     bool bInstant)
{
    CVE_OP_NOISE_REMOVE_T stOpNoiseRemove;
    int s32Ret = 0;

    s32Ret = cve_check_noise_remove_user(pCveHandle, pstSrcImage, pstDstImage, pstNoiseRemoveCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check NOISE REMOVE parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpNoiseRemove, 0, sizeof(CVE_OP_NOISE_REMOVE_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpNoiseRemove.stSrcImage, pstSrcImage, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpNoiseRemove.stDstImage, pstDstImage, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpNoiseRemove.stNoiseRemoveCtrl, pstNoiseRemoveCtrl, sizeof(CVE_NOISE_REMOVE_CTRL_T));
    stOpNoiseRemove.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_NOISE_REMOVE, &stOpNoiseRemove);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpNoiseRemove.cveHandle;

    return s32Ret;
}

int CVE_ADP_THRESH(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage0,
                   CVE_SRC_IMAGE_T *pstSrcImage1, CVE_DST_IMAGE_T *pstDstImage,
                   CVE_ADP_THRESH_CTRL_T *pstAdpThreshCtrl, bool bInstant)
{
    CVE_OP_ADP_THRESH_T stOpAdpThresh;
    int s32Ret = 0;

    s32Ret = cve_check_adp_thresh_user(pCveHandle, pstSrcImage0, pstSrcImage1, pstDstImage,
                                       pstAdpThreshCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check ADP THRESH parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpAdpThresh, 0, sizeof(CVE_OP_ADP_THRESH_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpAdpThresh.stSrcImage0, pstSrcImage0, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpAdpThresh.stSrcImage1, pstSrcImage1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpAdpThresh.stDstImage, pstDstImage, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpAdpThresh.stAdpThreshCtrl, pstAdpThreshCtrl, sizeof(CVE_ADP_THRESH_CTRL_T));
    stOpAdpThresh.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_ADP_THRESH, &stOpAdpThresh);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpAdpThresh.cveHandle;

    return s32Ret;
}

int CVE_REDUCE(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage, CVE_DST_MEM_INFO_T *pstDstMem0,
               CVE_DST_MEM_INFO_T *pstDstMem1, CVE_DST_MEM_INFO_T *pstDstMem2,
               CVE_REDUCE_CTRL_T *pstReduceCtrl, bool bInstant)
{
    CVE_OP_REDUCE_T stOpReduce;
    int s32Ret = 0;

    s32Ret = cve_check_reduce_user(pCveHandle, pstSrcImage, pstDstMem0, pstDstMem1, pstDstMem2,
                                   pstReduceCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check REDUCE parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpReduce, 0, sizeof(CVE_OP_REDUCE_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpReduce.stSrcImage, pstSrcImage, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpReduce.stDstMem0, pstDstMem0, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpReduce.stDstMem1, pstDstMem1, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpReduce.stDstMem2, pstDstMem2, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpReduce.stReduceCtrl, pstReduceCtrl, sizeof(CVE_REDUCE_CTRL_T));
    stOpReduce.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_REDUCE, &stOpReduce);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpReduce.cveHandle;

    return s32Ret;
}

int CVE_PERSP_TRANS(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage,
                    CVE_DST_IMAGE_T *pstDstImage, CVE_PERSP_TRANS_CTRL_T *pstPerspTransCtrl,
                    bool bInstant)
{
    CVE_OP_PERSP_TRANS_T stOpPerspTrans;
    int s32Ret = 0;

    s32Ret = cve_check_persp_trans_user(pCveHandle, pstSrcImage, pstDstImage, pstPerspTransCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check PERSP TRANS parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpPerspTrans, 0, sizeof(CVE_OP_PERSP_TRANS_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpPerspTrans.stSrcImage, pstSrcImage, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpPerspTrans.stDstImage, pstDstImage, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpPerspTrans.stPerspTransCtrl, pstPerspTransCtrl, sizeof(CVE_PERSP_TRANS_CTRL_T));
    stOpPerspTrans.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_PERSP_TRANS, &stOpPerspTrans);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpPerspTrans.cveHandle;

    return s32Ret;
}

int CVE_FAST_GUIDE_FILTER(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage0,
                          CVE_SRC_IMAGE_T *pstSrcImage1, CVE_DST_IMAGE_T *pstDstImage0,
                          CVE_DST_IMAGE_T *pstDstImage1, CVE_DST_IMAGE_T *pstDstImage2,
                          CVE_FAST_GUIDE_FILTER_CTRL_T *pstFastGuideFilterCtrl, bool bInstant)
{
    CVE_OP_FAST_GUIDE_FILTER_T stOpFastGuideFilter;
    int s32Ret = 0;

    s32Ret = cve_check_fast_guide_filter_user(pCveHandle, pstSrcImage0, pstSrcImage1, pstDstImage0,
                                              pstDstImage1, pstDstImage2, pstFastGuideFilterCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check FAST GUIDE FILTER parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpFastGuideFilter, 0, sizeof(CVE_OP_FAST_GUIDE_FILTER_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpFastGuideFilter.stSrcImage0, pstSrcImage0, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpFastGuideFilter.stSrcImage1, pstSrcImage1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpFastGuideFilter.stDstImage0, pstDstImage0, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpFastGuideFilter.stDstImage1, pstDstImage1, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpFastGuideFilter.stDstImage2, pstDstImage2, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpFastGuideFilter.stFastGuideFilterCtrl, pstFastGuideFilterCtrl,
           sizeof(CVE_FAST_GUIDE_FILTER_CTRL_T));
    stOpFastGuideFilter.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_FAST_GUIDED_FILTER, &stOpFastGuideFilter);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpFastGuideFilter.cveHandle;

    return s32Ret;
}

int CVE_HOG(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage, CVE_SRC_MEM_INFO_T *pstSrcMem,
            CVE_DST_IMAGE_T *pstDstImage, CVE_HOG_CTRL_T *pstHogCtrl, bool bInstant)
{
    CVE_OP_HOG_T stOpHog;
    int s32Ret = 0;

    s32Ret = cve_check_hog_user(pCveHandle, pstSrcImage, pstSrcMem, pstDstImage, pstHogCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check HOG parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpHog, 0, sizeof(CVE_OP_HOG_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpHog.stSrcImage, pstSrcImage, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpHog.stSrcMem, pstSrcMem, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpHog.stDstImage, pstDstImage, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpHog.stHogCtrl, pstHogCtrl, sizeof(CVE_HOG_CTRL_T));
    stOpHog.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_HOG, &stOpHog);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpHog.cveHandle;

    return s32Ret;
}

int CVE_RESIZE(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage, CVE_SRC_IMAGE_T *pstSrcImage1,
               CVE_DST_IMAGE_T *pstDstImage, CVE_DST_IMAGE_T *pstDstImage1,
               CVE_RESIZE_CTRL_T *pstResizeCtrl, bool bInstant)
{
    CVE_OP_RESIZE_T stOpResize;
    int s32Ret = 0;

    s32Ret = cve_check_resize_user(pCveHandle, pstSrcImage, pstDstImage, pstResizeCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check RESIZE parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpResize, 0, sizeof(CVE_OP_RESIZE_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpResize.stSrcImage, pstSrcImage, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpResize.stSrcImage1, pstSrcImage1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpResize.stDstImage, pstDstImage, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpResize.stDstImage1, pstDstImage1, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpResize.stResizeCtrl, pstResizeCtrl, sizeof(CVE_RESIZE_CTRL_T));
    stOpResize.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_RESIZE, &stOpResize);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpResize.cveHandle;

    return s32Ret;
}

int CVE_SVM_KERNEL(CVE_HANDLE *pCveHandle, CVE_SRC_MEM_INFO_T *pstSrcMem0,
                   CVE_SRC_MEM_INFO_T *pstSrcMem1, CVE_DST_MEM_INFO_T *pstDstMem,
                   CVE_SVM_KERNEL_CTRL_T *pstSvmKernelCtrl, bool bInstant)
{
    CVE_OP_SVM_KERNEL_T stOpSvmKernel;
    int s32Ret = 0;

    s32Ret =
        cve_check_svm_kernel_user(pCveHandle, pstSrcMem0, pstSrcMem1, pstDstMem, pstSvmKernelCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check SVM KERNEL parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpSvmKernel, 0, sizeof(CVE_OP_SVM_KERNEL_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpSvmKernel.stSrcMem0, pstSrcMem0, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpSvmKernel.stSrcMem1, pstSrcMem1, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpSvmKernel.stDstMem, pstDstMem, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpSvmKernel.stSvmKernelCtrl, pstSvmKernelCtrl, sizeof(CVE_SVM_KERNEL_CTRL_T));
    stOpSvmKernel.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_SVM_KERNEL, &stOpSvmKernel);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpSvmKernel.cveHandle;

    return s32Ret;
}

int CVE_SVM_PREDICT(CVE_HANDLE *pCveHandle, CVE_SRC_MEM_INFO_T *pstSrcMem0,
                    CVE_SRC_MEM_INFO_T *pstSrcMem1, CVE_DST_MEM_INFO_T *pstDstMem0,
                    CVE_DST_MEM_INFO_T *pstDstMem1, CVE_SVM_PREDICT_CTRL_T *pstSvmPredictCtrl,
                    bool bInstant)
{
    CVE_OP_SVM_PREDICT_T stOpSvmPredict;
    int s32Ret = 0;

    s32Ret = cve_check_svm_predict_user(pCveHandle, pstSrcMem0, pstSrcMem1, pstDstMem0, pstDstMem1,
                                        pstSvmPredictCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check SVM KERNEL parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpSvmPredict, 0, sizeof(CVE_OP_SVM_PREDICT_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpSvmPredict.stSrcMem0, pstSrcMem0, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpSvmPredict.stSrcMem1, pstSrcMem1, sizeof(CVE_SRC_MEM_INFO_T));
    memcpy(&stOpSvmPredict.stDstMem0, pstDstMem0, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpSvmPredict.stDstMem1, pstDstMem1, sizeof(CVE_DST_MEM_INFO_T));
    memcpy(&stOpSvmPredict.stSvmPredictCtrl, pstSvmPredictCtrl, sizeof(CVE_SVM_PREDICT_CTRL_T));
    stOpSvmPredict.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_SVM_PREDICT, &stOpSvmPredict);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpSvmPredict.cveHandle;

    return s32Ret;
}

int CVE_RESHAPE(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage, CVE_DST_IMAGE_T *pstDstImage,
                CVE_RESHAPE_CTRL_T *pstReShapeCtrl, bool bInstant)
{
    CVE_OP_RESHAPE_T stOpReshape;
    int s32Ret = 0;

    s32Ret = cve_check_reshape_user(pCveHandle, pstSrcImage, pstDstImage, pstReShapeCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check RESHAPE parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpReshape, 0, sizeof(CVE_OP_RESHAPE_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpReshape.stSrcImage, pstSrcImage, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpReshape.stDstImage, pstDstImage, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpReshape.stReShapeCtrl, pstReShapeCtrl, sizeof(CVE_RESHAPE_CTRL_T));
    stOpReshape.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_RESHAPS, &stOpReshape);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpReshape.cveHandle;

    return s32Ret;
}

int CVE_IM2COL(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage, CVE_DST_IMAGE_T *pstDstImage,
               CVE_IM2COL_CTRL_T *pstImToColCtrl, bool bInstant)
{
    CVE_OP_IM2COL_T stOpIm2Col;
    int s32Ret = 0;

    s32Ret = cve_check_im2col_user(pCveHandle, pstSrcImage, pstDstImage, pstImToColCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check IM2COL parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpIm2Col, 0, sizeof(CVE_OP_IM2COL_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpIm2Col.stSrcImage, pstSrcImage, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpIm2Col.stDstImage, pstDstImage, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpIm2Col.stImToColCtrl, pstImToColCtrl, sizeof(CVE_IM2COL_CTRL_T));
    stOpIm2Col.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_IM2COL, &stOpIm2Col);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpIm2Col.cveHandle;

    return s32Ret;
}

int CVE_GEMM(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage0, CVE_SRC_IMAGE_T *pstSrcImage1,
             CVE_SRC_IMAGE_T *pstSrcImage2, CVE_DST_IMAGE_T *pstDstImage,
             CVE_GEMM_CTRL_T *pstGemmCtrl, bool bInstant)
{
    CVE_OP_GEMM_T stOpGemm;
    int s32Ret = 0;

    s32Ret = cve_check_gemm_user(pCveHandle, pstSrcImage0, pstSrcImage1, pstSrcImage2, pstDstImage,
                                 pstGemmCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check GEMM parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpGemm, 0, sizeof(CVE_OP_GEMM_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpGemm.stSrcImage0, pstSrcImage0, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpGemm.stSrcImage1, pstSrcImage1, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpGemm.stSrcImage2, pstSrcImage2, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpGemm.stDstImage, pstDstImage, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpGemm.stGemmCtrl, pstGemmCtrl, sizeof(CVE_GEMM_CTRL_T));
    stOpGemm.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_GEMM, &stOpGemm);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpGemm.cveHandle;

    return s32Ret;
}

int CVE_POOLING(CVE_HANDLE *pCveHandle, CVE_IMAGE_T *pstSrcImage, CVE_IMAGE_T *pstDstImage,
                CVE_POOLING_CTRL_T *pstPoolingCtrl, bool bInstant)
{
    CVE_OP_POOLING_T stOpPooling;
    int s32Ret = 0;

    s32Ret = cve_check_pooling_user(pCveHandle, pstSrcImage, pstDstImage, pstPoolingCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check GEMM parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpPooling, 0, sizeof(CVE_OP_POOLING_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpPooling.stSrcImage, pstSrcImage, sizeof(CVE_IMAGE_T));
    memcpy(&stOpPooling.stDstImage, pstDstImage, sizeof(CVE_IMAGE_T));
    memcpy(&stOpPooling.stPoolingCtrl, pstPoolingCtrl, sizeof(CVE_POOLING_CTRL_T));
    stOpPooling.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_POOLING, &stOpPooling);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpPooling.cveHandle;

    return s32Ret;
}

int CVE_AIISP_TNR_PRE_PROCESS(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRaw0,
                              CVE_RAW_AIISP_T *pstSrcRaw1, CVE_IMAGE_T *pstDstImage,
                              CVE_AIISP_TNR_PRE_PROCESS_CTRL_T *pstAiIspTnrPreProcessCtrl,
                              bool bInstant)
{
    CVE_OP_AIISP_TNR_PRE_PROCESS_T stOpAiIspTnrPreProcess;
    int s32Ret = 0;

    s32Ret = cve_aiisp_tnr_pre_process_user(pCveHandle, pstSrcRaw0, pstSrcRaw1, pstDstImage,
                                            pstAiIspTnrPreProcessCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check GEMM parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpAiIspTnrPreProcess, 0, sizeof(CVE_OP_AIISP_TNR_PRE_PROCESS_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpAiIspTnrPreProcess.stSrcRaw0, pstSrcRaw0, sizeof(CVE_RAW_AIISP_T));
    memcpy(&stOpAiIspTnrPreProcess.stSrcRaw1, pstSrcRaw1, sizeof(CVE_RAW_AIISP_T));
    memcpy(&stOpAiIspTnrPreProcess.stDstImage, pstDstImage, sizeof(CVE_IMAGE_T));
    memcpy(&stOpAiIspTnrPreProcess.stAiIspTnrPreProcessCtrl, pstAiIspTnrPreProcessCtrl,
           sizeof(CVE_AIISP_TNR_PRE_PROCESS_CTRL_T));
    stOpAiIspTnrPreProcess.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_AIISP_TNR_PRE_PROC, &stOpAiIspTnrPreProcess);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpAiIspTnrPreProcess.cveHandle;

    return s32Ret;
}

int CVE_AIISP_TNR_POST_PROCESS(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRaw0,
                               CVE_RAW_AIISP_T *pstSrcRaw1, CVE_SRC_IMAGE_T *pstSrcImage2,
                               CVE_IMAGE_T *pstSrcImage3, CVE_IMAGE_T *pstDstImage0,
                               CVE_RAW_AIISP_T *pstDstRaw1, CVE_DST_IMAGE_T *pstDstImage2,
                               CVE_DST_IMAGE_T *pstDstImage3,
                               CVE_AIISP_TNR_POST_PROCESS_CTRL_T *pstAiIspTnrPostProcessCtrl,
                               bool bInstant)
{
    CVE_OP_AIISP_TNR_POST_PROCESS_T stOpAiIspTnrPostProcess;
    int s32Ret = 0;

    s32Ret = cve_aiisp_tnr_post_process_user(pCveHandle, pstSrcRaw0, pstSrcRaw1, pstSrcImage2,
                                             pstSrcImage3, pstDstImage0, pstDstRaw1, pstDstImage2,
                                             pstDstImage3, pstAiIspTnrPostProcessCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check GEMM parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpAiIspTnrPostProcess, 0, sizeof(CVE_OP_AIISP_TNR_POST_PROCESS_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpAiIspTnrPostProcess.stSrcRaw0, pstSrcRaw0, sizeof(CVE_RAW_AIISP_T));
    memcpy(&stOpAiIspTnrPostProcess.stSrcRaw1, pstSrcRaw1, sizeof(CVE_RAW_AIISP_T));
    memcpy(&stOpAiIspTnrPostProcess.stSrcImage2, pstSrcImage2, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpAiIspTnrPostProcess.stSrcImage3, pstSrcImage3, sizeof(CVE_IMAGE_T));
    memcpy(&stOpAiIspTnrPostProcess.stDstImage0, pstDstImage0, sizeof(CVE_IMAGE_T));
    memcpy(&stOpAiIspTnrPostProcess.stDstRaw1, pstDstRaw1, sizeof(CVE_RAW_AIISP_T));
    memcpy(&stOpAiIspTnrPostProcess.stDstImage2, pstDstImage2, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpAiIspTnrPostProcess.stDstImage3, pstDstImage3, sizeof(CVE_DST_IMAGE_T));
    memcpy(&stOpAiIspTnrPostProcess.stAiIspTnrPostProcessCtrl, pstAiIspTnrPostProcessCtrl,
           sizeof(CVE_AIISP_TNR_POST_PROCESS_CTRL_T));
    stOpAiIspTnrPostProcess.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_AIISP_TNR_POST_PROC, &stOpAiIspTnrPostProcess);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpAiIspTnrPostProcess.cveHandle;

    return s32Ret;
}

int CVE_AIISP_SNR_POST_PROCESS(CVE_HANDLE *pCveHandle, CVE_IMAGE_T *pstSrcImage0,
                               CVE_IMAGE_T *pstSrcImage1, CVE_SRC_IMAGE_T *pstSrcImage2,
                               CVE_RAW_AIISP_T *pstDstRaw,
                               CVE_AIISP_SNR_POST_PROCESS_CTRL_T *pstAiIspSnrPostProcessCtrl,
                               bool bInstant)
{
    CVE_OP_AIISP_SNR_POST_PROCESS_T stOpAiIspSnrPostProcess;
    int s32Ret = 0;

    s32Ret = cve_aiisp_snr_post_process_user(pCveHandle, pstSrcImage0, pstSrcImage1, pstSrcImage2,
                                             pstDstRaw, pstAiIspSnrPostProcessCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check GEMM parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpAiIspSnrPostProcess, 0, sizeof(CVE_OP_AIISP_SNR_POST_PROCESS_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpAiIspSnrPostProcess.stSrcImage0, pstSrcImage0, sizeof(CVE_IMAGE_T));
    memcpy(&stOpAiIspSnrPostProcess.stSrcImage1, pstSrcImage1, sizeof(CVE_IMAGE_T));
    memcpy(&stOpAiIspSnrPostProcess.stSrcImage2, pstSrcImage2, sizeof(CVE_SRC_IMAGE_T));
    memcpy(&stOpAiIspSnrPostProcess.stDstRaw, pstDstRaw, sizeof(CVE_RAW_AIISP_T));
    memcpy(&stOpAiIspSnrPostProcess.stAiIspSnrPostProcessCtrl, pstAiIspSnrPostProcessCtrl,
           sizeof(CVE_AIISP_SNR_POST_PROCESS_CTRL_T));
    stOpAiIspSnrPostProcess.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_AIISP_SNR_POST_PROC, &stOpAiIspSnrPostProcess);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpAiIspSnrPostProcess.cveHandle;

    return s32Ret;
}

int CVE_AIISP_TNR_MFNR_PROCESS(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRaw,
                                   CVE_IMAGE_T *pstDstImage,
                                   CVE_AIISP_TNR_MFNR_PROCESS_CTRL_T *pstAiIspTnrMfnrProcessCtrl,
                                   bool bInstant)
{
    CVE_OP_AIISP_TNR_MFNR_PROCESS_T stOpAiIspTnrMfnrProcess;
    int s32Ret = 0;

    s32Ret = cve_aiisp_tnr_mfnr_process_user(pCveHandle, pstSrcRaw, pstDstImage,
                                             pstAiIspTnrMfnrProcessCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check tnr mfnr parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpAiIspTnrMfnrProcess, 0, sizeof(CVE_OP_AIISP_TNR_PRE_PROCESS_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpAiIspTnrMfnrProcess.stSrcRaw, pstSrcRaw, sizeof(CVE_RAW_AIISP_T));
    memcpy(&stOpAiIspTnrMfnrProcess.stDstImage, pstDstImage, sizeof(CVE_IMAGE_T));
    memcpy(&stOpAiIspTnrMfnrProcess.stAiIspTnrMfnrProcessCtrl, pstAiIspTnrMfnrProcessCtrl,
           sizeof(CVE_AIISP_TNR_MFNR_PROCESS_CTRL_T));
    stOpAiIspTnrMfnrProcess.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_AIISP_TNR_MFNR_PROC, &stOpAiIspTnrMfnrProcess);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpAiIspTnrMfnrProcess.cveHandle;

    return s32Ret;
}

int CVE_AIISP_SNR_MFNR_PROCESS(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRaw,
                                   CVE_RAW_AIISP_T *pstDstRaw,
                                   CVE_AIISP_SNR_MFNR_PROCESS_CTRL_T *pstAiIspSnrMfnrProcessCtrl,
                                   bool bInstant)
{
    CVE_OP_AIISP_SNR_MFNR_PROCESS_T stOpAiIspSnrMfnrProcess;
    int s32Ret = 0;

    s32Ret = cve_aiisp_snr_mfnr_process_user(pCveHandle, pstSrcRaw, pstDstRaw,
                                             pstAiIspSnrMfnrProcessCtrl);
    if (s32Ret) {
        CVE_ERR_LOG("check snr mfnr parameters failed! error:0x%08x\n", s32Ret);
        return s32Ret;
    }

    memset((void *)&stOpAiIspSnrMfnrProcess, 0, sizeof(CVE_OP_AIISP_SNR_MFNR_PROCESS_T));

    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    memcpy(&stOpAiIspSnrMfnrProcess.stSrcRaw, pstSrcRaw, sizeof(CVE_RAW_AIISP_T));
    memcpy(&stOpAiIspSnrMfnrProcess.stDstRaw, pstDstRaw, sizeof(CVE_RAW_AIISP_T));
    memcpy(&stOpAiIspSnrMfnrProcess.stAiIspSnrMfnrProcessCtrl, pstAiIspSnrMfnrProcessCtrl,
           sizeof(CVE_AIISP_SNR_MFNR_PROCESS_CTRL_T));
    stOpAiIspSnrMfnrProcess.bInstant = bInstant;

    s32Ret = ioctl(g_s32CveFd, CVE_OP_AIISP_SNR_MFNR_PROC, &stOpAiIspSnrMfnrProcess);
    if (s32Ret) {
        *pCveHandle = -1;
    }

    *pCveHandle = stOpAiIspSnrMfnrProcess.cveHandle;

    return s32Ret;
}
int CVE_Query(CVE_HANDLE cveHandle, bool *pbFinish, bool bBlock)
{
    CVE_OP_QUERY_T stQuery;
    int s32Ret = 0;

    if (bBlock != true && bBlock != false) {
        CVE_ERR_LOG("block must be true or false!\n");
        return CVE_ERR_ILLEGAL_PARAM;
    }

    if (pbFinish == NULL) {
        CVE_ERR_LOG("pbFinish is NULL\n");
        return CVE_ERR_NULL_PTR;
    }

    if (cveHandle >= CMD_HANDLE_MAX) {
        CVE_ERR_LOG("Error,cveHandle(%d) must be (-1,%d)\n", cveHandle, CMD_HANDLE_MAX - 1);
        return CVE_ERR_ILLEGAL_PARAM;
    }
    s32Ret = cve_check_fd_open();
    if (s32Ret) {
        return s32Ret;
    }

    stQuery.cveHandle = cveHandle;
    stQuery.bBlock = bBlock;
    s32Ret = ioctl(g_s32CveFd, CVE_OP_QUERY, &stQuery);
    if (!s32Ret) {
        *pbFinish = stQuery.bFinish;
    }

    return s32Ret;
}