2473 lines
81 KiB
C
2473 lines
81 KiB
C
// 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;
|
|
}
|