727 lines
27 KiB
C++
727 lines
27 KiB
C++
/* Copyright 2020 Rockchip Electronics Co. LTD
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* author: rimon.xu@rock-chips.com
|
|
* date: 2020-11-06
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include "rk_debug.h"
|
|
#include "rk_mpi_mb.h"
|
|
#include "rk_comm_tde.h"
|
|
#include "rk_comm_video.h"
|
|
#include "rk_mpi_tde.h"
|
|
#include "rk_mpi_sys.h"
|
|
#include "rk_mpi_cal.h"
|
|
#include "argparse.h"
|
|
#include "mpi_test_utils.h"
|
|
|
|
typedef enum rkTDE_OP_TYPE_E {
|
|
TDE_OP_QUICK_COPY = 0,
|
|
TDE_OP_QUICK_RESIZE,
|
|
TDE_OP_QUICK_FILL,
|
|
TDE_OP_ROTATION,
|
|
TDE_OP_MIRROR,
|
|
TDE_OP_COLOR_KEY
|
|
} TDE_OP_TYPE_E;
|
|
|
|
typedef struct _rkTDEOpMap {
|
|
RK_S32 op;
|
|
const char* strOp;
|
|
} TDE_OP_MAP_S;
|
|
|
|
const static TDE_OP_MAP_S gstTdeOpMaps[] = {
|
|
{ TDE_OP_QUICK_COPY, "quick_copy" },
|
|
{ TDE_OP_QUICK_RESIZE, "quick_resize" },
|
|
{ TDE_OP_QUICK_FILL, "quick_fill" },
|
|
{ TDE_OP_ROTATION, "rotation" },
|
|
{ TDE_OP_MIRROR, "mirror" },
|
|
{ TDE_OP_COLOR_KEY, "color_key" }
|
|
};
|
|
|
|
typedef struct _rkMpiTdeCtx {
|
|
const char *srcFilePath;
|
|
const char *dstFilePath;
|
|
RK_S32 s32LoopCount;
|
|
RK_S32 s32JobNum;
|
|
RK_S32 s32TaskNum;
|
|
RK_S32 s32Rotation;
|
|
RK_S32 s32Operation;
|
|
TDE_SURFACE_S stSrcSurface;
|
|
TDE_SURFACE_S stDstSurface;
|
|
RECT_S stSrcRect;
|
|
RECT_S stDstRect;
|
|
RK_U32 u32SrcVirWidth;
|
|
RK_U32 u32SrcVirHeight;
|
|
RK_S32 s32Color;
|
|
RK_S32 s32Mirror;
|
|
RK_BOOL bStatEn;
|
|
} TEST_TDE_CTX_S;
|
|
|
|
static const char *test_tde_str_op(RK_S32 op) {
|
|
RK_S32 s32ElemLen = sizeof(gstTdeOpMaps) / sizeof(gstTdeOpMaps[0]);
|
|
for (size_t i = 0; i < s32ElemLen; i++) {
|
|
if (op == gstTdeOpMaps[i].op) {
|
|
return gstTdeOpMaps[i].strOp;
|
|
}
|
|
}
|
|
|
|
return RK_NULL;
|
|
}
|
|
|
|
RK_S32 test_tde_save_result(MB_BLK dstBlk, TDE_SURFACE_S *pstDst, RK_S32 taskId, TEST_TDE_CTX_S *ctx) {
|
|
char yuv_out_path[1024] = {0};
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
PIC_BUF_ATTR_S stPicBufAttr;
|
|
MB_PIC_CAL_S stMbPicCalResult;
|
|
RK_VOID *pstFrame = RK_MPI_MB_Handle2VirAddr(dstBlk);
|
|
stPicBufAttr.u32Width = ctx->stDstSurface.u32Width;
|
|
stPicBufAttr.u32Height = ctx->stDstSurface.u32Height;
|
|
stPicBufAttr.enPixelFormat = ctx->stDstSurface.enColorFmt;
|
|
stPicBufAttr.enCompMode = COMPRESS_MODE_NONE;
|
|
s32Ret = RK_MPI_CAL_TDE_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
|
|
return s32Ret;
|
|
}
|
|
RK_U32 u32OutputSize = stMbPicCalResult.u32MBSize;
|
|
|
|
snprintf(yuv_out_path,
|
|
sizeof(yuv_out_path),
|
|
"%s%s_%dx%d_%d.bin",
|
|
ctx->dstFilePath,
|
|
test_tde_str_op(ctx->s32Operation),
|
|
stPicBufAttr.u32Width,
|
|
stPicBufAttr.u32Height,
|
|
taskId);
|
|
|
|
FILE *file = fopen(yuv_out_path, "wb+");
|
|
if (file == RK_NULL) {
|
|
RK_LOGE("open path %s failed because %s.", yuv_out_path, strerror(errno));
|
|
return RK_FAILURE;
|
|
}
|
|
|
|
if (pstFrame) {
|
|
RK_LOGI("get frame data = %p, size = %d, bBlk:%p ", pstFrame, u32OutputSize, dstBlk);
|
|
fwrite(pstFrame, 1, u32OutputSize, file);
|
|
fflush(file);
|
|
}
|
|
fclose(file);
|
|
file = NULL;
|
|
|
|
return RK_SUCCESS;
|
|
}
|
|
|
|
RK_U32 unit_test_tde_get_size(TEST_TDE_CTX_S *ctx) {
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
PIC_BUF_ATTR_S stPicBufAttr;
|
|
MB_PIC_CAL_S stMbPicCalResult;
|
|
|
|
if (ctx->u32SrcVirWidth == 0) {
|
|
ctx->u32SrcVirWidth = ctx->stSrcSurface.u32Width;
|
|
}
|
|
if (ctx->u32SrcVirHeight == 0) {
|
|
ctx->u32SrcVirHeight = ctx->stSrcSurface.u32Height;
|
|
}
|
|
|
|
stPicBufAttr.u32Width = ctx->u32SrcVirWidth;
|
|
stPicBufAttr.u32Height = ctx->u32SrcVirHeight;
|
|
stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->stSrcSurface.enColorFmt;
|
|
stPicBufAttr.enCompMode = COMPRESS_MODE_NONE;
|
|
s32Ret = RK_MPI_CAL_COMM_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
|
|
return s32Ret;
|
|
}
|
|
|
|
return stMbPicCalResult.u32MBSize;
|
|
}
|
|
|
|
FILE *test_tde_read_file(const char *path, void *pu8SrcData, RK_U32 u32ImgSize, TEST_TDE_CTX_S *ctx) {
|
|
FILE *pFile = RK_NULL;
|
|
RK_U32 u32ReadSize = 0;
|
|
|
|
pFile = fopen(path, "rb+");
|
|
if (pFile == RK_NULL) {
|
|
RK_LOGE("open path %s failed because %s.", path, strerror(errno));
|
|
return RK_NULL;
|
|
}
|
|
|
|
if (pFile) {
|
|
u32ReadSize = fread(pu8SrcData, 1, u32ImgSize, pFile);
|
|
fflush(pFile);
|
|
}
|
|
|
|
RK_LOGE("unit_test_open_source u32ReadSize:%d", u32ReadSize);
|
|
if (u32ReadSize != u32ImgSize) {
|
|
fclose(pFile);
|
|
RK_LOGE("read error read %d, request %d", u32ReadSize, u32ImgSize);
|
|
return RK_NULL;
|
|
}
|
|
|
|
return pFile;
|
|
}
|
|
|
|
RK_S32 test_tde_fill_src(
|
|
TEST_TDE_CTX_S *ctx, TDE_SURFACE_S *pstSrcSurface, TDE_RECT_S *pstSrcRect) {
|
|
pstSrcSurface->u32Width = ctx->stSrcSurface.u32Width;
|
|
pstSrcSurface->u32Height = ctx->stSrcSurface.u32Height;
|
|
pstSrcSurface->enColorFmt = ctx->stSrcSurface.enColorFmt;
|
|
pstSrcRect->s32Xpos = ctx->stSrcRect.s32X;
|
|
pstSrcRect->s32Ypos = ctx->stSrcRect.s32Y;
|
|
pstSrcRect->u32Width = ctx->stSrcRect.u32Width;
|
|
pstSrcRect->u32Height = ctx->stSrcRect.u32Height;
|
|
|
|
return RK_SUCCESS;
|
|
}
|
|
|
|
RK_S32 test_tde_fill_dst(
|
|
TEST_TDE_CTX_S *ctx, TDE_SURFACE_S *pstDstSurface, TDE_RECT_S *pstDstRect) {
|
|
pstDstSurface->u32Width = ctx->stDstSurface.u32Width;
|
|
pstDstSurface->u32Height = ctx->stDstSurface.u32Height;
|
|
pstDstSurface->enColorFmt = ctx->stDstSurface.enColorFmt;
|
|
pstDstRect->s32Xpos = ctx->stDstRect.s32X;
|
|
pstDstRect->s32Ypos = ctx->stDstRect.s32Y;
|
|
pstDstRect->u32Width = ctx->stDstRect.u32Width;
|
|
pstDstRect->u32Height = ctx->stDstRect.u32Height;
|
|
|
|
return RK_SUCCESS;
|
|
}
|
|
|
|
RK_S32 test_tde_quick_copy_task(TDE_SURFACE_S *pstSrc,
|
|
TDE_RECT_S *pstSrcRect,
|
|
TDE_SURFACE_S *pstDst,
|
|
TDE_RECT_S *pstDstRect,
|
|
MB_BLK srcBlk,
|
|
RK_U32 u32ImgSize,
|
|
TEST_TDE_CTX_S *ctx) {
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
MB_BLK dstBlk = RK_NULL;
|
|
|
|
test_tde_fill_src(ctx, pstSrc, pstSrcRect);
|
|
test_tde_fill_dst(ctx, pstDst, pstDstRect);
|
|
|
|
s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32ImgSize);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
return RK_FAILURE;
|
|
}
|
|
|
|
pstSrc->pMbBlk = srcBlk;
|
|
pstDst->pMbBlk = dstBlk;
|
|
|
|
return RK_SUCCESS;
|
|
}
|
|
|
|
RK_S32 test_tde_quick_resize_task(TDE_SURFACE_S *pstSrc,
|
|
TDE_RECT_S *pstSrcRect,
|
|
TDE_SURFACE_S *pstDst,
|
|
TDE_RECT_S *pstDstRect,
|
|
MB_BLK srcBlk,
|
|
RK_U32 u32ImgSize,
|
|
TEST_TDE_CTX_S *ctx) {
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
MB_BLK dstBlk = RK_NULL;
|
|
|
|
test_tde_fill_src(ctx, pstSrc, pstSrcRect);
|
|
test_tde_fill_dst(ctx, pstDst, pstDstRect);
|
|
|
|
s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32ImgSize);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
return RK_FAILURE;
|
|
}
|
|
|
|
pstSrc->pMbBlk = srcBlk;
|
|
pstDst->pMbBlk = dstBlk;
|
|
|
|
return RK_SUCCESS;
|
|
}
|
|
|
|
RK_S32 test_tde_quick_fill_task(TDE_SURFACE_S *pstDst,
|
|
TDE_RECT_S *pstDstRect,
|
|
MB_BLK srcBlk,
|
|
RK_U32 u32ImgSize,
|
|
TEST_TDE_CTX_S *ctx) {
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
MB_BLK dstBlk = RK_NULL;
|
|
|
|
test_tde_fill_dst(ctx, pstDst, pstDstRect);
|
|
|
|
s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32ImgSize);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
return RK_FAILURE;
|
|
}
|
|
memcpy(RK_MPI_MB_Handle2VirAddr(dstBlk),
|
|
RK_MPI_MB_Handle2VirAddr(srcBlk),
|
|
u32ImgSize);
|
|
|
|
pstDst->pMbBlk = dstBlk;
|
|
|
|
return RK_SUCCESS;
|
|
}
|
|
|
|
RK_S32 test_tde_rotate_task(TDE_SURFACE_S *pstSrc,
|
|
TDE_RECT_S *pstSrcRect,
|
|
TDE_SURFACE_S *pstDst,
|
|
TDE_RECT_S *pstDstRect,
|
|
MB_BLK srcBlk,
|
|
RK_U32 u32ImgSize, TEST_TDE_CTX_S *ctx) {
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
MB_BLK dstBlk = RK_NULL;
|
|
|
|
test_tde_fill_src(ctx, pstSrc, pstSrcRect);
|
|
test_tde_fill_dst(ctx, pstDst, pstDstRect);
|
|
|
|
s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32ImgSize);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
return RK_FAILURE;
|
|
}
|
|
|
|
pstSrc->pMbBlk = srcBlk;
|
|
pstDst->pMbBlk = dstBlk;
|
|
|
|
return RK_SUCCESS;
|
|
}
|
|
|
|
RK_S32 test_tde_bit_blit_task(TDE_SURFACE_S *pstSrc,
|
|
TDE_RECT_S *pstSrcRect,
|
|
TDE_SURFACE_S *pstDst,
|
|
TDE_RECT_S *pstDstRect,
|
|
TDE_OPT_S *stOpt,
|
|
MB_BLK srcBlk,
|
|
RK_U32 u32ImgSize, RK_S32 i, TEST_TDE_CTX_S *ctx) {
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
MB_BLK dstBlk = RK_NULL;
|
|
RK_U32 u32ReadSize = 0;
|
|
void *pDstData = RK_NULL;
|
|
|
|
s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32ImgSize);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
return RK_FAILURE;
|
|
}
|
|
|
|
if (i == 0) {
|
|
// test case : mirror and clip
|
|
stOpt->enMirror = (MIRROR_E)ctx->s32Mirror;
|
|
stOpt->stClipRect.s32Xpos = ctx->stSrcRect.s32X;
|
|
stOpt->stClipRect.s32Ypos = ctx->stSrcRect.s32Y;
|
|
stOpt->stClipRect.u32Width = ctx->stSrcRect.u32Width;
|
|
stOpt->stClipRect.u32Height = ctx->stSrcRect.u32Height;
|
|
|
|
test_tde_fill_src(ctx, pstSrc, pstSrcRect);
|
|
pstSrc->pMbBlk = srcBlk;
|
|
|
|
pstSrcRect->s32Xpos = stOpt->stClipRect.s32Xpos;
|
|
pstSrcRect->s32Ypos = stOpt->stClipRect.s32Ypos;
|
|
pstSrcRect->u32Width = stOpt->stClipRect.u32Width;
|
|
pstSrcRect->u32Height = stOpt->stClipRect.u32Height;
|
|
|
|
test_tde_fill_dst(ctx, pstDst, pstDstRect);
|
|
pstDst->pMbBlk = dstBlk;
|
|
|
|
pstDstRect->s32Xpos = ctx->stDstRect.s32X;
|
|
pstDstRect->s32Ypos = ctx->stDstRect.s32Y;
|
|
pstDstRect->u32Width = ctx->stDstRect.u32Width;
|
|
pstDstRect->u32Height = ctx->stDstRect.u32Height;
|
|
} else if (i == 1) {
|
|
// test case : colorkey
|
|
test_tde_fill_src(ctx, pstSrc, pstSrcRect);
|
|
pstSrc->pMbBlk = srcBlk;
|
|
|
|
pstSrcRect->s32Xpos = ctx->stSrcRect.s32X;
|
|
pstSrcRect->s32Ypos = ctx->stSrcRect.s32Y;
|
|
pstSrcRect->u32Width = ctx->stSrcRect.u32Width;
|
|
pstSrcRect->u32Height = ctx->stSrcRect.u32Height;
|
|
|
|
test_tde_fill_dst(ctx, pstDst, pstDstRect);
|
|
pstDst->pMbBlk = dstBlk;
|
|
|
|
pstDstRect->s32Xpos = ctx->stDstRect.s32X;
|
|
pstDstRect->s32Ypos = ctx->stDstRect.s32Y;
|
|
pstDstRect->u32Width = ctx->stDstRect.u32Width;
|
|
pstDstRect->u32Height = ctx->stDstRect.u32Height;
|
|
|
|
stOpt->unColorKeyValue = ctx->s32Color;
|
|
stOpt->u32GlobalAlpha = 0xff;
|
|
}
|
|
return RK_SUCCESS;
|
|
}
|
|
|
|
RK_S32 test_tde_add_all_task(TDE_HANDLE hHandle,
|
|
TDE_RECT_S *pstDstRect,
|
|
TDE_SURFACE_S *pstDst,
|
|
RK_U32 u32ImgSize,
|
|
RK_U32 *pu32TaskIndex,
|
|
MB_BLK srcBlk,
|
|
TEST_TDE_CTX_S *ctx) {
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
RK_U32 u32TaskIndex = *pu32TaskIndex;
|
|
TDE_SURFACE_S pstSrc;
|
|
TDE_RECT_S pstSrcRect;
|
|
|
|
for (RK_S32 i = 0; i < ctx->s32TaskNum; i++) {
|
|
switch (ctx->s32Operation) {
|
|
case TDE_OP_QUICK_COPY: {
|
|
test_tde_quick_copy_task(&pstSrc,
|
|
&pstSrcRect,
|
|
&pstDst[u32TaskIndex],
|
|
&pstDstRect[u32TaskIndex],
|
|
srcBlk, u32ImgSize, ctx);
|
|
s32Ret = RK_TDE_QuickCopy(hHandle, &pstSrc, &pstSrcRect,
|
|
&pstDst[u32TaskIndex], &pstDstRect[u32TaskIndex]);
|
|
} break;
|
|
case TDE_OP_QUICK_RESIZE: {
|
|
test_tde_quick_resize_task(&pstSrc,
|
|
&pstSrcRect,
|
|
&pstDst[u32TaskIndex],
|
|
&pstDstRect[u32TaskIndex],
|
|
srcBlk,
|
|
u32ImgSize,
|
|
ctx);
|
|
s32Ret = RK_TDE_QuickResize(hHandle, &pstSrc, &pstSrcRect,
|
|
&pstDst[u32TaskIndex], &pstDstRect[u32TaskIndex]);
|
|
} break;
|
|
case TDE_OP_QUICK_FILL: {
|
|
test_tde_quick_fill_task(&pstDst[u32TaskIndex],
|
|
&pstDstRect[u32TaskIndex],
|
|
srcBlk,
|
|
u32ImgSize,
|
|
ctx);
|
|
s32Ret = RK_TDE_QuickFill(hHandle, &pstDst[u32TaskIndex], &pstDstRect[u32TaskIndex],
|
|
ctx->s32Color);
|
|
} break;
|
|
case TDE_OP_ROTATION: {
|
|
ROTATION_E enRotateAngle = (ROTATION_E)ctx->s32Rotation;
|
|
test_tde_rotate_task(&pstSrc,
|
|
&pstSrcRect,
|
|
&pstDst[u32TaskIndex],
|
|
&pstDstRect[u32TaskIndex],
|
|
srcBlk, u32ImgSize, ctx);
|
|
s32Ret = RK_TDE_Rotate(hHandle, &pstSrc, &pstSrcRect,
|
|
&pstDst[u32TaskIndex], &pstDstRect[u32TaskIndex],
|
|
(ROTATION_E)ctx->s32Rotation);
|
|
} break;
|
|
case TDE_OP_MIRROR: {
|
|
TDE_OPT_S stOpt;
|
|
memset(&stOpt, 0, sizeof(TDE_OPT_S));
|
|
test_tde_bit_blit_task(&pstSrc,
|
|
&pstSrcRect,
|
|
&pstDst[u32TaskIndex],
|
|
&pstDstRect[u32TaskIndex],
|
|
&stOpt, srcBlk, u32ImgSize, 0, ctx);
|
|
s32Ret = RK_TDE_Bitblit(hHandle,
|
|
&pstDst[u32TaskIndex],
|
|
&pstDstRect[u32TaskIndex],
|
|
&pstSrc,
|
|
&pstSrcRect,
|
|
&pstDst[u32TaskIndex],
|
|
&pstDstRect[u32TaskIndex],
|
|
&stOpt);
|
|
} break;
|
|
case TDE_OP_COLOR_KEY: {
|
|
TDE_OPT_S stOpt;
|
|
memset(&stOpt, 0, sizeof(TDE_OPT_S));
|
|
test_tde_bit_blit_task(&pstSrc,
|
|
&pstSrcRect,
|
|
&pstDst[u32TaskIndex],
|
|
&pstDstRect[u32TaskIndex],
|
|
&stOpt, srcBlk, u32ImgSize, 1, ctx);
|
|
s32Ret = RK_TDE_Bitblit(hHandle,
|
|
&pstDst[u32TaskIndex],
|
|
&pstDstRect[u32TaskIndex],
|
|
&pstSrc,
|
|
&pstSrcRect,
|
|
&pstDst[u32TaskIndex],
|
|
&pstDstRect[u32TaskIndex],
|
|
&stOpt);
|
|
} break;
|
|
default: {
|
|
RK_LOGE("unknown operation type %d", ctx->s32Operation);
|
|
return RK_FAILURE;
|
|
}
|
|
}
|
|
if (s32Ret != RK_SUCCESS) {
|
|
RK_TDE_CancelJob(hHandle);
|
|
return RK_FAILURE;
|
|
}
|
|
u32TaskIndex++;
|
|
}
|
|
|
|
*pu32TaskIndex = u32TaskIndex;
|
|
|
|
return s32Ret;
|
|
}
|
|
|
|
RK_S32 test_tde_all_job(TEST_TDE_CTX_S *ctx) {
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
FILE *file = RK_NULL;
|
|
void *pSrcData = RK_NULL;
|
|
MB_BLK srcBlk = RK_NULL;
|
|
RK_U32 u32SrcSize = 0;
|
|
RK_U32 u32DstSize = 0;
|
|
RK_U32 u32TaskIndex = 0;
|
|
TDE_HANDLE hHandle[TDE_MAX_JOB_NUM] = { 0 };
|
|
TDE_SURFACE_S pstDst[TDE_MAX_TASK_NUM];
|
|
TDE_RECT_S pstDstRect[TDE_MAX_TASK_NUM];
|
|
PIC_BUF_ATTR_S stPicBufAttr;
|
|
MB_PIC_CAL_S stMbPicCalResult;
|
|
u32SrcSize = unit_test_tde_get_size(ctx);
|
|
|
|
stPicBufAttr.u32Width = ctx->stDstSurface.u32Width;
|
|
stPicBufAttr.u32Height = ctx->stDstSurface.u32Height;
|
|
stPicBufAttr.enPixelFormat = ctx->stDstSurface.enColorFmt;
|
|
stPicBufAttr.enCompMode = COMPRESS_MODE_NONE;
|
|
s32Ret = RK_MPI_CAL_TDE_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
|
|
return s32Ret;
|
|
}
|
|
u32DstSize = stMbPicCalResult.u32MBSize;
|
|
|
|
s32Ret = RK_MPI_SYS_MmzAlloc(&srcBlk, RK_NULL, RK_NULL, u32SrcSize);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
return RK_FAILURE;
|
|
}
|
|
pSrcData = RK_MPI_MB_Handle2VirAddr(srcBlk);
|
|
file = test_tde_read_file(ctx->srcFilePath, pSrcData, u32SrcSize, ctx);
|
|
if (!file) {
|
|
return RK_FAILURE;
|
|
} else {
|
|
fclose(file);
|
|
}
|
|
RK_U32 u32HorStride = RK_MPI_CAL_COMM_GetHorStride(ctx->u32SrcVirWidth,
|
|
ctx->stSrcSurface.enColorFmt);
|
|
RK_U32 u32VerStride = ctx->u32SrcVirHeight;
|
|
RK_MPI_MB_SetBufferStride(srcBlk, u32HorStride, u32VerStride);
|
|
for (RK_S32 i = 0; i < ctx->s32JobNum; i++) {
|
|
hHandle[i] = RK_TDE_BeginJob();
|
|
if (RK_ERR_TDE_INVALID_HANDLE == hHandle[i]) {
|
|
RK_LOGE("start job fail");
|
|
return RK_FAILURE;
|
|
}
|
|
|
|
s32Ret = test_tde_add_all_task(hHandle[i], pstDstRect,
|
|
pstDst, u32DstSize,
|
|
&u32TaskIndex, srcBlk, ctx);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
return RK_FAILURE;
|
|
}
|
|
}
|
|
for (RK_S32 i = 0; i < ctx->s32JobNum; i++) {
|
|
RK_U64 start = mpi_test_utils_get_now_us();
|
|
s32Ret = RK_TDE_EndJob(hHandle[i], RK_FALSE, RK_TRUE, 10);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
RK_TDE_CancelJob(hHandle[i]);
|
|
return RK_FAILURE;
|
|
}
|
|
|
|
RK_TDE_WaitForDone(hHandle[i]);
|
|
RK_U64 end = mpi_test_utils_get_now_us();
|
|
if (ctx->bStatEn) {
|
|
RK_LOGI("space time %lld us", end - start);
|
|
}
|
|
|
|
RK_TDE_CancelJob(hHandle[i]);
|
|
}
|
|
// save result
|
|
for (RK_S32 i = 0; i < u32TaskIndex; i++) {
|
|
MB_BLK dstBlk = pstDst[i].pMbBlk;
|
|
if (ctx->dstFilePath) {
|
|
s32Ret = test_tde_save_result(dstBlk, &(pstDst[i]), i, ctx);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
return RK_FAILURE;
|
|
}
|
|
}
|
|
if (dstBlk) {
|
|
RK_MPI_SYS_Free(dstBlk);
|
|
}
|
|
}
|
|
|
|
RK_MPI_SYS_Free(srcBlk);
|
|
return RK_SUCCESS;
|
|
}
|
|
|
|
RK_S32 unit_test_mpi_tde(TEST_TDE_CTX_S *ctx) {
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
|
|
s32Ret = RK_TDE_Open();
|
|
if (s32Ret != RK_SUCCESS) {
|
|
return RK_FAILURE;
|
|
}
|
|
for (RK_S32 i = 0; i < ctx->s32LoopCount; i++) {
|
|
s32Ret = test_tde_all_job(ctx);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
return s32Ret;
|
|
}
|
|
RK_LOGI("Running mpi tde test loop count %d.", i + 1);
|
|
}
|
|
RK_TDE_Close();
|
|
return s32Ret;
|
|
}
|
|
|
|
static const char *const usages[] = {
|
|
"./rk_mpi_tde_test [-i SRC_PATH] [-w SRC_WIDTH] [-h SRC_HEIGHT] [-W DST_WIDTH] [-H DST_HEIGHT]...",
|
|
NULL,
|
|
};
|
|
|
|
static void mpi_tde_test_show_options(const TEST_TDE_CTX_S *ctx) {
|
|
RK_PRINT("cmd parse result: \n");
|
|
RK_PRINT("input file name : %s\n", ctx->srcFilePath);
|
|
RK_PRINT("output file name : %s\n", ctx->dstFilePath);
|
|
RK_PRINT("loop count : %d\n", ctx->s32LoopCount);
|
|
RK_PRINT("job number : %d\n", ctx->s32JobNum);
|
|
RK_PRINT("task number : %d\n", ctx->s32TaskNum);
|
|
RK_PRINT("input width : %d\n", ctx->stSrcSurface.u32Width);
|
|
RK_PRINT("input height : %d\n", ctx->stSrcSurface.u32Height);
|
|
RK_PRINT("input vir width : %d\n", ctx->u32SrcVirWidth);
|
|
RK_PRINT("input vir height : %d\n", ctx->u32SrcVirHeight);
|
|
RK_PRINT("input pixel format : %d\n", ctx->stSrcSurface.enColorFmt);
|
|
RK_PRINT("output width : %d\n", ctx->stDstSurface.u32Width);
|
|
RK_PRINT("output height : %d\n", ctx->stDstSurface.u32Height);
|
|
RK_PRINT("output pixel format : %d\n", ctx->stDstSurface.enColorFmt);
|
|
RK_PRINT("operation type : %d\n", ctx->s32Operation);
|
|
}
|
|
|
|
int main(int argc, const char **argv) {
|
|
TEST_TDE_CTX_S ctx;
|
|
RK_S32 s32Ret = RK_SUCCESS;
|
|
|
|
memset(&ctx, 0, sizeof(TEST_TDE_CTX_S));
|
|
|
|
// set default params.
|
|
ctx.dstFilePath = RK_NULL;
|
|
ctx.s32LoopCount = 1;
|
|
ctx.s32JobNum = 1;
|
|
ctx.s32TaskNum = 1;
|
|
ctx.s32Operation = 0;
|
|
ctx.stSrcSurface.enColorFmt = RK_FMT_YUV420SP;
|
|
ctx.stDstSurface.enColorFmt = RK_FMT_YUV420SP;
|
|
|
|
struct argparse_option options[] = {
|
|
OPT_HELP(),
|
|
OPT_GROUP("basic options:"),
|
|
OPT_STRING('i', "input", &(ctx.srcFilePath),
|
|
"input file name. e.g.(/userdata/1080p.nv12). <required>", NULL, 0, 0),
|
|
OPT_INTEGER('w', "src_width", &(ctx.stSrcSurface.u32Width),
|
|
"src width. e.g.(1920). <required>", NULL, 0, 0),
|
|
OPT_INTEGER('h', "src_height", &(ctx.stSrcSurface.u32Height),
|
|
"src height. e.g.(1080). <required>", NULL, 0, 0),
|
|
OPT_INTEGER('\0', "src_vir_width", &(ctx.u32SrcVirWidth),
|
|
"src vir width. e.g.(1920).", NULL, 0, 0),
|
|
OPT_INTEGER('\0', "src_vir_height", &(ctx.u32SrcVirHeight),
|
|
"src vir height. e.g.(1080).", NULL, 0, 0),
|
|
OPT_INTEGER('W', "dst_width", &(ctx.stDstSurface.u32Width),
|
|
"dst width. e.g.(1920). <required>", NULL, 0, 0),
|
|
OPT_INTEGER('H', "dst_height", &(ctx.stDstSurface.u32Height),
|
|
"dst height. e.g.(1080). <required>", NULL, 0, 0),
|
|
OPT_STRING('o', "output", &(ctx.dstFilePath),
|
|
"output file path. e.g.(/userdata/tde/). default(NULL).", NULL, 0, 0),
|
|
OPT_INTEGER('n', "loop_count", &(ctx.s32LoopCount),
|
|
"loop running count. can be any count. default(1)", NULL, 0, 0),
|
|
OPT_INTEGER('j', "job_number", &(ctx.s32JobNum),
|
|
"the job number of vgs. default(1).", NULL, 0, 0),
|
|
OPT_INTEGER('t', "task_number", &(ctx.s32TaskNum),
|
|
"the task number of one job. default(1).", NULL, 0, 0),
|
|
OPT_INTEGER('f', "src_format", &(ctx.stSrcSurface.enColorFmt),
|
|
"src pixel format. default(0. 0 is NV12).", NULL, 0, 0),
|
|
OPT_INTEGER('F', "dst_format", &(ctx.stDstSurface.enColorFmt),
|
|
"dst pixel format. default(0. 0 is NV12).", NULL, 0, 0),
|
|
OPT_INTEGER('p', "operation", &(ctx.s32Operation),
|
|
"operation type. default(0).\n\t\t\t\t\t0: quick copy.\n\t\t\t\t\t1: quick resize."
|
|
"\n\t\t\t\t\t2: quick fill.\n\t\t\t\t\t3: rotation.\n\t\t\t\t\t4: mirror and flip."
|
|
"\n\t\t\t\t\t5: colorkey.", NULL, 0, 0),
|
|
OPT_INTEGER('\0', "src_rect_x", &(ctx.stSrcRect.s32X),
|
|
"src rect x. default(0).", NULL, 0, 0),
|
|
OPT_INTEGER('\0', "src_rect_y", &(ctx.stSrcRect.s32Y),
|
|
"src rect y. default(0).", NULL, 0, 0),
|
|
OPT_INTEGER('\0', "src_rect_w", &(ctx.stSrcRect.u32Width),
|
|
"src rect width. default(src_width).", NULL, 0, 0),
|
|
OPT_INTEGER('\0', "src_rect_h", &(ctx.stSrcRect.u32Height),
|
|
"src rect height. default(src_height).", NULL, 0, 0),
|
|
OPT_INTEGER('\0', "dst_rect_x", &(ctx.stDstRect.s32X),
|
|
"dst rect x. default(0).", NULL, 0, 0),
|
|
OPT_INTEGER('\0', "dst_rect_y", &(ctx.stDstRect.s32Y),
|
|
"dst rect y. default(0).", NULL, 0, 0),
|
|
OPT_INTEGER('\0', "dst_rect_w", &(ctx.stDstRect.u32Width),
|
|
"dst rect width. default(dst_width).", NULL, 0, 0),
|
|
OPT_INTEGER('\0', "dst_rect_h", &(ctx.stDstRect.u32Height),
|
|
"dst rect height. default(dst_height).", NULL, 0, 0),
|
|
OPT_INTEGER('c', "fill color", &(ctx.s32Color),
|
|
"fill color. default(0).", NULL, 0, 0),
|
|
OPT_INTEGER('r', "rotation", &(ctx.s32Rotation),
|
|
"rotation angle. default(0). 0: 0. 1: 90. 2: 180. 3: 270", NULL, 0, 0),
|
|
OPT_INTEGER('m', "mirror", &(ctx.s32Mirror),
|
|
"mirror or flip. default(0). 0: none. 1: flip. 2: mirror. 3: both", NULL, 0, 0),
|
|
OPT_INTEGER('s', "statistics", &(ctx.bStatEn),
|
|
"statistics open or not.", NULL, 0, 0),
|
|
OPT_END(),
|
|
};
|
|
|
|
struct argparse argparse;
|
|
argparse_init(&argparse, options, usages, 0);
|
|
argparse_describe(&argparse, "\nselect a test case to run.",
|
|
"\nuse --help for details.");
|
|
|
|
argc = argparse_parse(&argparse, argc, argv);
|
|
|
|
if (ctx.stSrcRect.u32Width == 0) {
|
|
ctx.stSrcRect.u32Width = ctx.stSrcSurface.u32Width;
|
|
}
|
|
if (ctx.stSrcRect.u32Height == 0) {
|
|
ctx.stSrcRect.u32Height = ctx.stSrcSurface.u32Height;
|
|
}
|
|
if (ctx.stDstRect.u32Width == 0) {
|
|
ctx.stDstRect.u32Width = ctx.stDstSurface.u32Width;
|
|
}
|
|
if (ctx.stDstRect.u32Height == 0) {
|
|
ctx.stDstRect.u32Height = ctx.stDstSurface.u32Height;
|
|
}
|
|
|
|
mpi_tde_test_show_options(&ctx);
|
|
|
|
if (ctx.srcFilePath == RK_NULL
|
|
|| ctx.stSrcSurface.u32Width <= 0
|
|
|| ctx.stSrcSurface.u32Height <= 0
|
|
|| ctx.stDstSurface.u32Width <= 0
|
|
|| ctx.stDstSurface.u32Height <= 0) {
|
|
argparse_usage(&argparse);
|
|
goto __FAILED;
|
|
}
|
|
|
|
s32Ret = RK_MPI_SYS_Init();
|
|
if (s32Ret != RK_SUCCESS) {
|
|
goto __FAILED;
|
|
}
|
|
|
|
s32Ret = unit_test_mpi_tde(&ctx);
|
|
if (s32Ret != RK_SUCCESS) {
|
|
goto __FAILED;
|
|
}
|
|
|
|
s32Ret = RK_MPI_SYS_Exit();
|
|
if (s32Ret != RK_SUCCESS) {
|
|
goto __FAILED;
|
|
}
|
|
|
|
|
|
RK_LOGI("test running ok!");
|
|
return 0;
|
|
__FAILED:
|
|
RK_LOGI("test runnning failed!");
|
|
return -1;
|
|
}
|
|
|