BPI/BPI-CM9-Linux
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update source to Armbian-dev-202610.A311Y3

Browse Source
This commit is contained in:
Qubot
2026-11-11 08:50:43 +08:00
parent 3428a94f6b
commit f459ef6a9e
12514 changed files with 2264376 additions and 468481 deletions
Download Patch File Download Diff File Expand all files Collapse all files
aml-comp/hardware/amlogic/cve/lib/v2/include/cve.h
+1 -1
View File
@@ -740,7 +740,7 @@ typedef struct {
typedef struct {
CVE_HANDLE cveHandle;
CVE_RAW_AIISP_T stSrcRaw;
CVE_IMAGE_T stSrcImage;
CVE_RAW_AIISP_T stDstRaw;
CVE_AIISP_SNR_MFNR_PROCESS_CTRL_T stAiIspSnrMfnrProcessCtrl;
bool bInstant;
aml-comp/hardware/amlogic/cve/lib/v2/libcve/cve_check_params.c
+17 -18
View File
@@ -15,16 +15,14 @@ int cve_check_dma_param_user(CVE_HANDLE *pCveHandle, CVE_DATA_T *pstSrc, CVE_DST
{
int s32Ret = 0;
if (pCveHandle != NULL) {
if ((pstSrc != NULL) && (pstDmaCtrl != NULL)) {
if (pstDmaCtrl->enMode <= CVE_DMA_MODE_INTERVAL_COPY ||
pstDmaCtrl->enMode == CVE_DMA_MODE_NOT ||
pstDmaCtrl->enMode == CVE_DMA_MODE_DIRECT_COPY_TO_LINE ||
pstDmaCtrl->enMode == CVE_DMA_MODE_COL2IM) {
if (pstSrc == NULL || pstDst == NULL) {
s32Ret = CVE_ERR_NULL_PTR;
CVE_ERR_LOG("pCve have Null handle\n");
}
if (pCveHandle != NULL && (pstDmaCtrl != NULL)) {
if (pstDmaCtrl->enMode <= CVE_DMA_MODE_INTERVAL_COPY ||
pstDmaCtrl->enMode == CVE_DMA_MODE_NOT ||
pstDmaCtrl->enMode == CVE_DMA_MODE_DIRECT_COPY_TO_LINE ||
pstDmaCtrl->enMode == CVE_DMA_MODE_COL2IM) {
if (pstSrc == NULL || pstDst == NULL) {
s32Ret = CVE_ERR_NULL_PTR;
CVE_ERR_LOG("pCve have Null handle\n");
}
} else if (pstDmaCtrl->enMode == CVE_DMA_MODE_SET_3BYTE ||
pstDmaCtrl->enMode == CVE_DMA_MODE_SET_8BYTE) {
@@ -72,10 +70,11 @@ int cve_check_filter_param_user(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrc,
if ((pstSrc == NULL) || (pstDst == NULL) || (pstFltCtrl == NULL)) {
s32Ret = CVE_ERR_NULL_PTR;
CVE_ERR_LOG("pCve have Null handle\n");
}
if (pstFltCtrl->filter_mode == CVE_FILTER_CLARITY && pstDstMem == NULL) {
s32Ret = CVE_ERR_NULL_PTR;
CVE_ERR_LOG("pCve have Null handle\n");
} else if (pstFltCtrl != NULL) {
if (pstFltCtrl->filter_mode == CVE_FILTER_CLARITY && pstDstMem == NULL) {
s32Ret = CVE_ERR_NULL_PTR;
CVE_ERR_LOG("pCve have Null handle\n");
}
}
} else {
CVE_ERR_LOG("pCveHandle is NULL, CVE not init\n");
@@ -1306,8 +1305,8 @@ int cve_aiisp_tnr_post_process_user(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pst
return s32Ret;
}
int cve_aiisp_snr_post_process_user(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage0,
CVE_SRC_IMAGE_T *pstSrcImage1, CVE_SRC_IMAGE_T *pstSrcImage2,
int cve_aiisp_snr_post_process_user(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)
{
@@ -1347,14 +1346,14 @@ int cve_aiisp_tnr_mfnr_process_user(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pst
return s32Ret;
}
int cve_aiisp_snr_mfnr_process_user(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRaw,
int cve_aiisp_snr_mfnr_process_user(CVE_HANDLE *pCveHandle, CVE_IMAGE_T *pstSrcImage,
CVE_RAW_AIISP_T *pstDstRaw,
CVE_AIISP_SNR_MFNR_PROCESS_CTRL_T *pstAiIspSnrMfnrProcessCtrl)
{
int s32Ret = 0;
if (pCveHandle != NULL) {
if ((pstSrcRaw == NULL) || (pstDstRaw == NULL) ||
if ((pstSrcImage == NULL) || (pstDstRaw == NULL) ||
(pstAiIspSnrMfnrProcessCtrl == NULL)) {
s32Ret = CVE_ERR_NULL_PTR;
CVE_ERR_LOG("pCve have Null handle\n");
aml-comp/hardware/amlogic/cve/lib/v2/libcve/cve_check_params.h
+1 -1
View File
@@ -194,7 +194,7 @@ int cve_aiisp_snr_post_process_user(CVE_HANDLE *pCveHandle, CVE_IMAGE_T *pstSrcI
int cve_aiisp_tnr_mfnr_process_user(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRaw,
CVE_IMAGE_T *pstDstImage,
CVE_AIISP_TNR_MFNR_PROCESS_CTRL_T *pstAiIspTnrMfnrProcessCtrl);
int cve_aiisp_snr_mfnr_process_user(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRaw,
int cve_aiisp_snr_mfnr_process_user(CVE_HANDLE *pCveHandle, CVE_IMAGE_T *pstSrcImage,
CVE_RAW_AIISP_T *pstDstRaw,
CVE_AIISP_SNR_MFNR_PROCESS_CTRL_T *pstAiIspSnrMfnrProcessCtrl);
aml-comp/hardware/amlogic/cve/lib/v2/libcve/lib_cve.c
+4 -4
View File
@@ -2400,15 +2400,15 @@ int CVE_AIISP_TNR_MFNR_PROCESS(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRa
return s32Ret;
}
int CVE_AIISP_SNR_MFNR_PROCESS(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRaw,
CVE_RAW_AIISP_T *pstDstRaw,
int CVE_AIISP_SNR_MFNR_PROCESS(CVE_HANDLE *pCveHandle, CVE_IMAGE_T *pstSrcImage,
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,
s32Ret = cve_aiisp_snr_mfnr_process_user(pCveHandle, pstSrcImage, pstDstRaw,
pstAiIspSnrMfnrProcessCtrl);
if (s32Ret) {
CVE_ERR_LOG("check snr mfnr parameters failed! error:0x%08x\n", s32Ret);
@@ -2422,7 +2422,7 @@ int CVE_AIISP_SNR_MFNR_PROCESS(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRa
return s32Ret;
}
memcpy(&stOpAiIspSnrMfnrProcess.stSrcRaw, pstSrcRaw, sizeof(CVE_RAW_AIISP_T));
memcpy(&stOpAiIspSnrMfnrProcess.stSrcImage, pstSrcImage, sizeof(CVE_IMAGE_T));
memcpy(&stOpAiIspSnrMfnrProcess.stDstRaw, pstDstRaw, sizeof(CVE_RAW_AIISP_T));
memcpy(&stOpAiIspSnrMfnrProcess.stAiIspSnrMfnrProcessCtrl, pstAiIspSnrMfnrProcessCtrl,
sizeof(CVE_AIISP_SNR_MFNR_PROCESS_CTRL_T));
aml-comp/hardware/amlogic/cve/lib/v2/libcve/lib_cve.h
+3 -3
View File
@@ -179,8 +179,8 @@ int CVE_AIISP_TNR_POST_PROCESS(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRa
CVE_DST_IMAGE_T *pstDstImage3,
CVE_AIISP_TNR_POST_PROCESS_CTRL_T *pstAiIspTnrPostProcessCtrl,
bool bInstant);
int CVE_AIISP_SNR_POST_PROCESS(CVE_HANDLE *pCveHandle, CVE_SRC_IMAGE_T *pstSrcImage0,
CVE_SRC_IMAGE_T *pstSrcImage1, CVE_SRC_IMAGE_T *pstSrcImage2,
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);
@@ -188,7 +188,7 @@ int CVE_AIISP_TNR_MFNR_PROCESS(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRa
CVE_IMAGE_T *pstDstImage,
CVE_AIISP_TNR_MFNR_PROCESS_CTRL_T *pstAiIspTnrMfnrProcessCtrl,
bool bInstant);
int CVE_AIISP_SNR_MFNR_PROCESS(CVE_HANDLE *pCveHandle, CVE_RAW_AIISP_T *pstSrcRaw,
int CVE_AIISP_SNR_MFNR_PROCESS(CVE_HANDLE *pCveHandle, CVE_IMAGE_T *pstSrcImage,
CVE_RAW_AIISP_T *pstDstRaw,
CVE_AIISP_SNR_MFNR_PROCESS_CTRL_T *pstAiIspSnrMfnrProcessCtrl,
bool bInstant);
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_comm_cve.c
+4
View File
@@ -495,6 +495,7 @@ int SAMPLE_COMM_CVE_ReadFile(CVE_IMAGE_T *pstImg, FILE *pFp)
pU8 += pstImg->au32Stride[0];
}
} break;
case CVE_IMAGE_TYPE_YVU420SP:
case CVE_IMAGE_TYPE_YUV420SP: {
pU8 = (U8 *)(UL)pstImg->au64VirAddr[0];
for (y = 0; y < height; y++) {
@@ -516,6 +517,7 @@ int SAMPLE_COMM_CVE_ReadFile(CVE_IMAGE_T *pstImg, FILE *pFp)
pU8 += pstImg->au32Stride[1];
}
} break;
case CVE_IMAGE_TYPE_YVU422SP:
case CVE_IMAGE_TYPE_YUV422SP:
case CVE_IMAGE_TYPE_S8C2_PLANAR: {
pU8 = (U8 *)(UL)pstImg->au64VirAddr[0];
@@ -695,6 +697,7 @@ int SAMPLE_COMM_CVE_WriteFile(CVE_IMAGE_T *pstImg, FILE *pFp)
pU8 += pstImg->au32Stride[0];
}
} break;
case CVE_IMAGE_TYPE_YVU420SP:
case CVE_IMAGE_TYPE_YUV420SP: {
pU8 = (U8 *)(UL)pstImg->au64VirAddr[0];
for (y = 0; y < height; y++) {
@@ -716,6 +719,7 @@ int SAMPLE_COMM_CVE_WriteFile(CVE_IMAGE_T *pstImg, FILE *pFp)
pU8 += pstImg->au32Stride[1];
}
} break;
case CVE_IMAGE_TYPE_YVU422SP:
case CVE_IMAGE_TYPE_YUV422SP:
case CVE_IMAGE_TYPE_S8C2_PLANAR: {
pU8 = (U8 *)(UL)pstImg->au64VirAddr[0];
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_aiisp_snr_mfnr_process.c
+85 -59
View File
@@ -10,9 +10,8 @@
#include <unistd.h>
typedef struct {
CVE_RAW_AIISP_T stSrcRaw;
CVE_IMAGE_T stSrcImage;
CVE_RAW_AIISP_T stDstRaw;
int enType;
CVE_AIISP_SNR_MFNR_PROCESS_CTRL_T stAiIspSnrMfnrProcessCtrl;
FILE *pFpSrc;
FILE *pFpDst;
@@ -32,9 +31,9 @@ static void SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSUnInit(
SAMPLE_COMM_CVE_WriteFile_From_AiispRaw(&pstOpAiispSnrMfnrProcessInfo->stDstRaw,
pstOpAiispSnrMfnrProcessInfo->pFpDst);
CVE_PMZ_FREE(pstOpAiispSnrMfnrProcessInfo->stSrcRaw.u64PhyAddr,
pstOpAiispSnrMfnrProcessInfo->stSrcRaw.u64VirAddr);
CVE_PMZ_FREE(pstOpAiispSnrMfnrProcessInfo->stDstRaw.u64PhyAddr,
CVE_PMZ_FREE(pstOpAiispSnrMfnrProcessInfo->stSrcImage.dmafd,
pstOpAiispSnrMfnrProcessInfo->stSrcImage.au64VirAddr[0]);
CVE_PMZ_FREE(pstOpAiispSnrMfnrProcessInfo->stDstRaw.dmafd,
pstOpAiispSnrMfnrProcessInfo->stDstRaw.u64VirAddr);
CVE_CLOSE_FILE(pstOpAiispSnrMfnrProcessInfo->pFpSrc);
@@ -43,51 +42,49 @@ static void SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSUnInit(
static int SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSInit(
SAMPLE_CVE_AIISP_SNR_MFNR_PROCESS_INFO_T *pstOpAiispSnrMfnrProcessInfo,
char *pchSrcFileName, char *pchDstFileName, U32 u32Width, U32 u32Height)
char *pchSrcFileName, char *pchDstFileName)
{
int s32Ret = 0;
U32 sqrt_val = 4;
U32 enType;
if (pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.MipiCompactEn == true) {
enType = pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u8MipiBit;
} else {
if (pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u8MipiBit ==
CVE_RAW_AIISP_MODE_RAW8) {
enType = CVE_RAW_AIISP_MODE_RAW8;
} else {
enType = CVE_RAW_AIISP_MODE_RAW16;
}
}
pstOpAiispSnrMfnrProcessInfo->enType = enType;
if (pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u8Channel == 16) {
sqrt_val = 4;
} else {
sqrt_val = 2;
}
memset(&pstOpAiispSnrMfnrProcessInfo->stSrcRaw, 0, sizeof(CVE_RAW_AIISP_T));
memset(&pstOpAiispSnrMfnrProcessInfo->stSrcImage, 0, sizeof(CVE_IMAGE_T));
memset(&pstOpAiispSnrMfnrProcessInfo->stDstRaw, 0, sizeof(CVE_RAW_AIISP_T));
CVE_OPEN_FILE(pstOpAiispSnrMfnrProcessInfo->pFpSrc, pchSrcFileName, "r+");
CVE_OPEN_FILE(pstOpAiispSnrMfnrProcessInfo->pFpDst, pchDstFileName, "w");
s32Ret = SAMPLE_COMM_CVE_CreateAiispRawInfo(&pstOpAiispSnrMfnrProcessInfo->stSrcRaw, enType,
u32Width, u32Height);
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstOpAiispSnrMfnrProcessInfo->stSrcImage, CVE_IMAGE_TYPE_U16C1,
pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u16ImgPadW *
pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u8Channel,
pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u16ImgPadH);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Src Image failed!\n", s32Ret);
goto CVE_DMA_EXIT1;
}
s32Ret = SAMPLE_COMM_CVE_CreateAiispRawInfo(&pstOpAiispSnrMfnrProcessInfo->stDstRaw, enType,
u32Width / sqrt_val, u32Height * sqrt_val);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Src Image failed!\n", s32Ret);
goto CVE_DMA_EXIT2;
if (pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.MipiCompactEn == true) {
s32Ret = SAMPLE_COMM_CVE_CreateAiispRawInfo(
&pstOpAiispSnrMfnrProcessInfo->stDstRaw,
pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u8MipiBit,
pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u16ImgW,
pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u16ImgH);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Src Image failed!\n", s32Ret);
goto CVE_DMA_EXIT2;
}
} else {
s32Ret = SAMPLE_COMM_CVE_CreateAiispRawInfo(
&pstOpAiispSnrMfnrProcessInfo->stDstRaw, CVE_RAW_AIISP_MODE_RAW16,
pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u16ImgW,
pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl.u16ImgH);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Src Image failed!\n", s32Ret);
goto CVE_DMA_EXIT2;
}
}
s32Ret = SAMPLE_COMM_CVE_ReadFile_On_AiispRaw(&pstOpAiispSnrMfnrProcessInfo->stSrcRaw,
pstOpAiispSnrMfnrProcessInfo->pFpSrc);
s32Ret = SAMPLE_COMM_CVE_ReadFile(&pstOpAiispSnrMfnrProcessInfo->stSrcImage,
pstOpAiispSnrMfnrProcessInfo->pFpSrc);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Read Src Image failed!\n", s32Ret);
goto CVE_DMA_EXIT3;
@@ -98,8 +95,8 @@ CVE_DMA_EXIT3:
CVE_PMZ_FREE(pstOpAiispSnrMfnrProcessInfo->stDstRaw.u64PhyAddr,
pstOpAiispSnrMfnrProcessInfo->stDstRaw.u64VirAddr);
CVE_DMA_EXIT2:
CVE_PMZ_FREE(pstOpAiispSnrMfnrProcessInfo->stSrcRaw.u64PhyAddr,
pstOpAiispSnrMfnrProcessInfo->stSrcRaw.u64VirAddr);
CVE_PMZ_FREE(pstOpAiispSnrMfnrProcessInfo->stSrcImage.au64PhyAddr[0],
pstOpAiispSnrMfnrProcessInfo->stSrcImage.au64VirAddr[0]);
CVE_DMA_EXIT1:
CVE_CLOSE_FILE(pstOpAiispSnrMfnrProcessInfo->pFpSrc);
CVE_CLOSE_FILE(pstOpAiispSnrMfnrProcessInfo->pFpDst);
@@ -115,10 +112,10 @@ static int SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSProc(
CVE_HANDLE cveHandle;
int s32Ret = 0;
s32Ret = CVE_AIISP_SNR_MFNR_PROCESS(&cveHandle, &pstOpAiispSnrMfnrProcessInfo->stSrcRaw,
&pstOpAiispSnrMfnrProcessInfo->stDstRaw,
&pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl,
bInstant);
s32Ret = CVE_AIISP_SNR_MFNR_PROCESS(
&cveHandle, &pstOpAiispSnrMfnrProcessInfo->stSrcImage,
&pstOpAiispSnrMfnrProcessInfo->stDstRaw,
&pstOpAiispSnrMfnrProcessInfo->stAiIspSnrMfnrProcessCtrl, bInstant);
if (s32Ret != 0) {
TEST_PRT("CVE KCF GET FEATURE Proc error\n");
return s32Ret;
@@ -140,14 +137,6 @@ int SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSCase(U32 u32CaseIndex)
int i;
U8 u8NoiseLut[16] = {0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x00, 0x00,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00};
U32 u32Width = 32768;
U32 u32Height = 1536;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.stCrop.enCrop = false;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.stCrop.u16X = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.stCrop.u16Y = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.stCrop.u16Width = 8192;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.stCrop.u16Height = 6144;
for (i = 0; i < 16; i++) {
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8NoiseLut[i] = u8NoiseLut[i];
@@ -155,11 +144,17 @@ int SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSCase(U32 u32CaseIndex)
switch (u32CaseIndex) {
case 0:
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgH = 6144;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgW = 1024;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgPadH = 1536;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgPadW = 256;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgShuffleH = 1536;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgShuffleW = 256;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgW = 8192;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgShuffleH =
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgH / 4;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgShuffleW =
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgW / 4;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgPadH =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgShuffleH, 8);
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgPadW =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgShuffleW, 8);
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8Channel = 16;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8NcEn = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8NoiseBins = 0xc;
@@ -171,8 +166,7 @@ int SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSCase(U32 u32CaseIndex)
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16BlcSnrOut[2] = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16BlcSnrOut[3] = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8MipiBit = CVE_RAW_AIISP_MODE_RAW16;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.MipiCompactEn =
true; // true:raw false:image
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.MipiCompactEn = true;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16MfnrBlcOut[0] = 0xf0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16MfnrBlcOut[1] = 0xf0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16MfnrBlcOut[2] = 0xf0;
@@ -180,6 +174,38 @@ int SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSCase(U32 u32CaseIndex)
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8DataBitMode =
CVE_AIISP_MFNR_OUT_16BIT_BIT_MODE;
break;
case 1:
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgH = 6144;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgW = 8192;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgShuffleH =
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgH / 2;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgShuffleW =
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgW / 2;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgPadH =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgShuffleH, 8);
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgPadW =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16ImgShuffleW, 8);
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8Channel = 4;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8NcEn = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8NoiseBins = 0xc;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8NoiseStep = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8SnrDequantScale = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16SnrDequantOffset = 0x2000;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16BlcSnrOut[0] = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16BlcSnrOut[1] = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16BlcSnrOut[2] = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16BlcSnrOut[3] = 0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8MipiBit = CVE_RAW_AIISP_MODE_RAW10;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.MipiCompactEn = true;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16MfnrBlcOut[0] = 0x0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16MfnrBlcOut[1] = 0x0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16MfnrBlcOut[2] = 0x0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u16MfnrBlcOut[3] = 0x0;
stOpAiispSnrMfnrProcessInfo.stAiIspSnrMfnrProcessCtrl.u8DataBitMode =
CVE_AIISP_MFNR_OUT_16BIT_BIT_MODE;
break;
default:
printf("the Aiisp Snr Mfnr case index is invalid! valid index:\n");
SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSCaseList();
@@ -189,8 +215,8 @@ int SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSCase(U32 u32CaseIndex)
SAMPLE_COMM_CVE_Input_FileName(pFpSrcName, sizeof(pFpSrcName), SrcName);
printf("src file name:%s\n", pFpSrcName);
printf("dst file name:%s\n", pFpDstName);
s32Ret = SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSInit(&stOpAiispSnrMfnrProcessInfo, pFpSrcName,
pFpDstName, u32Width, u32Height);
s32Ret =
SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSInit(&stOpAiispSnrMfnrProcessInfo, pFpSrcName, pFpDstName);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] SAMPLE_CVE_AIISP_SNR_MFNR_PROCESSInit failed!\n", s32Ret);
return s32Ret;
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_aiisp_snr_post_process.c
+25 -27
View File
@@ -42,7 +42,7 @@ static void SAMPLE_CVE_AIISP_SNR_POST_PROCESSUnInit(
pstOpAiispSnrPostProcessInfo->stSrcImage1.au64VirAddr[0]);
CVE_PMZ_FREE(pstOpAiispSnrPostProcessInfo->stSrcImage2.dmafd,
pstOpAiispSnrPostProcessInfo->stSrcImage2.au64VirAddr[0]);
CVE_PMZ_FREE(pstOpAiispSnrPostProcessInfo->stDstRaw.u64PhyAddr,
CVE_PMZ_FREE(pstOpAiispSnrPostProcessInfo->stDstRaw.dmafd,
pstOpAiispSnrPostProcessInfo->stDstRaw.u64VirAddr);
CVE_CLOSE_FILE(pstOpAiispSnrPostProcessInfo->pFpSrc0);
@@ -56,13 +56,6 @@ static int SAMPLE_CVE_AIISP_SNR_POST_PROCESSInit(
char *pchSrcFileName1, char *pchSrcFileName2, char *pchDstFileName)
{
int s32Ret = 0;
U32 sqrt_val = 4;
if (pstOpAiispSnrPostProcessInfo->stAiIspSnrPostProcessCtrl.u8Channel == 16) {
sqrt_val = 4;
} else {
sqrt_val = 2;
}
memset(&pstOpAiispSnrPostProcessInfo->stDstRaw, 0, sizeof(CVE_RAW_AIISP_T));
memset(&pstOpAiispSnrPostProcessInfo->stSrcImage0, 0, sizeof(CVE_SRC_IMAGE_T));
@@ -94,17 +87,10 @@ static int SAMPLE_CVE_AIISP_SNR_POST_PROCESSInit(
goto CVE_DMA_EXIT2;
}
if (pstOpAiispSnrPostProcessInfo->stAiIspSnrPostProcessCtrl.u8Channel == 16) {
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstOpAiispSnrPostProcessInfo->stSrcImage2, CVE_IMAGE_TYPE_U8C1,
pstOpAiispSnrPostProcessInfo->stAiIspSnrPostProcessCtrl.u16ImgPadW * sqrt_val + 17,
pstOpAiispSnrPostProcessInfo->stAiIspSnrPostProcessCtrl.u16ImgPadH);
} else {
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstOpAiispSnrPostProcessInfo->stSrcImage2, CVE_IMAGE_TYPE_U8C1,
pstOpAiispSnrPostProcessInfo->stAiIspSnrPostProcessCtrl.u16ImgPadW + 9,
pstOpAiispSnrPostProcessInfo->stAiIspSnrPostProcessCtrl.u16ImgPadH);
}
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstOpAiispSnrPostProcessInfo->stSrcImage2, CVE_IMAGE_TYPE_U8C1,
pstOpAiispSnrPostProcessInfo->stAiIspSnrPostProcessCtrl.u16ImgW / 2 + 4,
pstOpAiispSnrPostProcessInfo->stAiIspSnrPostProcessCtrl.u16ImgH / 2);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Src Image failed!\n", s32Ret);
goto CVE_DMA_EXIT3;
@@ -216,10 +202,16 @@ int SAMPLE_CVE_AIISP_SNR_POST_PROCESSCase(U32 u32CaseIndex)
case 0:
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgH = 1080;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgW = 1920;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgPadH = 272;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgPadW = 480;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleH = 270;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleW = 480;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleH =
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgH / 4;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleW =
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgW / 4;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgPadH =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleH, 8);
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgPadW =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleW, 8);
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u8Channel = 16;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16BlcSnrOut[0] = 240;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16BlcSnrOut[1] = 240;
@@ -230,10 +222,16 @@ int SAMPLE_CVE_AIISP_SNR_POST_PROCESSCase(U32 u32CaseIndex)
case 1:
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgH = 720;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgW = 1280;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgPadH = 360;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgPadW = 640;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleH = 360;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleW = 640;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleH =
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgH / 2;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleW =
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgW / 2;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgPadH =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleH, 8);
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgPadW =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16ImgShuffleW, 8);
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u8Channel = 4;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16BlcSnrOut[0] = 238;
stOpAiispSnrPostProcessInfo.stAiIspSnrPostProcessCtrl.u16BlcSnrOut[1] = 238;
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_aiisp_tnr_mfnr_process.c
+97 -58
View File
@@ -13,8 +13,6 @@ typedef struct {
CVE_RAW_AIISP_T stSrcRaw;
CVE_IMAGE_T stDstImage;
CVE_AIISP_TNR_MFNR_PROCESS_CTRL_T stAiIspTnrMfnrProcessCtrl;
U32 sqrt_val;
U32 enType;
FILE *pFpSrc;
FILE *pFpDst;
} SAMPLE_CVE_AIISP_TNR_MFNR_PROCESS_INFO_T;
@@ -33,9 +31,9 @@ static void SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSUnInit(
SAMPLE_COMM_CVE_WriteFile(&stAiIspTnrMfnrProcessCtrl->stDstImage,
stAiIspTnrMfnrProcessCtrl->pFpDst);
CVE_PMZ_FREE(stAiIspTnrMfnrProcessCtrl->stSrcRaw.u64PhyAddr,
CVE_PMZ_FREE(stAiIspTnrMfnrProcessCtrl->stSrcRaw.dmafd,
stAiIspTnrMfnrProcessCtrl->stSrcRaw.u64VirAddr);
CVE_PMZ_FREE(stAiIspTnrMfnrProcessCtrl->stDstImage.au64PhyAddr[0],
CVE_PMZ_FREE(stAiIspTnrMfnrProcessCtrl->stDstImage.dmafd,
stAiIspTnrMfnrProcessCtrl->stDstImage.au64VirAddr[0]);
CVE_CLOSE_FILE(stAiIspTnrMfnrProcessCtrl->pFpSrc);
@@ -43,55 +41,48 @@ static void SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSUnInit(
}
static int SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSInit(
SAMPLE_CVE_AIISP_TNR_MFNR_PROCESS_INFO_T *stAiIspTnrMfnrProcessCtrl, char *pchSrcFileName,
char *pchDstFileName, U32 u32Width, U32 u32Height)
SAMPLE_CVE_AIISP_TNR_MFNR_PROCESS_INFO_T *pstAiIspTnrMfnrProcessInfo, char *pchSrcFileName,
char *pchDstFileName)
{
int s32Ret = 0;
U32 sqrt_val = 4;
U32 enType;
if (stAiIspTnrMfnrProcessCtrl->stAiIspTnrMfnrProcessCtrl.MipiCompactEn == true) {
enType = stAiIspTnrMfnrProcessCtrl->stAiIspTnrMfnrProcessCtrl.u8MipiBit;
memset(&pstAiIspTnrMfnrProcessInfo->stSrcRaw, 0, sizeof(CVE_RAW_AIISP_T));
memset(&pstAiIspTnrMfnrProcessInfo->stDstImage, 0, sizeof(CVE_RAW_AIISP_T));
CVE_OPEN_FILE(pstAiIspTnrMfnrProcessInfo->pFpSrc, pchSrcFileName, "r+");
CVE_OPEN_FILE(pstAiIspTnrMfnrProcessInfo->pFpDst, pchDstFileName, "w");
if (pstAiIspTnrMfnrProcessInfo->stAiIspTnrMfnrProcessCtrl.MipiCompactEn == true) {
s32Ret = SAMPLE_COMM_CVE_CreateAiispRawInfo(
&pstAiIspTnrMfnrProcessInfo->stSrcRaw,
pstAiIspTnrMfnrProcessInfo->stAiIspTnrMfnrProcessCtrl.u8MipiBit,
pstAiIspTnrMfnrProcessInfo->stAiIspTnrMfnrProcessCtrl.u16ImgW,
pstAiIspTnrMfnrProcessInfo->stAiIspTnrMfnrProcessCtrl.u16ImgH);
} else {
if (stAiIspTnrMfnrProcessCtrl->stAiIspTnrMfnrProcessCtrl.u8MipiBit ==
CVE_RAW_AIISP_MODE_RAW8) {
enType = CVE_RAW_AIISP_MODE_RAW8;
} else {
enType = CVE_RAW_AIISP_MODE_RAW16;
}
s32Ret = SAMPLE_COMM_CVE_CreateAiispRawInfo(
&pstAiIspTnrMfnrProcessInfo->stSrcRaw, CVE_RAW_AIISP_MODE_RAW16,
pstAiIspTnrMfnrProcessInfo->stAiIspTnrMfnrProcessCtrl.u16ImgW,
pstAiIspTnrMfnrProcessInfo->stAiIspTnrMfnrProcessCtrl.u16ImgH);
}
stAiIspTnrMfnrProcessCtrl->enType = enType;
if (stAiIspTnrMfnrProcessCtrl->stAiIspTnrMfnrProcessCtrl.u8Channel == 16) {
sqrt_val = 4;
} else {
sqrt_val = 2;
}
stAiIspTnrMfnrProcessCtrl->sqrt_val = sqrt_val;
memset(&stAiIspTnrMfnrProcessCtrl->stSrcRaw, 0, sizeof(CVE_RAW_AIISP_T));
memset(&stAiIspTnrMfnrProcessCtrl->stDstImage, 0, sizeof(CVE_RAW_AIISP_T));
CVE_OPEN_FILE(stAiIspTnrMfnrProcessCtrl->pFpSrc, pchSrcFileName, "r+");
CVE_OPEN_FILE(stAiIspTnrMfnrProcessCtrl->pFpDst, pchDstFileName, "w");
s32Ret = SAMPLE_COMM_CVE_CreateAiispRawInfo(&stAiIspTnrMfnrProcessCtrl->stSrcRaw, enType,
u32Width, u32Height);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Src Image failed!\n", s32Ret);
goto CVE_DMA_EXIT1;
}
s32Ret =
SAMPLE_COMM_CVE_CreateImage(&stAiIspTnrMfnrProcessCtrl->stDstImage, CVE_IMAGE_TYPE_U16C1,
u32Width * sqrt_val, u32Height / sqrt_val);
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstAiIspTnrMfnrProcessInfo->stDstImage, CVE_IMAGE_TYPE_U16C1,
pstAiIspTnrMfnrProcessInfo->stAiIspTnrMfnrProcessCtrl.u16ImgPadW *
pstAiIspTnrMfnrProcessInfo->stAiIspTnrMfnrProcessCtrl.u8Channel,
pstAiIspTnrMfnrProcessInfo->stAiIspTnrMfnrProcessCtrl.u16ImgPadH);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_DMA_EXIT2;
}
s32Ret = SAMPLE_COMM_CVE_ReadFile_On_AiispRaw(&stAiIspTnrMfnrProcessCtrl->stSrcRaw,
stAiIspTnrMfnrProcessCtrl->pFpSrc);
s32Ret = SAMPLE_COMM_CVE_ReadFile_On_AiispRaw(&pstAiIspTnrMfnrProcessInfo->stSrcRaw,
pstAiIspTnrMfnrProcessInfo->pFpSrc);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Read Src Image failed!\n", s32Ret);
goto CVE_DMA_EXIT3;
@@ -99,20 +90,20 @@ static int SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSInit(
goto CVE_DMA_EXIT0;
CVE_DMA_EXIT3:
CVE_PMZ_FREE(stAiIspTnrMfnrProcessCtrl->stDstImage.au64PhyAddr[0],
stAiIspTnrMfnrProcessCtrl->stDstImage.au64VirAddr[0]);
CVE_PMZ_FREE(pstAiIspTnrMfnrProcessInfo->stDstImage.dmafd,
pstAiIspTnrMfnrProcessInfo->stDstImage.au64VirAddr[0]);
CVE_DMA_EXIT2:
CVE_PMZ_FREE(stAiIspTnrMfnrProcessCtrl->stSrcRaw.u64PhyAddr,
stAiIspTnrMfnrProcessCtrl->stSrcRaw.u64VirAddr);
CVE_PMZ_FREE(pstAiIspTnrMfnrProcessInfo->stSrcRaw.dmafd,
pstAiIspTnrMfnrProcessInfo->stSrcRaw.u64VirAddr);
CVE_DMA_EXIT1:
CVE_CLOSE_FILE(stAiIspTnrMfnrProcessCtrl->pFpSrc);
CVE_CLOSE_FILE(stAiIspTnrMfnrProcessCtrl->pFpDst);
CVE_CLOSE_FILE(pstAiIspTnrMfnrProcessInfo->pFpSrc);
CVE_CLOSE_FILE(pstAiIspTnrMfnrProcessInfo->pFpDst);
CVE_DMA_EXIT0:
return s32Ret;
}
static int SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSProc(
SAMPLE_CVE_AIISP_TNR_MFNR_PROCESS_INFO_T *pstOpAiispTnrMfnrProcessInfo, U32 u32Width)
SAMPLE_CVE_AIISP_TNR_MFNR_PROCESS_INFO_T *pstOpAiispTnrMfnrProcessInfo)
{
bool bInstant = false;
bool bFinish = false;
@@ -141,23 +132,22 @@ int SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSCase(U32 u32CaseIndex)
char *SrcName = "/data/cve/op51-aiisp-tnr-mfnr-process/input/frame_0_src_0.bin";
char pFpSrcName[96] = {0};
char *pFpDstName = "/data/cve/op51-aiisp-tnr-mfnr-process/output/frame_0_dst_0.bin";
U32 u32Width = 8192;
U32 u32Height = 6144;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.stCrop.enCrop = true;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.stCrop.u16X = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.stCrop.u16Y = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.stCrop.u16Width = 1024;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.stCrop.u16Height = 6144;
switch (u32CaseIndex) {
case 0:
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgH = 6144;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgW = 1024;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgW = 8192;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8Channel = 16;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgShuffleH = 1536;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgShuffleW = 256;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgPadH = 1536;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgPadW = 256;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgShuffleH =
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgH / 4;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgShuffleW =
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgW / 4;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgPadH =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgShuffleH, 8);
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgPadW =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgShuffleW, 8);
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8MipiBit = CVE_RAW_AIISP_MODE_RAW12;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.MipiCompactEn = true;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u0q16DiffScale = 0;
@@ -193,6 +183,55 @@ int SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSCase(U32 u32CaseIndex)
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.IsShortFrame = false;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u4q6ExpRatio = 0x60;
break;
case 1:
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgH = 6144;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgW = 8192;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8Channel = 4;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgShuffleH =
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgH / 2;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgShuffleW =
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgW / 2;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgPadH =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgShuffleH, 8);
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgPadW =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u16ImgShuffleW, 8);
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8MipiBit = CVE_RAW_AIISP_MODE_RAW10;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.MipiCompactEn = true;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u0q16DiffScale = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8DiffOffset = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[0] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[1] = 1;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[2] = 2;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[3] = 3;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[4] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[5] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[6] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[7] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[8] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[9] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[10] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[11] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[12] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[13] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[14] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8IdxLut16[15] = 0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8MfnrBlcIn0[0] = 0x0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8MfnrBlcIn0[1] = 0x0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8MfnrBlcIn0[2] = 0x0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8MfnrBlcIn0[3] = 0x0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8MfnrBlcIn1[0] = 0x0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8MfnrBlcIn1[1] = 0x0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8MfnrBlcIn1[2] = 0x0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8MfnrBlcIn1[3] = 0x0;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u8DataBitMode =
CVE_AIISP_MFNR_OUT_12BIT_BIT_RIGHT_SHIFT_4BIT_MODE;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.DgainEn = false;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u6q6Dgain = 1;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.IsShortFrame = false;
stOpAiispTnrMfnrProcessInfo.stAiIspTnrMfnrProcessCtrl.u4q6ExpRatio = 0x60;
break;
default:
printf("the Aiisp Tnr Pre case index is invalid! valid index:\n");
SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSCaseList();
@@ -203,13 +242,13 @@ int SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSCase(U32 u32CaseIndex)
printf("src file name:%s\n", pFpSrcName);
printf("dst file name:%s\n", pFpDstName);
s32Ret = SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSInit(&stOpAiispTnrMfnrProcessInfo, pFpSrcName,
pFpDstName, u32Width, u32Height);
pFpDstName);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSInit failed!\n", s32Ret);
return s32Ret;
}
s32Ret = SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSProc(&stOpAiispTnrMfnrProcessInfo, u32Width);
s32Ret = SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSProc(&stOpAiispTnrMfnrProcessInfo);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] SAMPLE_CVE_AIISP_TNR_MFNR_PROCESSProc failed!\n", s32Ret);
}
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_aiisp_tnr_post_process.c
+45 -34
View File
@@ -84,12 +84,6 @@ static int SAMPLE_CVE_AIISP_TNR_POST_PROCESSInit(
char *pchDstFileName1, char *pchDstFileName2, char *pchDstFileName3)
{
int s32Ret = 0;
U32 sqrt_val = 4;
if (pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u8Channel == 16) {
sqrt_val = 4;
} else {
sqrt_val = 1;
}
memset(&pstOpAiispTnrPostProcessInfo->stSrcRaw0, 0, sizeof(CVE_RAW_AIISP_T));
memset(&pstOpAiispTnrPostProcessInfo->stSrcRaw0, 0, sizeof(CVE_RAW_AIISP_T));
@@ -131,20 +125,32 @@ static int SAMPLE_CVE_AIISP_TNR_POST_PROCESSInit(
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstOpAiispTnrPostProcessInfo->stSrcImage2, CVE_IMAGE_TYPE_U8C1,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgShuffleW * sqrt_val,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgShuffleH);
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgW / 2,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgH / 2);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_DMA_EXIT3;
}
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstOpAiispTnrPostProcessInfo->stSrcImage3, CVE_IMAGE_TYPE_U8C1,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgPadW * sqrt_val,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgPadH);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_DMA_EXIT4;
if (pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u8Channel == 16) {
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstOpAiispTnrPostProcessInfo->stSrcImage3, CVE_IMAGE_TYPE_U8C1,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgPadW / 2 *
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u8Channel,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgPadH / 2);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_DMA_EXIT4;
}
} else {
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstOpAiispTnrPostProcessInfo->stSrcImage3, CVE_IMAGE_TYPE_U8C1,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgPadW,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgPadH);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_DMA_EXIT4;
}
}
s32Ret = SAMPLE_COMM_CVE_CreateImage(
@@ -169,16 +175,16 @@ static int SAMPLE_CVE_AIISP_TNR_POST_PROCESSInit(
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstOpAiispTnrPostProcessInfo->stDstImage2, CVE_IMAGE_TYPE_U8C1,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgShuffleW * sqrt_val,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgShuffleH);
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgW / 2,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgH / 2);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_DMA_EXIT7;
}
s32Ret = SAMPLE_COMM_CVE_CreateImage(
&pstOpAiispTnrPostProcessInfo->stDstImage3, CVE_IMAGE_TYPE_U8C1,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgShuffleW * sqrt_val,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgShuffleH);
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgW / 2,
pstOpAiispTnrPostProcessInfo->stAiIspTnrPostProcessCtrl.u16ImgH / 2);
if (s32Ret != 0) {
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_DMA_EXIT7;
@@ -300,11 +306,6 @@ int SAMPLE_CVE_AIISP_TNR_POST_PROCESSCase(U32 u32CaseIndex)
int i;
memset(&stOpAiispTnrPostProcessInfo, 0, sizeof(stOpAiispTnrPostProcessInfo));
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.stCrop.enCrop = false;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.stCrop.u16X = 0;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.stCrop.u16Y = 0;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.stCrop.u16Width = 1280;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.stCrop.u16Height = 720;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u8MipiBit = CVE_RAW_AIISP_MODE_RAW16;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.MipiCompactEn = false;
@@ -330,10 +331,16 @@ int SAMPLE_CVE_AIISP_TNR_POST_PROCESSCase(U32 u32CaseIndex)
case 0:
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgH = 1080;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgW = 1920;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgPadH = 272;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgPadW = 480;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleH = 270;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleW = 480;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleH =
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgH / 4;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleW =
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgW / 4;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgPadH =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleH, 8);
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgPadW =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleW, 8);
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u8Channel = 16;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u8MaskThr = 81;
@@ -347,14 +354,18 @@ int SAMPLE_CVE_AIISP_TNR_POST_PROCESSCase(U32 u32CaseIndex)
case 1:
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgH = 720;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgW = 1280;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgPadH = 360;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgPadW = 640;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleH = 360;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleW = 640;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleH =
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgH / 2;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleW =
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgW / 2;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgPadH =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleH, 8);
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgPadW =
SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16ImgShuffleW, 8);
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u8Channel = 4;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u8MaskThr = 112;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u8MaskChannel = 1;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16BlcSnrIn[0] = 238;
stOpAiispTnrPostProcessInfo.stAiIspTnrPostProcessCtrl.u16BlcSnrIn[1] = 238;
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_aiisp_tnr_pre_process.c
+16 -13
View File
@@ -154,20 +154,19 @@ int SAMPLE_CVE_AIISP_TNR_PRE_PROCESSCase(U32 u32CaseIndex)
char pFpSrcName1[96] = {0};
char *pFpDstName = "/data/cve/op51-aiisp-tnr-pre-process/output/frame_0_dst_0.bin";
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.stCrop.enCrop = false;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.stCrop.u16X = 0;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.stCrop.u16Y = 0;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.stCrop.u16Width = 300 * 3;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.stCrop.u16Height = 200;
switch (u32CaseIndex) {
case 0:
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgH = 1080;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgW = 1920;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u8Channel = 16;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleH = 270;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleW = 480;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgPadH = 272;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgPadW = 480;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleH =
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgH / 4;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleW =
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgW / 4;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgPadH = SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleH, 8);
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgPadW = SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleW, 8);
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u8MipiBit = CVE_RAW_AIISP_MODE_RAW16;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.MipiCompactEn = false;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u0q16DiffScale = 64;
@@ -193,10 +192,14 @@ int SAMPLE_CVE_AIISP_TNR_PRE_PROCESSCase(U32 u32CaseIndex)
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgH = 720;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgW = 1280;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u8Channel = 4;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleH = 360;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleW = 640;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgPadH = 360;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgPadW = 640;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleH =
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgH / 2;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleW =
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgW / 2;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgPadH = SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleH, 8);
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgPadW = SAMPLE_COMM_CVE_CalcStride(
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u16ImgShuffleW, 8);
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u8MipiBit = CVE_RAW_AIISP_MODE_RAW16;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.MipiCompactEn = false;
stOpAiispTnrPreProcessInfo.stAiIspTnrPreProcessCtrl.u0q16DiffScale = 2399;
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_alu.c
+1 -1
View File
@@ -104,7 +104,7 @@ static int SAMPLE_CVE_AluInit(SAMPLE_CVE_ALU_INFO_T *pstAluInfo, U32 u32Width, U
goto CVE_ALU_EXIT2;
}
if (pstAluInfo->stDotCtrl.stCrop.enCrop == true) {
if (pstAluInfo->stDotCtrl.stCrop.enCrop == true && pstAluInfo->enOp == true) {
s32Ret = SAMPLE_COMM_CVE_CreateImage(&pstAluInfo->stDst, enDstImageType,
pstAluInfo->stDotCtrl.stCrop.u16Width,
pstAluInfo->stDotCtrl.stCrop.u16Height);
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_canny_hys_edge.c
+5
View File
@@ -98,6 +98,8 @@ static int SAMPLE_CVE_CannyHysEdgeInit(SAMPLE_CVE_CANNY_HYS_EDGE_INFO_T *pstCann
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_CANNY_HYS_EDGE_EXIT2;
}
memset((void *)(uintptr_t)pstCannyHysEdgeInfo->stEdge.au64VirAddr[0], 0,
u32Width * u32Height);
pstCannyHysEdgeInfo->stEdge.u32Height = pstCannyHysEdgeInfo->stEdge.u32Height - 1;
pstCannyHysEdgeInfo->stCannyHysEdgeCtrl.u32CannyCount =
(U32 *)(uintptr_t)(pstCannyHysEdgeInfo->stEdge.au64VirAddr[0] +
@@ -110,6 +112,7 @@ static int SAMPLE_CVE_CannyHysEdgeInit(SAMPLE_CVE_CANNY_HYS_EDGE_INFO_T *pstCann
TEST_PRT("[ERROR][%x] Create Dst Mem failed!\n", s32Ret);
goto CVE_CANNY_HYS_EDGE_EXIT3;
}
memset((void *)(uintptr_t)pstCannyHysEdgeInfo->stStack.u64VirAddr, 0, u32Size);
u32Size = pstCannyHysEdgeInfo->stSrc.au32Stride[0] * pstCannyHysEdgeInfo->stSrc.u32Height * 4;
s32Ret = SAMPLE_COMM_CVE_CreateMemInfo(&pstCannyHysEdgeInfo->stCannyHysEdgeCtrl.stMem, u32Size);
@@ -117,6 +120,8 @@ static int SAMPLE_CVE_CannyHysEdgeInit(SAMPLE_CVE_CANNY_HYS_EDGE_INFO_T *pstCann
TEST_PRT("[ERROR][%x] Create Dst Mem failed!\n", s32Ret);
goto CVE_CANNY_HYS_EDGE_EXIT4;
}
memset((void *)(uintptr_t)pstCannyHysEdgeInfo->stCannyHysEdgeCtrl.stMem.u64VirAddr, 0,
u32Size);
s32Ret = SAMPLE_COMM_CVE_ReadFile(&pstCannyHysEdgeInfo->stSrc, pstCannyHysEdgeInfo->pFpSrc);
if (s32Ret != 0) {
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_ccl.c
+2
View File
@@ -75,6 +75,7 @@ static int SAMPLE_CVE_CclInit(SAMPLE_CVE_CCL_INFO_T *pstCclInfo, U32 u32Width, U
TEST_PRT("[ERROR][%x] Create Src Image failed!\n", s32Ret);
goto CVE_CCL_EXIT2;
}
memset((void *)(uintptr_t)pstCclInfo->stDst.au64VirAddr[0], 0, u32Width * u32Height * 2);
size = sizeof(CVE_CCBLOB_T);
s32Ret = SAMPLE_COMM_CVE_CreateMemInfo(&pstCclInfo->stBlob, size);
@@ -82,6 +83,7 @@ static int SAMPLE_CVE_CclInit(SAMPLE_CVE_CCL_INFO_T *pstCclInfo, U32 u32Width, U
TEST_PRT("[ERROR][%x] Create Dst Mem failed!\n", s32Ret);
goto CVE_CCL_EXIT3;
}
memset((void *)(uintptr_t)pstCclInfo->stBlob.u64VirAddr, 0, size);
s32Ret = SAMPLE_COMM_CVE_ReadFile(&pstCclInfo->stSrc, pstCclInfo->pFpSrc);
if (s32Ret != 0) {
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_erode_and_dilate.c
+2 -1
View File
@@ -42,6 +42,7 @@ void SAMPLE_CVE_ErodeDilateCaseList(void)
printf("\t\t 1) OP:Erode FT:1.\n");
printf("\t\t 2) OP:Dilate FT:0.\n");
printf("\t\t 3) OP:Dilate FT:1.\n");
printf("\t\t 4) OP:Bernsen 5X5.\n");
return;
}
@@ -111,7 +112,7 @@ static int SAMPLE_CVE_ErodeDilateInit(SAMPLE_CVE_ERODE_DILATE_INFO_T *pstErodeDi
goto CVE_ERODE_DILATE_EXIT1;
}
if (pstErodeDilateInfo->stBernsenCtrl.stCrop.enCrop == true) {
if (pstErodeDilateInfo->stBernsenCtrl.stCrop.enCrop == true && enOp == CVE_OP_BERNSEN) {
s32Ret = SAMPLE_COMM_CVE_CreateImage(&pstErodeDilateInfo->stDst, CVE_IMAGE_TYPE_U8C1,
pstErodeDilateInfo->stBernsenCtrl.stCrop.u16Width,
pstErodeDilateInfo->stBernsenCtrl.stCrop.u16Height);
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_gmm.c
+8
View File
@@ -68,6 +68,7 @@ static void SAMPLE_CVE_GmmUninit(SAMPLE_CVE_GMM_INFO_T *pstGmmInfo)
CVE_CLOSE_FILE(pstGmmInfo->pFpSrc2);
CVE_CLOSE_FILE(pstGmmInfo->pFpDstFg);
CVE_CLOSE_FILE(pstGmmInfo->pFpDstBg);
CVE_CLOSE_FILE(pstGmmInfo->pFpDstMemPrev);
CVE_CLOSE_FILE(pstGmmInfo->pFpDstMem);
}
@@ -131,6 +132,8 @@ static int SAMPLE_CVE_GmmInit(SAMPLE_CVE_GMM_INFO_T *pstGmmInfo, CVE_IMAGE_TYPE_
TEST_PRT("[ERROR][%x] Create Src Image failed!\n", s32Ret);
goto CVE_GMM_EXIT2;
}
memset((void *)(uintptr_t)pstGmmInfo->stFactor.au64VirAddr[0], 0,
pstGmmInfo->stFactor.au32Stride[0] * (u32Height >> enDownScaleMode) * 2);
s32Ret = SAMPLE_COMM_CVE_CreateImage(&pstGmmInfo->stFg, CVE_IMAGE_TYPE_U8C1,
u32Width >> enDownScaleMode, u32Height >> enDownScaleMode);
@@ -138,6 +141,8 @@ static int SAMPLE_CVE_GmmInit(SAMPLE_CVE_GMM_INFO_T *pstGmmInfo, CVE_IMAGE_TYPE_
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_GMM_EXIT3;
}
memset((void *)(uintptr_t)pstGmmInfo->stFg.au64VirAddr[0], 0,
pstGmmInfo->stFg.au32Stride[0] * (u32Height >> enDownScaleMode));
s32Ret = SAMPLE_COMM_CVE_CreateImage(&pstGmmInfo->stBg, enSrcType, u32Width >> enDownScaleMode,
u32Height >> enDownScaleMode);
@@ -145,6 +150,8 @@ static int SAMPLE_CVE_GmmInit(SAMPLE_CVE_GMM_INFO_T *pstGmmInfo, CVE_IMAGE_TYPE_
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_GMM_EXIT4;
}
memset((void *)(uintptr_t)pstGmmInfo->stBg.au64VirAddr[0], 0,
pstGmmInfo->stBg.au32Stride[0] * (u32Height >> enDownScaleMode) * channel_num);
u32DstSize = (u32Width >> enDownScaleMode) * (2 + modelnum * (4 + 2 * channel_num)) *
(u32Height >> enDownScaleMode);
@@ -153,6 +160,7 @@ static int SAMPLE_CVE_GmmInit(SAMPLE_CVE_GMM_INFO_T *pstGmmInfo, CVE_IMAGE_TYPE_
TEST_PRT("[ERROR][%x] Create Dst Mem failed!\n", s32Ret);
goto CVE_GMM_EXIT5;
}
memset((void *)(uintptr_t)pstGmmInfo->stModel.u64VirAddr, 0, u32DstSize);
s32Ret = SAMPLE_COMM_CVE_ReadFile(&pstGmmInfo->stSrc, pstGmmInfo->pFpSrc1);
if (s32Ret != 0) {
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_lbp.c
+1
View File
@@ -65,6 +65,7 @@ static int SAMPLE_CVE_LbpInit(SAMPLE_CVE_LBP_INFO_T *pstLbpInfo, U32 u32Width, U
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_LBP_EXIT2;
}
memset((void *)(uintptr_t)pstLbpInfo->stDst.au64VirAddr[0], 0, u32Width * u32Height);
s32Ret = SAMPLE_COMM_CVE_ReadFile(&pstLbpInfo->stSrc, pstLbpInfo->pFpSrc);
if (s32Ret != 0) {
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_mag_and_ang.c
+4
View File
@@ -106,6 +106,8 @@ static int SAMPLE_CVE_MagAngInit(SAMPLE_CVE_MAG_ANG_INFO_T *pstMagAngInfo, U32 u
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_MagAng_EXIT3;
}
memset((void *)(uintptr_t)pstMagAngInfo->stDstAng.au64VirAddr[0], 0,
u32Width * u32Height);
} else if (enOutCtrl == CVE_MAG_AND_ANG_OUT_CTRL_HOG) {
s32Ret = SAMPLE_COMM_CVE_CreateImage(&pstMagAngInfo->stDstAng, CVE_IMAGE_TYPE_U16C1,
u32Width, u32Height);
@@ -113,6 +115,8 @@ static int SAMPLE_CVE_MagAngInit(SAMPLE_CVE_MAG_ANG_INFO_T *pstMagAngInfo, U32 u
TEST_PRT("[ERROR][%x] Create Dst Image failed!\n", s32Ret);
goto CVE_MagAng_EXIT3;
}
memset((void *)(uintptr_t)pstMagAngInfo->stDstAng.au64VirAddr[0], 0,
u32Width * u32Height * 2);
}
s32Ret = SAMPLE_COMM_CVE_ReadFile(&pstMagAngInfo->stSrc, pstMagAngInfo->pFpSrc);
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_ncc.c
+1
View File
@@ -78,6 +78,7 @@ static int SAMPLE_CVE_NccInit(SAMPLE_CVE_NCC_INFO_T *pstNccInfo, U32 u32Width, U
TEST_PRT("[ERROR][%x] Create Dst Mem failed!\n", s32Ret);
goto CVE_NCC_EXIT3;
}
memset((void *)(uintptr_t)pstNccInfo->stDst.u64VirAddr, 0, sizeof(CVE_NCC_DST_MEM_T));
s32Ret = SAMPLE_COMM_CVE_ReadFile(&pstNccInfo->stSrc1, pstNccInfo->pFpSrc1);
if (s32Ret != 0) {
aml-comp/hardware/amlogic/cve/lib/v2/sample/sample_cve_persptrans.c
-1
View File
@@ -56,7 +56,6 @@ static int SAMPLE_CVE_ReadFile(CVE_IMAGE_T *pstImg, FILE *pFp, U8 UvEn)
height = pstImg->u32Height;
width = pstImg->u32Width;
// width = pstImg->au32Stride[0];
switch (pstImg->enType) {
case CVE_IMAGE_TYPE_U8C1: