/*
|
* 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.
|
*
|
*/
|
#undef DBG_MOD_ID
|
#define DBG_MOD_ID RK_ID_VPSS
|
|
#include <stdio.h>
|
#include <string.h>
|
#include <pthread.h>
|
#include <errno.h>
|
|
#include "rk_debug.h"
|
#include "rk_mpi_vpss.h"
|
#include "rk_mpi_mb.h"
|
#include "rk_mpi_sys.h"
|
#include "rk_mpi_cal.h"
|
#include "argparse.h"
|
#include "mpi_test_utils.h"
|
|
typedef struct _rkMpiVPSSCtx {
|
const char *srcFileName;
|
const char *dstFilePath;
|
RK_S32 s32LoopCount;
|
RK_S32 s32GrpNum;
|
RK_S32 s32ChnNum;
|
RK_BOOL bGrpCropEn;
|
RK_BOOL bChnCropEn;
|
RK_S32 s32GrpCropRatio;
|
RK_S32 s32ChnCropRatio;
|
|
RK_S32 s32SrcWidth;
|
RK_S32 s32SrcHeight;
|
RK_S32 s32SrcVirWidth;
|
RK_S32 s32SrcVirHeight;
|
RK_S32 s32SrcCompressMode;
|
RK_S32 s32SrcPixFormat;
|
|
RK_S32 s32DstWidth;
|
RK_S32 s32DstHeight;
|
RK_S32 s32DstCompressMode;
|
RK_S32 s32DstPixFormat;
|
|
RK_S32 s32Rotation;
|
RK_S32 s32RotationEx;
|
|
RK_BOOL bBackupFrame;
|
RK_BOOL bAttachPool;
|
RK_S32 s32ChnMode;
|
|
RK_S32 s32GrpIndex;
|
} TEST_VPSS_CTX_S;
|
|
RK_S32 mpi_vpss_test_create_grp(VPSS_GRP VpssGrp, const TEST_VPSS_CTX_S *ctx) {
|
RK_S32 s32Ret = RK_SUCCESS;
|
VPSS_GRP_ATTR_S stGrpVpssAttr;
|
|
memset(&stGrpVpssAttr, 0, sizeof(VPSS_GRP_ATTR_S));
|
stGrpVpssAttr.u32MaxW = 4096;
|
stGrpVpssAttr.u32MaxH = 4096;
|
stGrpVpssAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
|
stGrpVpssAttr.enCompressMode = (COMPRESS_MODE_E)ctx->s32SrcCompressMode;
|
stGrpVpssAttr.stFrameRate.s32SrcFrameRate = -1;
|
stGrpVpssAttr.stFrameRate.s32DstFrameRate = -1;
|
s32Ret = RK_MPI_VPSS_CreateGrp(VpssGrp, &stGrpVpssAttr);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
|
return s32Ret;
|
}
|
|
RK_S32 mpi_vpss_test_set_grp_crop(VPSS_GRP VpssGrp, const TEST_VPSS_CTX_S *ctx) {
|
RK_S32 s32Ret = RK_SUCCESS;
|
VPSS_CROP_INFO_S stCropInfo;
|
|
memset(&stCropInfo, 0, sizeof(VPSS_CROP_INFO_S));
|
stCropInfo.bEnable = ctx->bGrpCropEn;
|
stCropInfo.enCropCoordinate = VPSS_CROP_RATIO_COOR;
|
stCropInfo.stCropRect.s32X = 500 - ctx->s32GrpCropRatio / 2;
|
stCropInfo.stCropRect.s32Y = 500 - ctx->s32GrpCropRatio / 2;
|
stCropInfo.stCropRect.u32Width = ctx->s32GrpCropRatio;
|
stCropInfo.stCropRect.u32Height = ctx->s32GrpCropRatio;
|
s32Ret = RK_MPI_VPSS_SetGrpCrop(VpssGrp, &stCropInfo);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
s32Ret = RK_MPI_VPSS_GetGrpCrop(VpssGrp, &stCropInfo);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
|
return s32Ret;
|
}
|
|
RK_S32 mpi_vpss_test_chn_set_rotation(
|
VPSS_GRP VpssGrp, VPSS_CHN VpssChn, ROTATION_E enRotation) {
|
RK_S32 s32Ret = RK_SUCCESS;
|
ROTATION_E rotation = ROTATION_0;
|
s32Ret = RK_MPI_VPSS_SetChnRotation(VpssGrp, VpssChn, enRotation);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
s32Ret = RK_MPI_VPSS_GetChnRotation(VpssGrp, VpssChn, &rotation);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
if (rotation != enRotation) {
|
s32Ret = RK_FAILURE;
|
return s32Ret;
|
}
|
|
return s32Ret;
|
}
|
|
RK_S32 mpi_vpss_test_chn_set_rotation_ex(
|
VPSS_GRP VpssGrp, VPSS_CHN VpssChn, RK_S32 rotationEx) {
|
RK_S32 s32Ret = RK_SUCCESS;
|
VPSS_ROTATION_EX_ATTR_S stRotationEx;
|
|
stRotationEx.bEnable = RK_TRUE;
|
stRotationEx.stRotationEx.u32Angle = rotationEx;
|
s32Ret = RK_MPI_VPSS_SetChnRotationEx(VpssGrp, VpssChn, &stRotationEx);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
s32Ret = RK_MPI_VPSS_GetChnRotationEx(VpssGrp, VpssChn, &stRotationEx);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
if (stRotationEx.bEnable != RK_TRUE
|
|| stRotationEx.stRotationEx.u32Angle != rotationEx) {
|
s32Ret = RK_FAILURE;
|
return s32Ret;
|
}
|
|
return s32Ret;
|
}
|
|
RK_S32 mpi_vpss_test_chn_set_crop(
|
VPSS_GRP VpssGrp, VPSS_CHN VpssChn, const TEST_VPSS_CTX_S *ctx) {
|
RK_S32 s32Ret = RK_SUCCESS;
|
VPSS_CROP_INFO_S stChnCropInfo;
|
|
stChnCropInfo.bEnable = ctx->bChnCropEn;
|
stChnCropInfo.enCropCoordinate = VPSS_CROP_RATIO_COOR;
|
stChnCropInfo.stCropRect.s32X = 500 - ctx->s32ChnCropRatio / 2;
|
stChnCropInfo.stCropRect.s32Y = 500 - ctx->s32ChnCropRatio / 2;
|
stChnCropInfo.stCropRect.u32Width = ctx->s32ChnCropRatio;
|
stChnCropInfo.stCropRect.u32Height = ctx->s32ChnCropRatio;
|
s32Ret = RK_MPI_VPSS_SetChnCrop(VpssGrp, VpssChn, &stChnCropInfo);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
s32Ret = RK_MPI_VPSS_GetChnCrop(VpssGrp, VpssChn, &stChnCropInfo);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
|
return s32Ret;
|
}
|
|
RK_S32 mpi_vpss_test_enable_chn(
|
VPSS_GRP VpssGrp, VPSS_CHN VpssChn, const TEST_VPSS_CTX_S *ctx) {
|
RK_S32 s32Ret = RK_SUCCESS;
|
VPSS_CHN_ATTR_S stVpssChnAttr;
|
|
memset(&stVpssChnAttr, 0, sizeof(VPSS_CHN_ATTR_S));
|
stVpssChnAttr.enChnMode = (VPSS_CHN_MODE_E)ctx->s32ChnMode;
|
stVpssChnAttr.enCompressMode = (COMPRESS_MODE_E)ctx->s32DstCompressMode;
|
stVpssChnAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
|
stVpssChnAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
|
stVpssChnAttr.stFrameRate.s32SrcFrameRate = -1;
|
stVpssChnAttr.stFrameRate.s32DstFrameRate = -1;
|
stVpssChnAttr.u32Width = ctx->s32DstWidth;
|
stVpssChnAttr.u32Height = ctx->s32DstHeight;
|
|
s32Ret = RK_MPI_VPSS_SetChnAttr(VpssGrp, VpssChn, &stVpssChnAttr);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
s32Ret = RK_MPI_VPSS_GetChnAttr(VpssGrp, VpssChn, &stVpssChnAttr);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
s32Ret = RK_MPI_VPSS_EnableChn(VpssGrp, VpssChn);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
|
return s32Ret;
|
}
|
|
RK_S32 mpi_vpss_test_write_file(const char *path, MB_BLK blk, RK_S32 size) {
|
FILE *fdW = fopen(path, "wb");
|
if (fdW == RK_NULL) {
|
RK_LOGE("open %s failed, error: %s", path, strerror(errno));
|
return RK_ERR_VPSS_BUSY;
|
}
|
fwrite(RK_MPI_MB_Handle2VirAddr(blk), 1, size, fdW);
|
fflush(fdW);
|
fclose(fdW);
|
|
return RK_SUCCESS;
|
}
|
|
RK_S32 mpi_vpss_test_process(
|
VPSS_GRP VpssGrp, const TEST_VPSS_CTX_S *ctx, MB_BLK blk, RK_S32 size) {
|
RK_S32 s32Ret = RK_SUCCESS;
|
VIDEO_FRAME_INFO_S frameIn = {0};
|
VIDEO_FRAME_INFO_S frameOut = {0};
|
|
frameIn.stVFrame.pMbBlk = blk;
|
frameIn.stVFrame.u32Width = ctx->s32SrcWidth;
|
frameIn.stVFrame.u32Height = ctx->s32SrcHeight;
|
frameIn.stVFrame.u32VirWidth = ctx->s32SrcVirWidth == 0 ? ctx->s32SrcWidth : ctx->s32SrcVirWidth;
|
frameIn.stVFrame.u32VirHeight = ctx->s32SrcVirHeight == 0 ? ctx->s32SrcHeight : ctx->s32SrcVirHeight;
|
frameIn.stVFrame.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
|
frameIn.stVFrame.enCompressMode = (COMPRESS_MODE_E)ctx->s32SrcCompressMode;
|
|
RK_MPI_VPSS_SendFrame(VpssGrp, 0, &frameIn, -1);
|
RK_MPI_MB_ReleaseMB(blk);
|
|
for (RK_S32 i = 0; i < ctx->s32ChnNum; i++) {
|
s32Ret = RK_MPI_VPSS_GetChnFrame(VpssGrp, i, &frameOut, -1);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
RK_LOGI("get chn[%d] frame %p", i, frameOut.stVFrame.pMbBlk);
|
if (ctx->dstFilePath != RK_NULL) {
|
char cWritePath[128] = {0};
|
PIC_BUF_ATTR_S stPicBufAttr;
|
MB_PIC_CAL_S stMbPicCalResult;
|
RK_S32 frameWidth = frameOut.stVFrame.u32VirWidth;
|
RK_S32 frameHeight = frameOut.stVFrame.u32VirHeight;
|
|
stPicBufAttr.u32Width = frameWidth;
|
stPicBufAttr.u32Height = frameHeight;
|
stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
|
stPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32DstCompressMode;
|
s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
|
if (s32Ret != RK_SUCCESS) {
|
RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
|
return s32Ret;
|
}
|
RK_S32 frameLength = stMbPicCalResult.u32MBSize;
|
snprintf(cWritePath, sizeof(cWritePath), "%schn_out_%dx%d_%d_%d.bin",
|
ctx->dstFilePath, frameWidth, frameHeight, VpssGrp, i);
|
s32Ret = mpi_vpss_test_write_file(cWritePath,
|
frameOut.stVFrame.pMbBlk,
|
frameLength);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
}
|
s32Ret = RK_MPI_VPSS_ReleaseChnFrame(VpssGrp, i, &frameOut);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
}
|
if (ctx->bBackupFrame) {
|
frameOut = {0};
|
s32Ret = RK_MPI_VPSS_GetGrpFrame(VpssGrp, 0, &frameOut);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
char cWritePath[128] = {0};
|
PIC_BUF_ATTR_S stPicBufAttr;
|
MB_PIC_CAL_S stMbPicCalResult;
|
|
stPicBufAttr.u32Width = frameOut.stVFrame.u32VirWidth;
|
stPicBufAttr.u32Height = frameOut.stVFrame.u32VirHeight;
|
stPicBufAttr.enCompMode = (COMPRESS_MODE_E)frameOut.stVFrame.enCompressMode;
|
stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)frameOut.stVFrame.enPixelFormat;
|
s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
|
if (s32Ret != RK_SUCCESS) {
|
RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
|
return RK_NULL;
|
}
|
snprintf(cWritePath, sizeof(cWritePath), "%sgrp_out_%dx%d_%d.bin",
|
ctx->dstFilePath, stMbPicCalResult.u32VirWidth, stMbPicCalResult.u32VirHeight, VpssGrp);
|
RK_LOGI("get group[%d] frame %p w %d h %d size %d", VpssGrp,
|
frameOut.stVFrame.pMbBlk, stMbPicCalResult.u32VirWidth,
|
stMbPicCalResult.u32VirHeight, stMbPicCalResult.u32MBSize);
|
s32Ret = mpi_vpss_test_write_file(cWritePath,
|
frameOut.stVFrame.pMbBlk,
|
stMbPicCalResult.u32MBSize);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
s32Ret = RK_MPI_VPSS_ReleaseGrpFrame(VpssGrp, 0, &frameOut);
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
}
|
|
return RK_SUCCESS;
|
}
|
|
static void *test_mpi_vpss_single(void *arg) {
|
RK_S32 s32Ret = RK_SUCCESS;
|
TEST_VPSS_CTX_S *ctx = reinterpret_cast<TEST_VPSS_CTX_S *>(arg);
|
MB_POOL pool = MB_INVALID_POOLID;
|
MB_POOL_CONFIG_S pstMbPoolCfg;
|
FILE *fdR = RK_NULL;
|
MB_BLK srcBlk = MB_INVALID_HANDLE;
|
RK_S32 readLen = 0;
|
PIC_BUF_ATTR_S stPicBufAttr;
|
MB_PIC_CAL_S stMbPicCalResult;
|
|
stPicBufAttr.u32Width = ctx->s32SrcWidth;
|
stPicBufAttr.u32Height = ctx->s32SrcHeight;
|
stPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32SrcCompressMode;
|
stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
|
s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
|
if (s32Ret != RK_SUCCESS) {
|
RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
|
return RK_NULL;
|
}
|
|
memset(&pstMbPoolCfg, 0, sizeof(MB_POOL_CONFIG_S));
|
pstMbPoolCfg.u64MBSize = stMbPicCalResult.u32MBSize;
|
pstMbPoolCfg.u32MBCnt = 10;
|
pstMbPoolCfg.enRemapMode = MB_REMAP_MODE_CACHED;
|
pstMbPoolCfg.bPreAlloc = RK_TRUE;
|
pool = RK_MPI_MB_CreatePool(&pstMbPoolCfg);
|
if (pool == MB_INVALID_POOLID) {
|
RK_LOGE("create pool failed!");
|
s32Ret = RK_FAILURE;
|
goto __FAILED;
|
}
|
|
s32Ret = mpi_vpss_test_create_grp(ctx->s32GrpIndex, ctx);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
s32Ret = RK_MPI_VPSS_ResetGrp(ctx->s32GrpIndex);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
s32Ret = mpi_vpss_test_set_grp_crop(ctx->s32GrpIndex, ctx);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
for (RK_S32 chnIndex = 0; chnIndex < ctx->s32ChnNum; chnIndex++) {
|
s32Ret = mpi_vpss_test_chn_set_crop(ctx->s32GrpIndex, chnIndex, ctx);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
if (ctx->s32Rotation > 0) {
|
s32Ret = mpi_vpss_test_chn_set_rotation(ctx->s32GrpIndex, chnIndex, (ROTATION_E)ctx->s32Rotation);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
}
|
if (ctx->s32RotationEx > 0) {
|
s32Ret = mpi_vpss_test_chn_set_rotation_ex(ctx->s32GrpIndex, chnIndex, ctx->s32RotationEx);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
}
|
s32Ret = mpi_vpss_test_enable_chn(ctx->s32GrpIndex, chnIndex, ctx);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
if (ctx->bAttachPool) {
|
s32Ret = RK_MPI_VPSS_AttachMbPool(ctx->s32GrpIndex, chnIndex, pool);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
}
|
}
|
s32Ret = RK_MPI_VPSS_StartGrp(ctx->s32GrpIndex);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
if (ctx->bBackupFrame) {
|
s32Ret = RK_MPI_VPSS_EnableBackupFrame(ctx->s32GrpIndex);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
}
|
|
for (RK_S32 loopCount = 0; loopCount < ctx->s32LoopCount; loopCount++) {
|
fdR = fopen(ctx->srcFileName, "rb");
|
if (fdR == RK_NULL) {
|
RK_LOGE("open %s failed, error: %s", ctx->srcFileName, strerror(errno));
|
s32Ret = RK_FAILURE;
|
goto __FAILED;
|
}
|
srcBlk = RK_MPI_MB_GetMB(pool, pstMbPoolCfg.u64MBSize, RK_TRUE);
|
readLen = fread(RK_MPI_MB_Handle2VirAddr(srcBlk), 1, pstMbPoolCfg.u64MBSize, fdR);
|
if (readLen == 0) {
|
RK_LOGE("read failed! request %d", pstMbPoolCfg.u64MBSize);
|
s32Ret = RK_FAILURE;
|
goto __FAILED;
|
}
|
s32Ret = mpi_vpss_test_process(ctx->s32GrpIndex, ctx, srcBlk, pstMbPoolCfg.u64MBSize);
|
if (s32Ret != RK_SUCCESS) {
|
RK_LOGE("test process failed.");
|
goto __FAILED;
|
}
|
if (fdR != RK_NULL) {
|
fclose(fdR);
|
}
|
}
|
|
for (RK_S32 i = 0; i < ctx->s32ChnNum; i++) {
|
if (ctx->bAttachPool) {
|
s32Ret = RK_MPI_VPSS_DetachMbPool(ctx->s32GrpIndex, i);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
}
|
s32Ret = RK_MPI_VPSS_DisableChn(ctx->s32GrpIndex, i);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
}
|
|
s32Ret = RK_MPI_VPSS_StopGrp(ctx->s32GrpIndex);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
s32Ret = RK_MPI_VPSS_DestroyGrp(ctx->s32GrpIndex);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
s32Ret = RK_MPI_MB_DestroyPool(pool);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
|
return arg;
|
__FAILED:
|
if (fdR != RK_NULL) {
|
fclose(fdR);
|
}
|
RK_LOGE("single vpss test %d running failed.", ctx->s32GrpIndex);
|
return RK_NULL;
|
}
|
|
RK_S32 unit_test_mpi_vpss(TEST_VPSS_CTX_S *ctx) {
|
RK_S32 s32Ret = RK_SUCCESS;
|
pthread_t tids[VPSS_MAX_GRP_NUM];
|
TEST_VPSS_CTX_S tmpCtx[VPSS_MAX_GRP_NUM];
|
|
for (RK_S32 grpIndex = 0; grpIndex < ctx->s32GrpNum; grpIndex++) {
|
memcpy(&(tmpCtx[grpIndex]), ctx, sizeof(TEST_VPSS_CTX_S));
|
pthread_create(&tids[grpIndex], 0, test_mpi_vpss_single, reinterpret_cast<void *>(&tmpCtx[grpIndex]));
|
ctx->s32GrpIndex++;
|
}
|
|
for (RK_S32 grpIndex = 0; grpIndex < ctx->s32GrpNum; grpIndex++) {
|
void *retval = RK_NULL;
|
pthread_join(tids[grpIndex], &retval);
|
if (retval == RK_NULL) {
|
RK_LOGE("Has error test.");
|
s32Ret = RK_FAILURE;
|
}
|
}
|
|
return s32Ret;
|
}
|
|
static const char *const usages[] = {
|
"./rk_mpi_vpss_test [-i SRC_PATH] [-w SRC_WIDTH] [-h SRC_HEIGHT] [-W DST_WIDTH] [-H DST_HEIGHT]...",
|
NULL,
|
};
|
|
static void mpi_vpss_test_show_options(const TEST_VPSS_CTX_S *ctx) {
|
RK_PRINT("cmd parse result:\n");
|
RK_PRINT("input file name : %s\n", ctx->srcFileName);
|
RK_PRINT("output file name : %s\n", ctx->dstFilePath);
|
RK_PRINT("loop count : %d\n", ctx->s32LoopCount);
|
RK_PRINT("group number : %d\n", ctx->s32GrpNum);
|
RK_PRINT("channel number : %d\n", ctx->s32ChnNum);
|
RK_PRINT("group crop enabled : %d\n", ctx->bGrpCropEn ? 1 : 0);
|
RK_PRINT("chn crop enabled : %d\n", ctx->bChnCropEn ? 1 : 0);
|
RK_PRINT("group crop ratio : %d\n", ctx->s32GrpCropRatio);
|
RK_PRINT("chn crop ratio : %d\n", ctx->s32ChnCropRatio);
|
RK_PRINT("input width : %d\n", ctx->s32SrcWidth);
|
RK_PRINT("input height : %d\n", ctx->s32SrcHeight);
|
RK_PRINT("input virtual width : %d\n", ctx->s32SrcVirWidth);
|
RK_PRINT("input virtual height : %d\n", ctx->s32SrcVirHeight);
|
RK_PRINT("input compress mode : %d\n", ctx->s32SrcCompressMode);
|
RK_PRINT("input pixel format : %d\n", ctx->s32SrcPixFormat);
|
RK_PRINT("output width : %d\n", ctx->s32DstWidth);
|
RK_PRINT("output height : %d\n", ctx->s32DstHeight);
|
RK_PRINT("output compress mode : %d\n", ctx->s32DstCompressMode);
|
RK_PRINT("output pixel format : %d\n", ctx->s32DstPixFormat);
|
RK_PRINT("fixed rotation : %d\n", ctx->s32Rotation);
|
RK_PRINT("any rotation angle : %d\n", ctx->s32RotationEx);
|
RK_PRINT("enable backup frame : %d\n", ctx->bBackupFrame);
|
RK_PRINT("enable attach mb pool : %d\n", ctx->bAttachPool);
|
}
|
|
RK_S32 main(int argc, const char **argv) {
|
RK_S32 s32Ret;
|
TEST_VPSS_CTX_S ctx;
|
|
memset(&ctx, 0, sizeof(TEST_VPSS_CTX_S));
|
|
// set default params.
|
ctx.dstFilePath = RK_NULL;
|
ctx.s32LoopCount = 1;
|
ctx.s32GrpNum = 1;
|
ctx.s32ChnNum = 1;
|
ctx.bGrpCropEn = RK_FALSE;
|
ctx.bChnCropEn = RK_FALSE;
|
ctx.s32GrpCropRatio = 1000;
|
ctx.s32ChnCropRatio = 1000;
|
ctx.s32SrcCompressMode = 0;
|
ctx.s32SrcPixFormat = RK_FMT_YUV420SP;
|
ctx.s32DstCompressMode = 0;
|
ctx.s32DstPixFormat = RK_FMT_YUV420SP;
|
ctx.s32GrpIndex = 0;
|
|
struct argparse_option options[] = {
|
OPT_HELP(),
|
OPT_GROUP("basic options:"),
|
OPT_STRING('i', "input", &(ctx.srcFileName),
|
"input file name. e.g.(/userdata/1080p.nv12). <required>", NULL, 0, 0),
|
OPT_STRING('o', "output", &(ctx.dstFilePath),
|
"output file path. e.g.(/userdata/vpss/). default(NULL).", NULL, 0, 0),
|
OPT_INTEGER('n', "loop_count", &(ctx.s32LoopCount),
|
"loop running count. default(1)", NULL, 0, 0),
|
OPT_INTEGER('g', "group_count", &(ctx.s32GrpNum),
|
"the count of vpss group. default(1).", NULL, 0, 0),
|
OPT_INTEGER('c', "channel_count", &(ctx.s32ChnNum),
|
"the count of vpss channel. default(1).", NULL, 0, 0),
|
OPT_BOOLEAN('\0', "group_crop_en", &(ctx.bGrpCropEn),
|
"vpss group crop is enabled. default(0).", NULL, 0, 0),
|
OPT_BOOLEAN('\0', "channel_crop_en", &(ctx.bChnCropEn),
|
"vpss channel crop is enabled. default(0)", NULL, 0, 0),
|
OPT_INTEGER('\0', "group_crop_ratio", &(ctx.s32GrpCropRatio),
|
"vpss group crop ratio. range(1,1000). default(1000)", NULL, 0, 0),
|
OPT_INTEGER('\0', "channel_crop_ratio", &(ctx.s32ChnCropRatio),
|
"vpss channel crop ratio. range(1,1000). default(1000)", NULL, 0, 0),
|
OPT_INTEGER('w', "src_width", &(ctx.s32SrcWidth),
|
"src width. e.g.(1920). <required>", NULL, 0, 0),
|
OPT_INTEGER('h', "src_height", &(ctx.s32SrcHeight),
|
"src height. e.g.(1080). <required>", NULL, 0, 0),
|
OPT_INTEGER('\0', "src_vir_width", &(ctx.s32SrcVirWidth),
|
"src virtual width. e.g.(1920). default(0)", NULL, 0, 0),
|
OPT_INTEGER('\0', "src_vir_height", &(ctx.s32SrcVirHeight),
|
"src virtual height. e.g.(1080). default(0)", NULL, 0, 0),
|
OPT_INTEGER('m', "src_compress", &(ctx.s32SrcCompressMode),
|
"src compress mode. default(0).", NULL, 0, 0),
|
OPT_INTEGER('f', "src_format", &(ctx.s32SrcPixFormat),
|
"src pixel format. default(0. 0 is NV12).", NULL, 0, 0),
|
OPT_INTEGER('W', "dst_width", &(ctx.s32DstWidth),
|
"dst width. e.g.(1920). <required>", NULL, 0, 0),
|
OPT_INTEGER('H', "dst_height", &(ctx.s32DstHeight),
|
"dst height. e.g.(1080). <required>", NULL, 0, 0),
|
OPT_INTEGER('M', "dst_compress", &(ctx.s32DstCompressMode),
|
"dst compress mode. default(0).", NULL, 0, 0),
|
OPT_INTEGER('F', "dst_format", &(ctx.s32DstPixFormat),
|
"dst pixel format. default(0. 0 is NV12).", NULL, 0, 0),
|
OPT_INTEGER('r', "rotation", &(ctx.s32Rotation),
|
"fixed rotation angle. default(0). 0: 0. 1: 90. 2: 180. 3: 270", NULL, 0, 0),
|
OPT_INTEGER('R', "rotation_ex", &(ctx.s32RotationEx),
|
"any rotation angle. default(0). ", NULL, 0, 0),
|
OPT_INTEGER('b', "backup_frame", &(ctx.bBackupFrame),
|
"enable backup frame or not, default(0), 0: RK_FALSE, 1: RK_TRUE", NULL, 0, 0),
|
OPT_INTEGER('a', "attach_mb_pool", &(ctx.bAttachPool),
|
"enable attach mb pool or not, default(0), 0: RK_FALSE, 1: RK_TRUE", NULL, 0, 0),
|
OPT_INTEGER('\0', "chn_mode", &(ctx.s32ChnMode),
|
"channel mode, default(0), 0: USER, 1: AUTO, 2: PASS-THOUGH", 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);
|
mpi_vpss_test_show_options(&ctx);
|
|
if (ctx.srcFileName == RK_NULL
|
|| ctx.s32SrcWidth <= 0
|
|| ctx.s32SrcHeight <= 0
|
|| ctx.s32DstWidth <= 0
|
|| ctx.s32DstHeight <= 0) {
|
argparse_usage(&argparse);
|
return RK_FAILURE;
|
}
|
|
s32Ret = RK_MPI_SYS_Init();
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
|
s32Ret = unit_test_mpi_vpss(&ctx);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
|
s32Ret = RK_MPI_SYS_Exit();
|
if (s32Ret != RK_SUCCESS) {
|
return s32Ret;
|
}
|
RK_LOGI("test running ok.");
|
return RK_SUCCESS;
|
|
__FAILED:
|
RK_MPI_SYS_Exit();
|
RK_LOGE("test running failed!");
|
return s32Ret;
|
}
|
