1579 lines
52 KiB
C
1579 lines
52 KiB
C
// SPDX-License-Identifier: (GPL-2.0-only OR MIT)
|
|
/*
|
|
* Copyright (C) 2025 Amlogic, Inc. All rights reserved
|
|
*/
|
|
#include "aml_cve.h"
|
|
#include "cve.h"
|
|
#include "cve_check_params.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 AML_S32 g_s32CveFd = -1;
|
|
|
|
static AML_S32 cve_check_fd_open()
|
|
{
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
pthread_mutex_lock(&g_stCveMutex);
|
|
if (g_s32CveFd < 0) {
|
|
g_s32CveFd = open(CVE_DEV, O_RDWR);
|
|
if (g_s32CveFd < 0) {
|
|
CVE_ERR_TRACE("cve dev open failed\n");
|
|
s32Ret = AML_ERR_CVE_NOTREADY;
|
|
}
|
|
}
|
|
pthread_mutex_unlock(&g_stCveMutex);
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
static AML_S32 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,
|
|
AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_NORM_GRAD_T stOpNormGrad;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_norm_grad_param_user(pCveHandle, pstSrc, pstDstH, pstDstV, pstDstHV,
|
|
pstNormGradCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpNormGrad.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_DMA(CVE_HANDLE *pCveHandle, CVE_DATA_T *pstSrc, CVE_DST_DATA_T *pstDst,
|
|
CVE_DMA_CTRL_T *pstDmaCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_DMA_T stOpDMA;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_dma_param_user(pCveHandle, pstSrc, pstDst, pstDmaCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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)) {
|
|
memcpy(&stOpDMA.stSrcDATA, pstSrc, sizeof(CVE_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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpDMA.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_LUAM_STAT_ARRAY_T stOpLuamStat;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_luamStat_param_user(pCveHandle, pstSrc, pstDst, astCveLumaRect,
|
|
pstLumaStatArrayCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpLuamStat.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Filter(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_FILTER_CTRL_T *pstFltCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_FILTER_T stOpFilter;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_filter_param_user(pCveHandle, pstSrc, pstDst, pstFltCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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));
|
|
memcpy(&stOpFilter.stFilterCtrl, pstFltCtrl, sizeof(CVE_FILTER_CTRL_T));
|
|
stOpFilter.bInstant = bInstant;
|
|
|
|
s32Ret = ioctl(g_s32CveFd, CVE_OP_FILTER, &stOpFilter);
|
|
if (s32Ret) {
|
|
*pCveHandle = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpFilter.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_CSC(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_CSC_CTRL_T *pstCscCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_CSC_T stOpCsc;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_csc_param_user(pCveHandle, pstSrc, pstDst, pstCscCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpCsc.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_FilterAndCSC(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_FILTER_AND_CSC_CTRL_T *pstFltCscCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
|
|
CVE_OP_FILTER_AND_CSC_T stOpFilterAndCsc;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_filter_and_csc_param_user(pCveHandle, pstSrc, pstDst, pstFltCscCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpFilterAndCsc.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_SOBEL_T stOpSobel;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_sobel_param_user(pCveHandle, pstSrc, pstDstH, pstDstV, pstSobelCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpSobel.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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,
|
|
AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_MAG_AND_ANG_T stOpMagAndAng;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_mag_and_ang_param_user(pCveHandle, pstSrc, pstDstMag, pstDstAng,
|
|
pstMagAndAngCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpMagAndAng.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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_DST_MEM_INFO_T *pstStatData,
|
|
CVE_MATCH_BG_MODEL_CTRL_T *pstMatchBgModelCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_MATCH_BG_MODEL_T stOpMatchBgModel;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_match_bg_model_param_user(pCveHandle, pstCurImg, pstPreImg, pstBgModel,
|
|
pstFg, pstBg, pstCurDiffBg, pstFrmDiff,
|
|
pstStatData, pstMatchBgModelCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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.stStatData, pstStatData, sizeof(CVE_DST_MEM_INFO_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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpMatchBgModel.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_UPDATE_BG_MODEL_T stOpUpdateBgModel;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_update_bg_model_param_user(pCveHandle, pstCurImg, pstBgModel1, pstBgModel2,
|
|
pstStatData, pstUpdateBgModelCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpUpdateBgModel.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Dilate(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_DILATE_CTRL_T *pstDilateCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_DILATE_T stOpDilate;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_dilate_param_user(pCveHandle, pstSrc, pstDst, pstDilateCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpDilate.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Erode(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_ERODE_CTRL_T *pstErodeCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
|
|
CVE_OP_ERODE_T stOpErode;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_erode_param_user(pCveHandle, pstSrc, pstDst, pstErodeCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpErode.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Thresh(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_THRESH_CTRL_T *pstThrCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_THRESH_T stOpThresh;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_thresh_param_user(pCveHandle, pstSrc, pstDst, pstThrCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpThresh.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Sub(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc1, CVE_SRC_IMAGE_T *pstSrc2,
|
|
CVE_DST_IMAGE_T *pstDst, CVE_DST_MEM_INFO_T *pstMemDst, CVE_SUB_CTRL_T *pstSubCtrl,
|
|
AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_SUB_T stOpSub;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_sub_param_user(pCveHandle, pstSrc1, pstSrc2, pstDst, pstMemDst, pstSubCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
|
|
memcpy(&stOpSub.stSrcImage2, pstSrc2, 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, pstMemDst, sizeof(CVE_DST_MEM_INFO_T));
|
|
stOpSub.bInstant = bInstant;
|
|
|
|
s32Ret = ioctl(g_s32CveFd, CVE_OP_SUB, &stOpSub);
|
|
if (s32Ret) {
|
|
*pCveHandle = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpSub.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Or(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc1, CVE_SRC_IMAGE_T *pstSrc2,
|
|
CVE_DST_IMAGE_T *pstDst, CVE_OR_CTRL_T *pstOrCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_OR_T stOpOr;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_or_param_user(pCveHandle, pstSrc1, pstSrc2, pstDst);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
|
|
memcpy(&stOpOr.stSrcImage2, pstSrc2, 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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpOr.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_And(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc1, CVE_SRC_IMAGE_T *pstSrc2,
|
|
CVE_DST_IMAGE_T *pstDst, CVE_AND_CTRL_T *pstAndCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
|
|
CVE_OP_AND_T stOpAnd;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_and_param_user(pCveHandle, pstSrc1, pstSrc2, pstDst);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
|
|
memcpy(&stOpAnd.stSrcImage2, pstSrc2, 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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpAnd.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Xor(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc1, CVE_SRC_IMAGE_T *pstSrc2,
|
|
CVE_DST_IMAGE_T *pstDst, CVE_XOR_CTRL_T *pstXorCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_XOR_T stOpXor;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_xor_param_user(pCveHandle, pstSrc1, pstSrc2, pstDst);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
|
|
memcpy(&stOpXor.stSrcImage2, pstSrc2, 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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpXor.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Add(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc1, CVE_SRC_IMAGE_T *pstSrc2,
|
|
CVE_DST_IMAGE_T *pstDst, CVE_DST_MEM_INFO_T *pstMemDst, CVE_ADD_CTRL_T *pstAddCtrl,
|
|
AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_ADD_T stOpAdd;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_add_param_user(pCveHandle, pstSrc1, pstSrc2, pstDst, pstMemDst, pstAddCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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.stSrcImage1, pstSrc1, sizeof(CVE_SRC_IMAGE_T));
|
|
memcpy(&stOpAdd.stSrcImage2, pstSrc2, 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, pstMemDst, sizeof(CVE_DST_MEM_INFO_T));
|
|
stOpAdd.bInstant = bInstant;
|
|
|
|
s32Ret = ioctl(g_s32CveFd, CVE_OP_ADD, &stOpAdd);
|
|
if (s32Ret) {
|
|
*pCveHandle = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpAdd.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Integ(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_INTEG_CTRL_T *pstIntegCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_INTEG_T stOpInteg;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_integ_param_user(pCveHandle, pstSrc, pstDst, pstIntegCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpInteg.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Hist(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_MEM_INFO_T *pstDst,
|
|
CVE_HIST_CTRL_T *pstHistCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_HIST_T stOpHist;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_hist_param_user(pCveHandle, pstSrc, pstDst);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpHist.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Thresh_S16(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_THRESH_S16_CTRL_T *pstThrS16Ctrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_THRESH_S16_T stOpThreshS16;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_thresh_s16_param_user(pCveHandle, pstSrc, pstDst, pstThrS16Ctrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpThreshS16.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Thresh_U16(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_THRESH_U16_CTRL_T *pstThrU16Ctrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_THRESH_U16_T stOpThreshU16;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_thresh_u16_param_user(pCveHandle, pstSrc, pstDst, pstThrU16Ctrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpThreshU16.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_16BitTo8Bit(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_16BIT_TO_8BIT_CTRL_T *pst16BitTo8BitCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_16BIT_TO_8BIT_T stOp16bitTo8bit;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_16bit_to_8bit_param_user(pCveHandle, pstSrc, pstDst, pst16BitTo8BitCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOp16bitTo8bit.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_OrdStatFilter(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_ORD_STAT_FILTER_CTRL_T *pstOrdStatFltCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
|
|
CVE_OP_ORD_STAT_FILTER_T stOpOrdStatFilter;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_ord_stat_filter_param_user(pCveHandle, pstSrc, pstDst, pstOrdStatFltCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpOrdStatFilter.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
|
|
CVE_OP_MAP_T stOpMap;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_map_param_user(pCveHandle, pstSrc, pstMap, pstDst, pstMapCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpMap.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_EqualizeHist(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_EQUALIZE_HIST_CTRL_T *pstEqualizeHistCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_EQUALIZE_HIST_T stOpEqualizeHist;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_equalize_hist_param_user(pCveHandle, pstSrc, pstDst, pstEqualizeHistCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpEqualizeHist.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_NCC_T stOpNcc;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_ncc_param_user(pCveHandle, pstSrc1, pstSrc2, pstDst, pstNccCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpNcc.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_CCL_T stOpCcl;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_ccl_param_user(pCveHandle, pstSrc, pstDst, pstBlob, pstCclCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpCcl.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_GMM_T stOpGmm;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret =
|
|
cve_check_gmm_param_user(pCveHandle, pstSrc, pstFactor, pstFg, pstBg, pstModel, pstGmmCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpGmm.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_CANNY_HYS_EDGE_T stOpCannyHysEdge;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_canny_hys_edge_param_user(pCveHandle, pstSrc, pstEdge, pstStack,
|
|
pstCannyHysEdgeCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpCannyHysEdge.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_CannyEdge(CVE_IMAGE_T *pstEdge, CVE_MEM_INFO_T *pstStack,
|
|
CVE_CANNY_EDGE_CTRL_T *pstCannyEdgeCtrl)
|
|
{
|
|
CVE_POINT_U16_T *pstStackPoints;
|
|
AML_U16 au16Xi[3];
|
|
AML_U16 au16Yi[3];
|
|
AML_U8 *ps32Edge;
|
|
AML_S32 i, j, m, n, num;
|
|
AML_U16 s32Row;
|
|
AML_U16 s32Col;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_canny_edge_param_user(pstEdge, pstStack, pstCannyEdgeCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("check cannyEdge parameters failed! error:0x%08x\n", s32Ret);
|
|
return s32Ret;
|
|
}
|
|
|
|
ps32Edge = (AML_U8 *)(AML_UINTPTR_T)pstEdge->au64VirAddr[0];
|
|
pstStackPoints = (CVE_POINT_U16_T *)(AML_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;
|
|
}
|
|
|
|
AML_S32 CVE_LBP(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc, CVE_DST_IMAGE_T *pstDst,
|
|
CVE_LBP_CTRL_T *pstLbpCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_LBP_T stOpLbp;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_lbp_param_user(pCveHandle, pstSrc, pstDst, pstLbpCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpLbp.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
return cve_norm_grad(pCveHandle, pstSrc, pstDstH, pstDstV, pstDstHV, pstNormGradCtrl, bInstant);
|
|
}
|
|
|
|
AML_S32 CVE_BuildLKOpticalFlowPyr(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcPrevPyr,
|
|
CVE_DST_IMAGE_T astDstPyr[],
|
|
CVE_BUILD_LK_OPTICAL_FLOW_PYR_CTRL_T *pstBuildLkOptiFlowPyrCtrl,
|
|
AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_BUILD_LK_OPTICAL_FLOW_PYR_T stOpBuildLkOpticalFlowPyr;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_buildlkoptionalflowpyr_param_user(pCveHandle, pstSrcPrevPyr,
|
|
pstBuildLkOptiFlowPyrCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpBuildLkOpticalFlowPyr.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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,
|
|
AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_LK_OPTICAL_FLOW_PYR_T stOpLkOpticalFlowPyr;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_lk_optical_flow_pyr_param_user(pCveHandle, pstPrevPts, pstNextPts, pstStatus,
|
|
pstLkOptiFlowPyrCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpLkOpticalFlowPyr.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_ST_CANDI_CORNER_T stOpSTCandiCorner;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_st_candi_corner_param_user(pCveHandle, pstSrc, pstLabel, pstCandiCorner,
|
|
pstCandiCornerPoint, pstStCandiCornerCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpSTCandiCorner.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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 *)(AML_UINTPTR_T)pstCornerPoint->u64VirAddr;
|
|
CVE_POINT_U16_T *ptrCandiCorner =
|
|
(CVE_POINT_U16_T *)(AML_UINTPTR_T)pstCandiCornerPoint->u64VirAddr;
|
|
int i, dist, cnt = 0, point = 0;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_st_corner_param_user(pstCandiCornerPoint, pstCornerPoint, pstStCornerCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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;
|
|
}
|
|
|
|
AML_S32 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,
|
|
AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_SAD_T stOpSad;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_sad_param_user(pCveHandle, pstSrc1, pstSrc2, pstSad, pstThr, pstSadCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpSad.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 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, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_GRAD_FG_T stOpGradFg;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_grad_fg_param_user(pCveHandle, pstFg, pstCurGrad, pstBgGrad, pstGradFg,
|
|
pstGradFgCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("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 = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpGradFg.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_TOF(CVE_HANDLE *pCveHandle, CVE_SRC_RAW_T *pstSrcRaw, CVE_SRC_RAW_T *pstSrcFpn,
|
|
CVE_SRC_MEM_INFO_T *pstSrcCoef, CVE_SRC_MEM_INFO_T *pstBpc,
|
|
CVE_DST_MEM_INFO_T *pstDstStatus, CVE_DST_MEM_INFO_T *pstDstIR,
|
|
CVE_DST_MEM_INFO_T *pstDstData, CVE_DST_MEM_INFO_T *pstDstHist,
|
|
CVE_TOF_CTRL_T *pstTofCtrl, AML_BOOL_E bInstant)
|
|
{
|
|
CVE_OP_TOF_T stOpTof;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
s32Ret = cve_check_tof_user(pCveHandle, pstSrcRaw, pstSrcFpn, pstSrcCoef, pstBpc, pstDstStatus,
|
|
pstDstIR, pstDstData, pstDstHist, pstTofCtrl);
|
|
if (s32Ret) {
|
|
CVE_ERR_TRACE("check tof parameters failed! error:0x%08x\n", s32Ret);
|
|
return s32Ret;
|
|
}
|
|
|
|
memset((void *)&stOpTof, 0, sizeof(CVE_OP_TOF_T));
|
|
|
|
s32Ret = cve_check_fd_open();
|
|
if (s32Ret) {
|
|
return s32Ret;
|
|
}
|
|
|
|
memcpy(&stOpTof.stSrcRaw, pstSrcRaw, sizeof(CVE_SRC_RAW_T));
|
|
memcpy(&stOpTof.stSrcFpn, pstSrcFpn, sizeof(CVE_SRC_RAW_T));
|
|
memcpy(&stOpTof.stSrcCoef, pstSrcCoef, sizeof(CVE_SRC_MEM_INFO_T));
|
|
memcpy(&stOpTof.stBpc, pstBpc, sizeof(CVE_SRC_MEM_INFO_T));
|
|
memcpy(&stOpTof.stDtsStatus, pstDstStatus, sizeof(CVE_DST_MEM_INFO_T));
|
|
memcpy(&stOpTof.stDtsIR, pstDstIR, sizeof(CVE_DST_MEM_INFO_T));
|
|
memcpy(&stOpTof.stDtsData, pstDstData, sizeof(CVE_DST_MEM_INFO_T));
|
|
memcpy(&stOpTof.stDstHist, pstDstHist, sizeof(CVE_DST_MEM_INFO_T));
|
|
memcpy(&stOpTof.stTofCtrl, pstTofCtrl, sizeof(CVE_TOF_CTRL_T));
|
|
stOpTof.bInstant = bInstant;
|
|
|
|
s32Ret = ioctl(g_s32CveFd, CVE_OP_TOF, &stOpTof);
|
|
if (s32Ret) {
|
|
*pCveHandle = AML_INVALID_HANDLE;
|
|
}
|
|
|
|
*pCveHandle = stOpTof.cveHandle;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
AML_S32 CVE_Query(CVE_HANDLE cveHandle, AML_BOOL_E *pbFinish, AML_BOOL_E bBlock)
|
|
{
|
|
CVE_OP_QUERY_T stQuery;
|
|
AML_S32 s32Ret = AML_SUCCESS;
|
|
|
|
if (bBlock > 1) {
|
|
CVE_ERR_TRACE("block (%d) must be AML_TRUE or AML_FALSE!\n", bBlock);
|
|
return AML_ERR_CVE_ILLEGAL_PARAM;
|
|
}
|
|
|
|
if (pbFinish == NULL) {
|
|
CVE_ERR_TRACE("pbFinish is NULL\n");
|
|
return AML_ERR_CVE_NULL_PTR;
|
|
}
|
|
|
|
if (cveHandle >= CMD_HANDLE_MAX) {
|
|
CVE_ERR_TRACE("Error,cveHandle(%d) must be (%d,%d)\n", cveHandle, AML_INVALID_HANDLE,
|
|
CMD_HANDLE_MAX - 1);
|
|
return AML_ERR_CVE_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;
|
|
}
|