#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;
}