925 lines
26 KiB
C
Executable File
925 lines
26 KiB
C
Executable File
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/poll.h>
|
|
#include <sys/time.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <pthread.h>
|
|
#include <math.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <sys/time.h>
|
|
#include <time.h>
|
|
#include <dirent.h>
|
|
#include <limits.h>
|
|
#include <getopt.h>
|
|
#include <sys/prctl.h>
|
|
|
|
#include "fh_common.h"
|
|
#include "fh_system_mpi.h"
|
|
#include "fh_vb_mpi.h"
|
|
#include "fh_tde_mpi.h"
|
|
#include "fh_defines.h"
|
|
#include "vmm_api.h"
|
|
#include "fh_jpege_mpi.h"
|
|
#include "fh_vpu_mpi.h"
|
|
#include "sample_comm.h"
|
|
#include "maxlod_cfg.h"
|
|
|
|
|
|
#define MAXLOAD_CHECK_GOTO(cond, label, msg, ...) \
|
|
if(cond) { \
|
|
printf("[Func]:%s [Line]:%d: " msg "\n", __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
|
goto label; \
|
|
}
|
|
|
|
#ifdef MAXLOD_STEP_RUN
|
|
#define MAXLOAD_GETCHAR() getchar()
|
|
#else
|
|
#define MAXLOAD_GETCHAR()
|
|
#endif
|
|
|
|
FH_BOOL maxlod_running = FH_TRUE;
|
|
FH_UINT32 uifps = 0;
|
|
FH_UINT32 g2dfps = 0;
|
|
FH_UINT32 jpgfps = 0;
|
|
FH_UINT32 nnpfps = 0;
|
|
FH_UINT32 vdspfps = 0;
|
|
FH_UINT32 vdecfps = 0;
|
|
FH_UINT32 vencfps0 = 0;
|
|
FH_UINT32 vencfps1 = 0;
|
|
float total = 0;
|
|
float ddrEff[3] = {0};
|
|
float ddrEffAvg = 0;
|
|
|
|
#ifdef MAXLOD_JPEGE_TEST
|
|
typedef struct
|
|
{
|
|
FH_UINT32 u32JpgWidth;
|
|
FH_UINT32 u32JpgHeight;
|
|
char filename[128];
|
|
}PTHREAD_JPEG_INFO;
|
|
|
|
static int jpegeNum = 0;
|
|
|
|
#if 0
|
|
static void* maxlod_thread_jpgGet(void* p)
|
|
{
|
|
int ret = 0;
|
|
JPEGE_STREAM_S stVecStream;
|
|
FH_UINT64 u64BeginTime = 0;
|
|
FH_UINT64 u64DuringTime = 0;
|
|
|
|
prctl(PR_SET_NAME, "jpgGet");
|
|
FH_SYS_GetCurPts(&u64BeginTime);
|
|
|
|
while(maxlod_running)
|
|
{
|
|
stVecStream.s32MilliSec = 500;
|
|
ret = FH_JPEGE_GetStream(0, &stVecStream);
|
|
if(ret){
|
|
//printf("FH_JPEGE_GetStream(0) failed!\n");
|
|
continue;
|
|
}
|
|
jpegeNum++;
|
|
/*
|
|
if(jpegeNum==1){
|
|
FILE *pOutFile;
|
|
pOutFile = fopen(MAXLOD_OUTJPG_NAME, "w+");
|
|
if (!pOutFile){
|
|
//printf("[MAXLOADING] open file %s failed!\n", MAXLOD_OUTJPG_NAME);
|
|
}else{
|
|
fwrite(stVecStream.pu8Addr, stVecStream.u32Len, 1, pOutFile);
|
|
fclose(pOutFile);
|
|
}
|
|
}
|
|
*/
|
|
FH_SYS_GetCurPts(&u64DuringTime);
|
|
u64DuringTime = u64DuringTime - u64BeginTime;
|
|
jpgfps = jpegeNum * 1000 * 1000 / (double)u64DuringTime;
|
|
if(jpegeNum % 500 == 0){
|
|
printf("\n------jpeg frameCnt:%d CostTime:%lld fps:%f---\n", jpegeNum, u64DuringTime, jpegeNum * 1000 * 1000 / (double)u64DuringTime);
|
|
FH_SYS_GetCurPts(&u64BeginTime);
|
|
jpegeNum = 0;
|
|
}
|
|
|
|
FH_JPEGE_ReleaseStream(0, &stVecStream);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
static void* maxlod_thread_jpege(void* p)
|
|
{
|
|
int ret = 0, jWidth, jHeight;
|
|
JPEGE_CHN_ATTR_S stJpegAttr;
|
|
VIDEO_FRAME_INFO_S stFrameInfo;
|
|
PTHREAD_JPEG_INFO *pstJpegInfo = (PTHREAD_JPEG_INFO *)p;
|
|
FH_UINT32 phyAddrSrc;
|
|
FH_VOID *pVirAddrSrc = NULL;
|
|
|
|
prctl(PR_SET_NAME, "jpege_snap");
|
|
/*
|
|
pfd = fopen(MAXLOD_JPEGE_FILE,"rb");
|
|
if(pfd == NULL)
|
|
{
|
|
printf("[MAXLOADING] open %s failed!\n", MAXLOD_JPEGE_FILE);
|
|
}
|
|
*/
|
|
jWidth = pstJpegInfo->u32JpgWidth;
|
|
jHeight = pstJpegInfo->u32JpgHeight;
|
|
|
|
//phyAddrSrc = 0x41000000;
|
|
FH_SYS_VmmAlloc(&phyAddrSrc, &pVirAddrSrc, "jpege_snap", NULL, jWidth * jHeight * 3 / 2);
|
|
|
|
//ret = fread(pVirAddrSrc, 1, jWidth * jHeight * 3 / 2, pfd);
|
|
//printf("[MAXLOADING] read jpeg src len:%d\n", ret);
|
|
//fclose(pfd);
|
|
|
|
stFrameInfo.u32PoolId = -1;
|
|
stFrameInfo.stVFrame.u32Width = jWidth;
|
|
stFrameInfo.stVFrame.u32Height = jHeight;
|
|
stFrameInfo.stVFrame.u32Stride[0] = jWidth;
|
|
stFrameInfo.stVFrame.u32Stride[1] = jWidth;
|
|
stFrameInfo.stVFrame.u32PhyAddr[0] = phyAddrSrc;
|
|
stFrameInfo.stVFrame.u32PhyAddr[1] = phyAddrSrc + jWidth*jHeight;
|
|
stFrameInfo.stVFrame.enPixelFormat = PIXEL_FMT_YUV_SEMIPLANAR_420;
|
|
stFrameInfo.stVFrame.enCompressMode = COMPRESS_MODE_NONE;
|
|
|
|
stJpegAttr.u32MaxPicWidth = jWidth;
|
|
stJpegAttr.u32MaxPicHeight = jHeight;
|
|
stJpegAttr.u32PicWidth = jWidth;
|
|
stJpegAttr.u32PicHeight = jHeight;
|
|
stJpegAttr.u32BufSize = jWidth* jHeight;
|
|
|
|
ret = FH_JPEGE_CreateChn(0, &stJpegAttr);
|
|
if(ret){
|
|
printf("FH_JPEGE_CreateChn(0) faild, ret: %x\n",ret);
|
|
return NULL;
|
|
}
|
|
FH_JPEGE_StartRecvPic(0);
|
|
|
|
#if 0
|
|
pthread_t pjJpege_snap;
|
|
//pthread_attr_t thrAttr;
|
|
//struct sched_param thrParam;
|
|
//pthread_attr_init(&thrAttr);
|
|
//thrParam.sched_priority = 90; //1~99
|
|
//pthread_attr_setschedparam(&thrAttr, &thrParam);
|
|
//pthread_attr_setschedpolicy(&thrAttr, SCHED_RR);
|
|
ret = pthread_create(&pjJpege_snap, 0, maxlod_thread_jpgGet, "jpege_snap");
|
|
if(ret != FH_SUCCESS)
|
|
{
|
|
printf("[MAXLOADING]======create thread jpege_snap failed======\n");
|
|
return NULL;
|
|
}else{
|
|
printf("[MAXLOADING]======create thread jpege_snap ok======\n");
|
|
}
|
|
#endif
|
|
|
|
JPEGE_STREAM_S stVecStream;
|
|
FH_UINT64 u64BeginTime = 0;
|
|
FH_UINT64 u64DuringTime = 0;
|
|
|
|
while(maxlod_running)
|
|
{
|
|
ret = FH_JPEGE_SendFrame(0,&stFrameInfo,0);
|
|
if(ret){
|
|
//printf("FH_JPEGE_SendFrame(0) failed! %d\n", stFrameInfo.u32PoolId);
|
|
continue;
|
|
}
|
|
|
|
stVecStream.s32MilliSec = 1000;
|
|
ret = FH_JPEGE_GetStream(0, &stVecStream);
|
|
if(ret){
|
|
//printf("FH_JPEGE_GetStream(0) failed!\n");
|
|
continue;
|
|
}
|
|
jpegeNum++;
|
|
|
|
FH_SYS_GetCurPts(&u64DuringTime);
|
|
u64DuringTime = u64DuringTime - u64BeginTime;
|
|
jpgfps = jpegeNum * 1000 * 1000 / (double)u64DuringTime;
|
|
if(jpegeNum % 500 == 0){
|
|
printf("\n------jpeg frameCnt:%d CostTime:%lld fps:%f---\n", jpegeNum, u64DuringTime, jpegeNum * 1000 * 1000 / (double)u64DuringTime);
|
|
FH_SYS_GetCurPts(&u64BeginTime);
|
|
jpegeNum = 0;
|
|
}
|
|
|
|
FH_JPEGE_ReleaseStream(0, &stVecStream);
|
|
|
|
#if defined(MAXLOD_TYPE_4M30_SLOCK)
|
|
usleep(20 * 1000);
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_2M30_FACEMOD)
|
|
usleep(30 * 1000);
|
|
#endif
|
|
}
|
|
FH_SYS_VmmFree(phyAddrSrc);
|
|
FH_JPEGE_StopRecvPic(0);
|
|
FH_JPEGE_DestroyChn(0);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PTHREAD_JPEG_INFO stJpegInfo;
|
|
FH_SINT32 maxlod_jpege_start()
|
|
{
|
|
int ret;
|
|
pthread_t pJpege;
|
|
stJpegInfo.u32JpgWidth = MAXLOD_JPEGE_WIDTH;
|
|
stJpegInfo.u32JpgHeight = MAXLOD_JPEGE_HEIGHT;
|
|
|
|
ret = pthread_create(&pJpege, 0, maxlod_thread_jpege, &stJpegInfo);
|
|
if(ret != FH_SUCCESS)
|
|
{
|
|
printf("[MAXLOADING]======create thread jpege failed======\n");
|
|
return ret;
|
|
}else{
|
|
printf("[MAXLOADING]======create thread jpege %dx%d ok======\n", stJpegInfo.u32JpgWidth, stJpegInfo.u32JpgHeight);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifdef MAXLOD_MEMCOPY_TEST
|
|
static void* maxlod_thread_memcpy(void* p)
|
|
{
|
|
FH_VOID *pVirAddrSrc = NULL, *pVirAddrDst = NULL;
|
|
FH_UINT32 phyAddrSrc, phyAddrDst;
|
|
|
|
prctl(PR_SET_NAME, "memcpy");
|
|
|
|
FH_SYS_VmmAlloc(&phyAddrSrc, &pVirAddrSrc, "memcpy_src", NULL, 128*1024);
|
|
FH_SYS_VmmAlloc(&phyAddrDst, &pVirAddrDst, "memcpy_dst", NULL, 128*1024);
|
|
|
|
while(maxlod_running)
|
|
{
|
|
memcpy(pVirAddrDst, pVirAddrSrc, 128*1024);
|
|
//usleep(1 * 1000);
|
|
}
|
|
|
|
FH_SYS_VmmFree(phyAddrSrc);
|
|
FH_SYS_VmmFree(phyAddrDst);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
FH_SINT32 maxlod_memcpy_start()
|
|
{
|
|
int ret;
|
|
|
|
pthread_t pMemcpy;
|
|
ret = pthread_create(&pMemcpy, 0, maxlod_thread_memcpy, "memcpy");
|
|
if(ret != FH_SUCCESS)
|
|
{
|
|
printf("[MAXLOADING]======create thread memcpy failed======\n");
|
|
return ret;
|
|
}else{
|
|
printf("[MAXLOADING]======create thread memcpy ok======\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef MAXLOD_ADD_LOAD
|
|
|
|
#define MAXLOD_TDE_WIDTH 1920
|
|
#define MAXLOD_TDE_HEIGHT 1080
|
|
#define MAXLOD_TDE_FILE "res/lab_sp420_1920x1080.yuv"
|
|
|
|
static void* maxlod_tde_performace(void* p)
|
|
{
|
|
FH_SINT32 ret = 0;
|
|
FH_UINT32 cnt = 0;
|
|
TDE_HANDLE s32Handle;
|
|
TDE2_SURFACE_S stSrc;
|
|
TDE2_RECT_S stSrcRect;
|
|
TDE2_SURFACE_S stDst;
|
|
TDE2_RECT_S stDstRect;
|
|
FH_UINT64 u64BeginTime = 0;
|
|
FH_UINT64 u64DuringTime = 0;
|
|
struct timeval tv;
|
|
|
|
int picWidthSrc = MAXLOD_TDE_WIDTH;
|
|
int picHeightSrc = MAXLOD_TDE_HEIGHT;
|
|
int picWidthDst = MAXLOD_TDE_WIDTH;
|
|
int picHeightDst = MAXLOD_TDE_HEIGHT;
|
|
TDE2_COLOR_FMT_E colorFormat = TDE2_COLOR_FMT_ARGB1555;
|
|
int byteStep = 2;
|
|
|
|
FH_UINT32 phyAddr, phyAddrOut;
|
|
FH_VOID *pVirAddr = NULL;
|
|
FH_VOID *pvirAddrOut = NULL;
|
|
FILE *pfd;
|
|
|
|
FH_SYS_VmmAlloc(&phyAddr, &pVirAddr, "g2d_src", NULL, picWidthSrc * picHeightSrc * byteStep);
|
|
FH_SYS_VmmAlloc(&phyAddrOut, &pvirAddrOut, "g2d_dst", NULL, picWidthDst * picHeightDst * byteStep);
|
|
|
|
pfd = fopen(MAXLOD_TDE_FILE,"rb");
|
|
if(pfd == NULL)
|
|
{
|
|
printf("open %s or fail!\n", MAXLOD_TDE_FILE);
|
|
goto out;
|
|
}
|
|
|
|
ret = FH_TDE2_Open();
|
|
|
|
/* resize param start */
|
|
stSrc.enColorFmt = colorFormat;
|
|
stSrc.u32Width = picWidthSrc;
|
|
stSrc.u32Height = picHeightSrc;
|
|
stSrc.u32Stride = picWidthSrc * byteStep;
|
|
stSrc.u32PhyAddr = phyAddr;
|
|
stSrc.bAlphaMax255 = 1;
|
|
stSrc.bAlphaExt1555 = 0;
|
|
stSrc.u8Alpha0 = 0;
|
|
stSrc.u8Alpha1 = 255;
|
|
stSrcRect.s32Xpos = 0;
|
|
stSrcRect.s32Ypos = 0;
|
|
stSrcRect.u32Width = picWidthSrc;
|
|
stSrcRect.u32Height = picHeightSrc;
|
|
|
|
stDst.enColorFmt = colorFormat;
|
|
stDst.u32Width = picWidthDst;
|
|
stDst.u32Height = picHeightDst;
|
|
stDst.u32Stride = picWidthDst * byteStep;
|
|
stDst.u32PhyAddr = phyAddrOut;
|
|
stDst.bAlphaMax255 = 1;
|
|
stDst.bAlphaExt1555 = 0;
|
|
stDst.u8Alpha0 = 0;
|
|
stDst.u8Alpha1 = 255;
|
|
stDstRect.s32Xpos = 0;
|
|
stDstRect.s32Ypos = 0;
|
|
stDstRect.u32Width = picWidthDst;
|
|
stDstRect.u32Height = picHeightDst;
|
|
/* resize_param end */
|
|
|
|
ret = fread(pVirAddr, 1, picWidthSrc * picHeightSrc * byteStep, pfd);
|
|
printf("file read done readLen:%d\n", ret);
|
|
memset(pvirAddrOut, 0 , picWidthDst * picHeightDst * byteStep);
|
|
|
|
gettimeofday(&tv, NULL);
|
|
u64BeginTime = (tv.tv_sec) * 1000 * 1000 + tv.tv_usec ;
|
|
|
|
while(maxlod_running)
|
|
{
|
|
s32Handle = FH_TDE2_BeginJob();
|
|
|
|
ret = FH_TDE2_QuickResize(s32Handle, &stSrc, &stSrcRect, &stDst, &stDstRect);
|
|
if (ret)
|
|
{
|
|
printf("FH_TDE2_QuickResize failed! ret:0x%x(%d)\n",ret,ret);
|
|
goto exit;
|
|
}
|
|
|
|
ret = FH_TDE2_EndJob(s32Handle, FH_TRUE, FH_TRUE, 500);
|
|
if (ret)
|
|
{
|
|
printf("FH_TDE2_EndJob failed! ret:0x%x(%d)\n",ret,ret);
|
|
goto exit;
|
|
}
|
|
cnt++;
|
|
usleep(10*1000);
|
|
}
|
|
|
|
gettimeofday(&tv, NULL);
|
|
u64DuringTime = (tv.tv_sec) * 1000 * 1000 + tv.tv_usec ;
|
|
u64DuringTime = u64DuringTime - u64BeginTime;
|
|
g2dfps = cnt * 1000 * 1000 / (double)u64DuringTime;
|
|
//printf("\n-----------------------------------------\n");
|
|
//printf("------frameCnt:%d CostTime:%lld fps:%f---\n", cnt, u64DuringTime, cnt * 1000 * 1000 / (double)u64DuringTime);
|
|
//printf("-----------------------------------------\n\n");
|
|
|
|
//printf("--------TDE performace test done--------\n");
|
|
|
|
exit:
|
|
FH_SYS_VmmFree(phyAddr);
|
|
FH_SYS_VmmFree(phyAddrOut);
|
|
FH_TDE2_Close();
|
|
out:
|
|
fclose(pfd);
|
|
return NULL;
|
|
}
|
|
|
|
#if 0
|
|
#define MAXLOD_VGS_WIDTH 480
|
|
#define MAXLOD_VGS_HEIGHT 270
|
|
#define MAXLOD_VGS_WIDTH_O 2560
|
|
#define MAXLOD_VGS_HEIGHT_O 1440
|
|
#define MAXLOD_VGS_FILE "res/lab_sp420_1920x1080.yuv"
|
|
|
|
static void* maxlod_vgs_performace(void* p)
|
|
{
|
|
FH_SINT32 ret = 0;
|
|
FH_UINT32 cnt = 0;
|
|
VGS_HANDLE VgsHandle;
|
|
VGS_TASK_ATTR_S stVgsTask;
|
|
FH_UINT32 phyAddr;
|
|
FH_UINT32 phyAddrOut;
|
|
FH_VOID *pVirAddr = NULL;
|
|
FH_VOID *pvirAddrOut = NULL;
|
|
FILE *pfd;
|
|
FH_UINT64 u64BeginTime = 0;
|
|
FH_UINT64 u64DuringTime = 0;
|
|
struct timeval tv;
|
|
|
|
int picWidSrc = MAXLOD_VGS_WIDTH;
|
|
int picHgtSrc = MAXLOD_VGS_HEIGHT;
|
|
int picWidDst = MAXLOD_VGS_WIDTH;
|
|
int picHgtDst = MAXLOD_VGS_HEIGHT;
|
|
PIXEL_FMT_E colorFmt = PIXEL_FMT_YUV_SEMIPLANAR_420;
|
|
int step = 3;
|
|
|
|
FH_SYS_VmmAlloc(&phyAddr, &pVirAddr, "vppu_src", NULL, picWidSrc * picHgtSrc * step / 2);
|
|
FH_SYS_VmmAlloc(&phyAddrOut, &pvirAddrOut, "vppu_dst", NULL, picWidDst * picHgtDst * step / 2);
|
|
|
|
pfd = fopen(MAXLOD_VGS_FILE,"rb");
|
|
if(pfd == NULL)
|
|
{
|
|
printf("open %s fail!\n", MAXLOD_VGS_FILE);
|
|
goto out;
|
|
}
|
|
|
|
memset(&stVgsTask, 0 ,sizeof(stVgsTask));
|
|
stVgsTask.stImgIn.stVFrame.u32Width = picWidSrc;
|
|
stVgsTask.stImgIn.stVFrame.u32Height = picHgtSrc;
|
|
stVgsTask.stImgIn.stVFrame.enPixelFormat = colorFmt;
|
|
stVgsTask.stImgIn.stVFrame.enVideoFormat = VIDEO_FORMAT_LINEAR;
|
|
stVgsTask.stImgIn.stVFrame.u32PhyAddr[0] = phyAddr;
|
|
stVgsTask.stImgIn.stVFrame.u32PhyAddr[1] = phyAddr + picWidSrc * picHgtSrc;
|
|
stVgsTask.stImgIn.stVFrame.u32Stride[0] = picWidSrc;
|
|
stVgsTask.stImgIn.stVFrame.enCompressMode = COMPRESS_MODE_NONE;
|
|
|
|
stVgsTask.stImgOut.stVFrame.u32Width = picWidDst;
|
|
stVgsTask.stImgOut.stVFrame.u32Height = picHgtDst;
|
|
stVgsTask.stImgOut.stVFrame.enPixelFormat = colorFmt;
|
|
stVgsTask.stImgOut.stVFrame.enVideoFormat = VIDEO_FORMAT_LINEAR;
|
|
stVgsTask.stImgOut.stVFrame.u32PhyAddr[0] = phyAddrOut;
|
|
stVgsTask.stImgOut.stVFrame.u32PhyAddr[1] = phyAddrOut + picWidDst * picHgtDst;
|
|
stVgsTask.stImgOut.stVFrame.u32Stride[0] = picWidDst;
|
|
stVgsTask.stImgOut.stVFrame.enCompressMode = COMPRESS_MODE_NONE;
|
|
|
|
fread(pVirAddr, 1, picWidSrc * picHgtSrc * step / 2, pfd);
|
|
|
|
gettimeofday(&tv, NULL);
|
|
u64BeginTime = (tv.tv_sec) * 1000 * 1000 + tv.tv_usec ;
|
|
|
|
while(1)
|
|
{
|
|
ret = FH_VGS_BeginJob(&VgsHandle);
|
|
|
|
ret = FH_VGS_AddScaleTask(VgsHandle, &stVgsTask);
|
|
if(ret != FH_SUCCESS)
|
|
{
|
|
printf("FH_VGS_AddScaleTask error, s32Ret:0x%x.\n", ret);
|
|
goto exit;
|
|
}
|
|
|
|
ret = FH_VGS_EndJob(VgsHandle);
|
|
if(ret != FH_SUCCESS)
|
|
{
|
|
printf("FH_VGS_EndJob error, s32Ret:0x%x.\n", ret);
|
|
goto exit;
|
|
}
|
|
|
|
cnt++;
|
|
|
|
if(cnt % 1000 == 0){
|
|
gettimeofday(&tv, NULL);
|
|
u64DuringTime = (tv.tv_sec) * 1000 * 1000 + tv.tv_usec ;
|
|
u64DuringTime = u64DuringTime - u64BeginTime;
|
|
printf("\n-----------------------------------------\n");
|
|
printf("------vppu frameCnt:%d CostTime:%lld fps:%f---\n", cnt, u64DuringTime, cnt * 1000 * 1000 / (double)u64DuringTime);
|
|
printf("-----------------------------------------\n\n");
|
|
}
|
|
usleep(20*100);
|
|
}
|
|
|
|
exit:
|
|
FH_SYS_VmmFree(phyAddr);
|
|
FH_SYS_VmmFree(phyAddrOut);
|
|
out:
|
|
fclose(pfd);
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
FH_SINT32 maxlod_add_module_start()
|
|
{
|
|
int ret;
|
|
|
|
pthread_t pTdeThr;
|
|
ret = pthread_create(&pTdeThr, 0, maxlod_tde_performace, "tde_run");
|
|
if(ret != FH_SUCCESS)
|
|
{
|
|
printf("[MAXLOADING]======create thread tde failed======\n");
|
|
return ret;
|
|
}else{
|
|
printf("[MAXLOADING]======create thread tde ok======\n");
|
|
}
|
|
|
|
#if 0
|
|
pthread_t pVgsThr;
|
|
ret = pthread_create(&pVgsThr, 0, maxlod_vgs_performace, "vgs_run");
|
|
if(ret != FH_SUCCESS)
|
|
{
|
|
printf("[MAXLOADING]======create thread tde failed======\n");
|
|
return ret;
|
|
}else{
|
|
printf("[MAXLOADING]======create thread vgs ok======\n");
|
|
}
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
void maxlod_signal_exit()
|
|
{
|
|
int i;
|
|
|
|
maxlod_running = FH_FALSE;
|
|
|
|
#ifdef MAXLOD_UI_TEST
|
|
maxlod_ui_stop();
|
|
#endif
|
|
|
|
#ifdef MAXLOD_VDSP_TEST
|
|
maxlod_vdsp_stop();
|
|
#endif
|
|
|
|
#ifdef MAXLOD_PREVIEW_TEST
|
|
maxlod_preview_stop();
|
|
#endif
|
|
|
|
#ifdef MAXLOD_PLAYBACK_TEST
|
|
maxlod_playback_stop();
|
|
#endif
|
|
|
|
FH_SYS_Exit();
|
|
for(i=0;i<VB_MAX_USER;i++){
|
|
FH_VB_ExitModCommPool(i);
|
|
}
|
|
for(i=0; i<VB_MAX_POOLS; i++){
|
|
FH_VB_DestroyPool(i);
|
|
}
|
|
FH_VB_Exit();
|
|
}
|
|
|
|
/*======================
|
|
* 1: mipi/vicap -> isp -> vpu(2DLUT) -> veu
|
|
* 2: vdec -> vppu/g2d -> vou -> mipiTx
|
|
* 3: g2d -> vou
|
|
* x: vdsp / nnp / memcpy / jpeg
|
|
======================*/
|
|
#define PIPE_MAX_LEN (16)
|
|
|
|
#define TILE_W_ALIGN (64)
|
|
#define FHVPU_DATA_ALIGN (1024)
|
|
#define DATA_ALIGN(size) ALIGN_UP((size),FHVPU_DATA_ALIGN)
|
|
|
|
#define CALC_TILE(w,h,tile) (ALIGN_UP(w,TILE_W_ALIGN)*h*3/2/384*tile)
|
|
#define CALC_TILE224(w,h) CALC_TILE(w,h,224)
|
|
#define CALC_TILE224_ALIGN(w,h) DATA_ALIGN(CALC_TILE224(w,h))
|
|
#define CALC_TILE192(w,h) CALC_TILE(w,h,192)
|
|
#define CALC_TILE192_ALIGN(w,h) DATA_ALIGN(CALC_TILE192(w,h))
|
|
#define CALC_YUV420_ALIGN(w,h) (DATA_ALIGN((w*h)) + DATA_ALIGN((w*h/2)))
|
|
|
|
int nnsleep = 0;
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
int i, ret, chkNum=0;
|
|
VB_CONF_S stVbConf;
|
|
FH_UINT32 ddrEffAvgJug = 0, vencfpsJug = 0;
|
|
FH_UINT32 nnpfpsJug = 0, vdspfpsJug = 0;
|
|
FH_UINT32 vdecfpsJug = 25;
|
|
FH_UINT32 g2dfpsJug = 20;
|
|
#if defined(MAXLOD_TYPE_8M30_ORG)
|
|
ddrEffAvgJug = 58; vencfpsJug = 25;
|
|
nnpfpsJug = 19; vdspfpsJug = 19;
|
|
ddrEff[0] = ddrEff[1] = ddrEff[2] = 60;
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_8M15_SLOCK)
|
|
ddrEffAvgJug = 26; vencfpsJug = 13;
|
|
nnpfpsJug = 19; vdspfpsJug = 19;
|
|
ddrEff[0] = ddrEff[1] = ddrEff[2] = 30;
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_8M15_SLOCK_VDSP)
|
|
ddrEffAvgJug = 48; vencfpsJug = 13;
|
|
nnpfpsJug = 19; vdspfpsJug = 19;
|
|
ddrEff[0] = ddrEff[1] = ddrEff[2] = 52;
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_4M30_ORG)
|
|
ddrEffAvgJug = 68; vencfpsJug = 25;
|
|
nnpfpsJug = 13; vdspfpsJug = 13;
|
|
ddrEff[0] = ddrEff[1] = ddrEff[2] = 70;
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_4M30_07V)
|
|
ddrEffAvgJug = 75; vencfpsJug = 25; g2dfpsJug = 15;
|
|
nnpfpsJug = 20; vdspfpsJug = 6; vdecfpsJug = 25;
|
|
ddrEff[0] = ddrEff[1] = ddrEff[2] = 79;
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_4M30_SLOCK)
|
|
ddrEffAvgJug = 42; vencfpsJug = 25;
|
|
nnpfpsJug = 19; vdspfpsJug = 19;
|
|
ddrEff[0] = ddrEff[1] = ddrEff[2] = 45;
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_2M30_FACEMOD)
|
|
ddrEffAvgJug = 60; vencfpsJug = 25;
|
|
nnpfpsJug = 19; vdspfpsJug = 19;
|
|
ddrEff[0] = ddrEff[1] = ddrEff[2] = 70;
|
|
#endif
|
|
|
|
signal(SIGINT,maxlod_signal_exit);
|
|
signal(SIGQUIT,maxlod_signal_exit);
|
|
signal(SIGTERM,maxlod_signal_exit);
|
|
|
|
if(argc>1){
|
|
nnsleep = atoi(argv[1]);
|
|
}else{
|
|
#ifdef MAXLOD_TYPE_2M30_FACEMOD
|
|
nnsleep = 5;
|
|
#else
|
|
nnsleep = 0;
|
|
#endif
|
|
}
|
|
|
|
memset(&stVbConf, 0, sizeof(VB_CONF_S));
|
|
stVbConf.u32MaxPoolCnt = 2;
|
|
|
|
#if defined(MAXLOD_TYPE_4M30_ORG)|| defined(MAXLOD_TYPE_4M30_07V) || defined(MAXLOD_TYPE_4M30_SLOCK) || defined(MAXLOD_TYPE_2M30_FACEMOD)
|
|
#ifdef MAXLOD_TYPE_4M30_07V
|
|
stVbConf.astCommPool[0].u32BlkSize = CALC_TILE192(ALIGN_UP(MAXLOD_VPU_WIDTH, 16), ALIGN_UP(MAXLOD_VPU_HEIGHT, 16)) + 2048;
|
|
stVbConf.astCommPool[1].u32BlkSize = CALC_TILE192(ALIGN_UP(MAXLOD_VPU1_WIDTH, 16), ALIGN_UP(MAXLOD_VPU1_HEIGHT, 16)) + 2048;
|
|
stVbConf.astCommPool[0].u32BlkCnt = 5;
|
|
stVbConf.astCommPool[1].u32BlkCnt = 5;
|
|
#else
|
|
stVbConf.astCommPool[0].u32BlkSize = CALC_TILE224_ALIGN(ALIGN_UP(MAXLOD_VPU_WIDTH, 16), ALIGN_UP(MAXLOD_VPU_HEIGHT, 16)) + 2048;
|
|
stVbConf.astCommPool[1].u32BlkSize = CALC_TILE224_ALIGN(ALIGN_UP(MAXLOD_VPU1_WIDTH, 16), ALIGN_UP(MAXLOD_VPU1_HEIGHT, 16)) + 2048;
|
|
stVbConf.astCommPool[0].u32BlkCnt = 4;
|
|
stVbConf.astCommPool[1].u32BlkCnt = 4;
|
|
#endif
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_8M30_ORG) || defined(MAXLOD_TYPE_8M15_SLOCK) || defined(MAXLOD_TYPE_8M15_SLOCK_VDSP)
|
|
stVbConf.astCommPool[0].u32BlkSize = ALIGN_UP(MAXLOD_VPU_WIDTH, 16) * ALIGN_UP(MAXLOD_VPU_HEIGHT, 16) * 2;
|
|
stVbConf.astCommPool[1].u32BlkSize = ALIGN_UP(MAXLOD_VPU1_WIDTH, 16) * ALIGN_UP(MAXLOD_VPU1_HEIGHT, 16) * 2;
|
|
stVbConf.astCommPool[0].u32BlkCnt = 4;
|
|
stVbConf.astCommPool[1].u32BlkCnt = 4;
|
|
#endif
|
|
|
|
FH_SYS_Exit();
|
|
for(i=0;i<VB_MAX_USER;i++){
|
|
FH_VB_ExitModCommPool(i);
|
|
}
|
|
for(i=0; i<VB_MAX_POOLS; i++){
|
|
FH_VB_DestroyPool(i);
|
|
}
|
|
FH_VB_Exit();
|
|
|
|
ret = FH_VB_SetConf(&stVbConf);
|
|
MAXLOAD_CHECK_GOTO((FH_SUCCESS != ret), EXIT, "FH_VB_SetConf failed!");
|
|
|
|
ret = FH_VB_Init();
|
|
MAXLOAD_CHECK_GOTO((FH_SUCCESS != ret), EXIT, "FH_VB_Init failed!");
|
|
|
|
ret = FH_SYS_Init();
|
|
MAXLOAD_CHECK_GOTO((FH_SUCCESS != ret), EXIT, "FH_SYS_Init failed!");
|
|
|
|
maxlod_running = FH_TRUE;
|
|
|
|
printf("############ MAXLOADING VERSION:%s ############\n", MAXLOD_VERSION);
|
|
|
|
#ifdef MAXLOD_PREVIEW_TEST
|
|
//thread: mipi/vicap -> isp -> vpu(2DLUT) -> veu
|
|
printf("############=============preview to run\n");
|
|
MAXLOAD_GETCHAR();
|
|
ret = maxlod_preview_start();
|
|
//sleep(1);
|
|
#endif
|
|
|
|
#ifdef MAXLOD_JPEGE_TEST
|
|
//thread: jpege
|
|
printf("############=============jpeg to run\n");
|
|
MAXLOAD_GETCHAR();
|
|
ret = maxlod_jpege_start();
|
|
sleep(2);
|
|
#endif
|
|
|
|
#ifdef MAXLOD_PLAYBACK_TEST
|
|
//thread: vdec -> vppu -> vou -> mipiTx
|
|
printf("############=============playback to run\n");
|
|
MAXLOAD_GETCHAR();
|
|
ret = maxlod_playback_start();
|
|
//sleep(1);
|
|
#endif
|
|
|
|
#ifdef MAXLOD_MEMCOPY_TEST
|
|
//thread: memcpy
|
|
printf("############=============memcpy to run\n");
|
|
MAXLOAD_GETCHAR();
|
|
ret = maxlod_memcpy_start();
|
|
//sleep(1);
|
|
#endif
|
|
|
|
#ifdef MAXLOD_UI_TEST
|
|
//thread: g2d -> vou
|
|
printf("############=============ui to run\n");
|
|
MAXLOAD_GETCHAR();
|
|
ret = maxlod_ui_start();
|
|
//sleep(1);
|
|
#endif
|
|
|
|
#ifdef MAXLOD_VDSP_TEST
|
|
printf("############=============vdsp to run\n");
|
|
MAXLOAD_GETCHAR();
|
|
ret = maxlod_vdsp_start();
|
|
//sleep(1);
|
|
#endif
|
|
|
|
#ifdef MAXLOD_NNP_TEST
|
|
sleep(10);
|
|
printf("############=============nnp to run\n");
|
|
MAXLOAD_GETCHAR();
|
|
ret = maxlod_nnp_start(nnsleep);
|
|
//sleep(1);
|
|
#endif
|
|
|
|
#ifdef MAXLOD_ADD_LOAD
|
|
printf("############=============module to run\n");
|
|
MAXLOAD_GETCHAR();
|
|
ret = maxlod_add_module_start();
|
|
#endif
|
|
|
|
FILE *pipeVdec, *pipeDdr, *pipeDdrT, *pipeVenc[2];
|
|
char bufVdec[PIPE_MAX_LEN], bufDdr[PIPE_MAX_LEN], bufDdrT[PIPE_MAX_LEN];
|
|
char bufVenc0[PIPE_MAX_LEN], bufVenc1[PIPE_MAX_LEN];
|
|
char ddrDff[10], ddrDffT[10];
|
|
|
|
i = 0;
|
|
int index = 0;
|
|
while(maxlod_running)
|
|
{
|
|
//system("mpstat 1 1");
|
|
//sleep(3);
|
|
|
|
#if defined(MAXLOD_TYPE_4M30_07V)
|
|
system("perfmon_xc 5000 1732");
|
|
pipeDdr = popen("perfmon_xc 5000 1732 | grep efficiency | awk '{print $3}'", "r");
|
|
pipeDdrT = popen("perfmon_xc 5000 1732 | grep Total | awk '{print $4}'", "r");
|
|
|
|
pipeVenc[0] = popen("cat /proc/driver/vpu | grep '1440 2560 1440'| awk '{print $8}'", "r");
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_4M30_ORG) || defined(MAXLOD_TYPE_4M30_SLOCK) || defined(MAXLOD_TYPE_2M30_FACEMOD)
|
|
system("perfmon_xc 5000 2133");
|
|
pipeDdr = popen("perfmon_xc 5000 2133 | grep efficiency | awk '{print $3}'", "r");
|
|
pipeDdrT = popen("perfmon_xc 5000 2133 | grep Total | awk '{print $4}'", "r");
|
|
|
|
pipeVenc[0] = popen("cat /proc/driver/vpu | grep '1440 2560 1440'| awk '{print $8}'", "r");
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_8M30_ORG) || defined(MAXLOD_TYPE_8M15_SLOCK)
|
|
system("perfmon_xc 5000 4800");
|
|
pipeDdr = popen("perfmon_xc 5000 4800 | grep efficiency | awk '{print $3}'", "r");
|
|
pipeDdrT = popen("perfmon_xc 5000 4800 | grep Total | awk '{print $4}'", "r");
|
|
|
|
pipeVenc[0] = popen("cat /proc/driver/vpu | grep '2160 3840 2160'| awk '{print $8}'", "r");
|
|
#endif
|
|
#if defined(MAXLOD_TYPE_8M15_SLOCK_VDSP)
|
|
system("perfmon_xc 5000 4266");
|
|
pipeDdr = popen("perfmon_xc 5000 4266 | grep efficiency | awk '{print $3}'", "r");
|
|
pipeDdrT = popen("perfmon_xc 5000 4266 | grep Total | awk '{print $4}'", "r");
|
|
|
|
pipeVenc[0] = popen("cat /proc/driver/vpu | grep '2160 3840 2160'| awk '{print $8}'", "r");
|
|
#endif
|
|
pipeVenc[1] = popen("cat /proc/driver/vpu | grep '720 1280 720'| awk '{print $8}'", "r");
|
|
|
|
if (pipeDdr == NULL) {
|
|
printf("open ddr pipeDdr failed\n");
|
|
continue;
|
|
}
|
|
fgets(bufDdr, PIPE_MAX_LEN, pipeDdr);
|
|
strncpy(ddrDff, bufDdr, 5);
|
|
ddrDff[5] = '\0';
|
|
pclose(pipeDdr);
|
|
|
|
if (pipeDdrT == NULL) {
|
|
printf("open ddr pipeDdrT failed\n");
|
|
continue;
|
|
}
|
|
fgets(bufDdrT, PIPE_MAX_LEN, pipeDdrT);
|
|
strncpy(ddrDffT, bufDdrT, 8);
|
|
ddrDffT[8] = '\0';
|
|
pclose(pipeDdrT);
|
|
|
|
if (pipeVenc[0] == NULL) {
|
|
printf("open vdec pipeVenc0 failed\n");
|
|
continue;
|
|
}
|
|
fgets(bufVenc0, PIPE_MAX_LEN, pipeVenc[0]);
|
|
pclose(pipeVenc[0]);
|
|
|
|
if (pipeVenc[1] == NULL) {
|
|
printf("open vdec pipeVenc1 failed\n");
|
|
continue;
|
|
}
|
|
fgets(bufVenc1, PIPE_MAX_LEN, pipeVenc[1]);
|
|
pclose(pipeVenc[1]);
|
|
|
|
pipeVdec = popen("cat /proc/driver/vdec | grep Start | awk '{print $12}'", "r");
|
|
if (pipeVdec == NULL) {
|
|
printf("open vdec pipeVdec failed\n");
|
|
continue;
|
|
}
|
|
fgets(bufVdec, PIPE_MAX_LEN, pipeVdec);
|
|
pclose(pipeVdec);
|
|
|
|
index = (i++) % 3;
|
|
|
|
total = atof(ddrDffT);
|
|
ddrEff[index] = atof(ddrDff);
|
|
vdecfps = atoi(bufVdec);
|
|
vencfps0 = atoi(bufVenc0);
|
|
vencfps1 = atoi(bufVenc1);
|
|
#ifdef MAXLOD_NNP_TEST
|
|
nnpfps = maxlod_nnp_getFps();
|
|
#endif
|
|
#ifdef MAXLOD_UI_TEST
|
|
uifps = maxlod_ui_getFps();
|
|
#endif
|
|
ddrEffAvg = (ddrEff[0] + ddrEff[1] + ddrEff[2]) / (float)3;
|
|
|
|
printf("\n******************************************************************************\n");
|
|
printf("FPS INFO: vdsp[%3d] nnp[%3d] ui[%3d] jpeg[%3d] playback[%3d] preview[%3d(%3d)]\n", vdspfps, nnpfps, uifps, jpgfps, vdecfps, vencfps0, vencfps1);
|
|
printf("******************************************************************************\n");
|
|
printf("DDR INFO: efficiency[%.2f]\n", ddrEffAvg);
|
|
printf("******************************************************************************\n");
|
|
printf("MAXLOAD RESULT [%d]:\n", chkNum++);
|
|
|
|
printf(" bandwidth [%4s]\n", (ddrEffAvg<ddrEffAvgJug)?"fail":"ok");
|
|
printf(" preview0 [%4s]\n", ((vencfps0<vencfpsJug) && (ddrEffAvg<ddrEffAvgJug))?"fail":"ok");
|
|
#ifdef MAXLOD_SUBSTREAM_EN
|
|
printf(" preview1 [%4s]\n", ((vencfps1<vencfpsJug) && (ddrEffAvg<ddrEffAvgJug))?"fail":"ok");
|
|
#else
|
|
printf(" preview1 [%4s]\n", ((vencfps1<vencfpsJug) && (ddrEffAvg<ddrEffAvgJug))?"NA":"NA");
|
|
#endif
|
|
#ifdef MAXLOD_VDSP_TEST
|
|
vdspfps = maxlod_vdsp_getFps();
|
|
printf(" vdsp [%4s]\n", ((vdspfps<vdspfpsJug)&& (ddrEffAvg<ddrEffAvgJug))?"fail":"ok");
|
|
#else
|
|
printf(" vdsp [%4s]\n", (vdspfps<vdspfpsJug)?"NA":"NA");
|
|
#endif
|
|
#ifdef MAXLOD_PLAYBACK_TEST
|
|
printf(" playback [%4s]\n", (vdecfps<vdecfpsJug)?"fail":"ok");
|
|
printf(" g2d [%4s]\n", ((uifps<g2dfpsJug) && (ddrEffAvg<ddrEffAvgJug))?"fail":"ok");
|
|
#else
|
|
printf(" playback [%4s]\n", (vdecfps<vdecfpsJug)?"NA":"NA");
|
|
printf(" g2d [%4s]\n", (uifps<g2dfpsJug)?"NA":"NA");
|
|
#endif
|
|
printf(" nnp [%4s]\n", (nnpfps<nnpfpsJug)?"fail":"ok");
|
|
printf("******************************************************************************\n\n");
|
|
}
|
|
|
|
#ifdef MAXLOD_UI_TEST
|
|
maxlod_ui_stop();
|
|
#endif
|
|
|
|
#ifdef MAXLOD_NNP_TEST
|
|
maxlod_nnp_stop();
|
|
#endif
|
|
|
|
#ifdef MAXLOD_VDSP_TEST
|
|
maxlod_vdsp_stop();
|
|
#endif
|
|
|
|
#ifdef MAXLOD_PREVIEW_TEST
|
|
maxlod_preview_stop();
|
|
#endif
|
|
|
|
#ifdef MAXLOD_PLAYBACK_TEST
|
|
maxlod_playback_stop();
|
|
#endif
|
|
|
|
FH_SYS_Exit();
|
|
for(i=0;i<VB_MAX_USER;i++){
|
|
FH_VB_ExitModCommPool(i);
|
|
}
|
|
for(i=0; i<VB_MAX_POOLS; i++){
|
|
FH_VB_DestroyPool(i);
|
|
}
|
|
FH_VB_Exit();
|
|
|
|
EXIT:
|
|
return ret;
|
|
}
|
|
|