/*
 * 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_VGS

#include <cstdio>
#include <cerrno>
#include <cstring>
#include <pthread.h>
#include "rk_type.h"
#include "rk_debug.h"
#include "rk_mpi_vgs.h"
#include "rk_mpi_mb.h"
#include "rk_mpi_sys.h"
#include "rk_mpi_cal.h"
#include "mpi_test_utils.h"
#include "argparse.h"

typedef enum rkVGS_TASK_TYPE_E {
    VGS_TASK_TYPE_NONE = 0,
    VGS_TASK_TYPE_SCALE,
    VGS_TASK_TYPE_ROTATE,
    VGS_TASK_TYPE_DRAW_LINE,
    VGS_TASK_TYPE_COVER,
    VGS_TASK_TYPE_OSD,
    VGS_TASK_TYPE_MOSAIC,
    VGS_TASK_TYPE_CROP,
    VGS_TASK_TYPE_BUTT
} VGS_TASK_TYPE_E;

typedef enum rkVGS_TASK_MODE_E {
    VGS_TASK_MODE_NONE = 0,
    VGS_TASK_MODE_ONE,
    VGS_TASK_MODE_ALL,
    VGS_TASK_MODE_BUTT
} VGS_TASK_MODE_E;

typedef struct _rkMpiVgsCtx {
    const char *srcFilePath;
    const char *dstFilePath;
    const char *osdFilePath;
    RK_S32  s32LoopCount;
    RK_S32  s32JobNum;
    RK_S32  s32TaskNum;
    RK_S32  s32TaskType;
    RK_S32  s32TaskMode;
    RK_U32  u32TaskArraySize;
    RK_S32  s32Angle;
    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  s32OsdWidth;
    RK_S32  s32OsdHeight;
    RK_S32  s32OsdCompressMode;
    RK_S32  s32OsdPixFormat;
    RECT_S  stCropRect;
    RK_S32  s32JobIdx;
    RK_U32  u32SrcSize;
} TEST_VGS_CTX_S;

typedef struct _rkMpiTestTaskCtx {
    VGS_ADD_COVER_S enCoverInfo[VGS_MAX_TASK_NUM];
    VGS_ADD_OSD_S   enOsdInfo[VGS_MAX_TASK_NUM * VGS_MAX_ARRAY_SIZE];
    VGS_MOSAIC_S    enMosaicInfo[VGS_MAX_TASK_NUM];
    VGS_DRAW_LINE_S enDrawLine[VGS_MAX_TASK_NUM];
    VGS_CROP_INFO_S stCropInfo;
} TEST_TASK_CTX_S;

RK_S32 test_open_and_read_file(const char *path, void *pu8SrcData, RK_U32 u32SrcSize) {
    FILE  *pFile        = 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_ERR_VGS_NULL_PTR;
    }
    if (pFile) {
         u32ReadSize = fread(pu8SrcData, 1, u32SrcSize, pFile);
         fflush(pFile);
         fclose(pFile);
    }
    RK_LOGD("unit_test_open_source u32ReadSize:%d", u32ReadSize);
    if (u32ReadSize != u32SrcSize) {
        RK_LOGE("read error read %d, request %d", u32ReadSize, u32SrcSize);
        return RK_ERR_VGS_NULL_PTR;
    }
    return RK_SUCCESS;
}

RK_S32 unit_test_vgs_generate_source(const char *srcFilePath, MB_BLK *pstSrcBlk, RK_U32 u32SrcSize) {
    RK_S32 s32Ret            = RK_SUCCESS;
    void  *pSrcData          = RK_NULL;
    s32Ret = RK_MPI_SYS_MmzAlloc(pstSrcBlk, RK_NULL, RK_NULL, u32SrcSize);
    if (s32Ret == RK_SUCCESS) {
       pSrcData = RK_MPI_MB_Handle2VirAddr(*pstSrcBlk);
       s32Ret = test_open_and_read_file(srcFilePath, pSrcData, u32SrcSize);
    }
    return s32Ret;
}

RK_S32 unit_test_vgs_generate_scale_task(
        const VGS_TASK_ATTR_S *pstTask, const TEST_VGS_CTX_S *ctx, MB_BLK srcBlk) {
    RK_S32           s32Ret         = RK_SUCCESS;
    VGS_TASK_ATTR_S *pTaskAttr      = const_cast<VGS_TASK_ATTR_S *>(pstTask);
    VIDEO_FRAME_S    videoFrameIn   = {0};
    VIDEO_FRAME_S    videoFrameOut  = {0};
    RK_U32           u32DstSize     = 0;
    MB_BLK           dstBlk         = RK_NULL;

    videoFrameIn.u32Width       = ctx->s32SrcWidth;
    videoFrameIn.u32Height      = ctx->s32SrcHeight;
    videoFrameIn.u32VirWidth    = ctx->s32SrcVirWidth;
    videoFrameIn.u32VirHeight   = ctx->s32SrcVirHeight;
    videoFrameIn.enPixelFormat  = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
    videoFrameIn.u32TimeRef     = 0;
    videoFrameIn.u64PTS         = 0;
    videoFrameIn.pMbBlk         = srcBlk;

    PIC_BUF_ATTR_S stDstPicBufAttr;
    MB_PIC_CAL_S stDstMbPicCalResult;
    stDstPicBufAttr.u32Width = ctx->s32DstWidth;
    stDstPicBufAttr.u32Height = ctx->s32DstHeight;
    stDstPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
    stDstPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32DstCompressMode;
    s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stDstPicBufAttr, &stDstMbPicCalResult);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
        return s32Ret;
    }
    u32DstSize = stDstMbPicCalResult.u32MBSize;
    s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32DstSize);
    if (s32Ret != RK_SUCCESS) {
        return s32Ret;
    }
    videoFrameOut.u32Width      = ctx->s32DstWidth;
    videoFrameOut.u32Height     = ctx->s32DstHeight;
    videoFrameOut.u32VirWidth   = stDstMbPicCalResult.u32VirWidth;
    videoFrameOut.u32VirHeight  = stDstMbPicCalResult.u32VirHeight;
    videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
    videoFrameOut.u32TimeRef    = 0;
    videoFrameOut.u64PTS        = 0;
    videoFrameOut.pMbBlk        = dstBlk;

    pTaskAttr->stImgIn.stVFrame  = videoFrameIn;
    pTaskAttr->stImgOut.stVFrame = videoFrameOut;
    RK_LOGD("src w(%d) h(%d) dst w(%d) h(%d)",
                pTaskAttr->stImgIn.stVFrame.u32Width,
                pTaskAttr->stImgIn.stVFrame.u32Height,
                pTaskAttr->stImgOut.stVFrame.u32Width,
                pTaskAttr->stImgOut.stVFrame.u32Height);

    return s32Ret;
}

RK_S32 unit_test_vgs_generate_rotation_task(
        const VGS_TASK_ATTR_S *pstTask, const TEST_VGS_CTX_S *ctx, MB_BLK srcBlk) {
    RK_S32           s32Ret            = RK_SUCCESS;
    VIDEO_FRAME_S    videoFrameIn      = {0};
    VIDEO_FRAME_S    videoFrameOut     = {0};
    VGS_TASK_ATTR_S *pTaskAttr         = const_cast<VGS_TASK_ATTR_S *>(pstTask);
    RK_U32           u32DstSize        = 0;
    MB_BLK           dstBlk            = RK_NULL;
    RK_S32          s32SrcWidth        = ctx->s32SrcWidth;
    RK_S32          s32SrcHeight       = ctx->s32SrcHeight;

    videoFrameIn.u32Width       = s32SrcWidth;
    videoFrameIn.u32Height      = s32SrcHeight;
    videoFrameIn.u32VirWidth    = ctx->s32SrcVirWidth;
    videoFrameIn.u32VirHeight   = ctx->s32SrcVirHeight;
    videoFrameIn.enPixelFormat  = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
    videoFrameIn.u32TimeRef     = 0;
    videoFrameIn.u64PTS         = 0;
    videoFrameIn.pMbBlk         = srcBlk;

    PIC_BUF_ATTR_S stDstPicBufAttr;
    MB_PIC_CAL_S stDstMbPicCalResult;

    videoFrameOut.u32Width      = s32SrcWidth;
    videoFrameOut.u32Height     = s32SrcHeight;
    if ((ctx->s32Angle == ROTATION_90) || (ctx->s32Angle == ROTATION_270)) {
        videoFrameOut.u32Width  = s32SrcHeight;
        videoFrameOut.u32Height = s32SrcWidth;
    }
    stDstPicBufAttr.u32Width = videoFrameOut.u32Width;
    stDstPicBufAttr.u32Height = videoFrameOut.u32Height;
    stDstPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
    stDstPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32DstCompressMode;
    s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stDstPicBufAttr, &stDstMbPicCalResult);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
        return s32Ret;
    }
    u32DstSize = stDstMbPicCalResult.u32MBSize;
    s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32DstSize);
    if (s32Ret != RK_SUCCESS) {
        return s32Ret;
    }

    videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
    videoFrameOut.u32VirWidth   = stDstMbPicCalResult.u32VirWidth;
    videoFrameOut.u32VirHeight  = stDstMbPicCalResult.u32VirHeight;
    videoFrameOut.u32TimeRef    = 0;
    videoFrameOut.u64PTS        = 0;
    videoFrameOut.pMbBlk        = dstBlk;

    pTaskAttr->stImgIn.stVFrame = videoFrameIn;
    pTaskAttr->stImgOut.stVFrame = videoFrameOut;
    RK_LOGD("src w(%d) h(%d) dst w(%d) h(%d)",
                pTaskAttr->stImgIn.stVFrame.u32Width,
                pTaskAttr->stImgIn.stVFrame.u32Height,
                pTaskAttr->stImgOut.stVFrame.u32Width,
                pTaskAttr->stImgOut.stVFrame.u32Height);

    return s32Ret;
}

RK_S32 unit_test_vgs_generate_crop_task(
        const VGS_TASK_ATTR_S *pstTask, VGS_CROP_INFO_S *pstCropInfo, const TEST_VGS_CTX_S *ctx, MB_BLK srcBlk) {
    RK_S32           s32Ret         = RK_SUCCESS;
    VGS_TASK_ATTR_S *pTaskAttr      = const_cast<VGS_TASK_ATTR_S *>(pstTask);
    VIDEO_FRAME_S    videoFrameIn   = {0};
    VIDEO_FRAME_S    videoFrameOut  = {0};
    RK_U32           u32DstSize     = 0;
    MB_BLK           dstBlk         = RK_NULL;

    videoFrameIn.u32Width       = ctx->s32SrcWidth;
    videoFrameIn.u32Height      = ctx->s32SrcHeight;
    videoFrameIn.u32VirWidth    = ctx->s32SrcVirWidth;
    videoFrameIn.u32VirHeight   = ctx->s32SrcVirHeight;
    videoFrameIn.enPixelFormat  = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
    videoFrameIn.u32TimeRef     = 0;
    videoFrameIn.u64PTS         = 0;
    videoFrameIn.pMbBlk         = srcBlk;

    PIC_BUF_ATTR_S stDstPicBufAttr;
    MB_PIC_CAL_S stDstMbPicCalResult;

    stDstPicBufAttr.u32Width = ctx->s32DstWidth;
    stDstPicBufAttr.u32Height = ctx->s32DstHeight;
    stDstPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
    stDstPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32DstCompressMode;
    s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stDstPicBufAttr, &stDstMbPicCalResult);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
        return s32Ret;
    }
    u32DstSize = stDstMbPicCalResult.u32MBSize;
    s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32DstSize);
    if (s32Ret != RK_SUCCESS) {
        return s32Ret;
    }

    videoFrameOut.u32Width      = ctx->s32DstWidth;
    videoFrameOut.u32Height     = ctx->s32DstHeight;
    videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
    videoFrameOut.u32VirWidth   = stDstMbPicCalResult.u32VirWidth;
    videoFrameOut.u32VirHeight  = stDstMbPicCalResult.u32VirHeight;
    videoFrameOut.u32TimeRef    = 0;
    videoFrameOut.u64PTS        = 0;
    videoFrameOut.pMbBlk        = dstBlk;

    pTaskAttr->stImgIn.stVFrame  = videoFrameIn;
    pTaskAttr->stImgOut.stVFrame = videoFrameOut;
    pstCropInfo->enCropCoordinate = VGS_CROP_RATIO_COOR;
    pstCropInfo->stCropRect.s32X = ctx->stCropRect.s32X;
    pstCropInfo->stCropRect.s32Y = ctx->stCropRect.s32Y;
    pstCropInfo->stCropRect.u32Width = ctx->stCropRect.u32Width;
    pstCropInfo->stCropRect.u32Height = ctx->stCropRect.u32Height;
    RK_LOGD("src w(%d) h(%d) dst w(%d) h(%d)",
                pTaskAttr->stImgIn.stVFrame.u32Width,
                pTaskAttr->stImgIn.stVFrame.u32Height,
                pTaskAttr->stImgOut.stVFrame.u32Width,
                pTaskAttr->stImgOut.stVFrame.u32Height);

    return s32Ret;
}

RK_VOID unit_test_set_vgs_cover_array_info(
        VGS_ADD_COVER_S *pstVgsAddCover, const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize) {
    RK_U32   u32Color[VGS_MAX_TASK_NUM] = {0xff00ff00, 0x000000ff, 0x00ff0000,  0x00ff00ff,  0xff00ffff};
    RK_U32   u32Ratio[VGS_MAX_TASK_NUM] = {2, 4,  6,  8,  10,  2,  4,  6};
    RK_S32   s32SrcWidth     = ctx->s32SrcWidth;
    RK_S32   s32SrcHeight    = ctx->s32SrcHeight;
    for (RK_S32 i = 0; i < u32ArraySize; i++) {
        if (u32Ratio[i]) {
            pstVgsAddCover[i].enCoverType         = COVER_RECT;
            pstVgsAddCover[i].stDstRect.s32X      = s32SrcWidth / u32Ratio[i];
            pstVgsAddCover[i].stDstRect.s32Y      = s32SrcHeight / u32Ratio[i];
            pstVgsAddCover[i].stDstRect.u32Width  = s32SrcWidth / u32Ratio[i];
            pstVgsAddCover[i].stDstRect.u32Height = s32SrcHeight / u32Ratio[i];
            pstVgsAddCover[i].u32Color            = u32Color[i];  // green
        }
    }
}

RK_S32 unit_test_vgs_generate_cover_task_array(
        const VGS_TASK_ATTR_S *pstTask, VGS_ADD_COVER_S *pstVgsAddCover,
        const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize, MB_BLK srcBlk) {
    RK_S32           s32Ret         = RK_SUCCESS;
    VIDEO_FRAME_S    videoFrameOut  = {0};
    VGS_TASK_ATTR_S *pTaskAttr      = const_cast<VGS_TASK_ATTR_S *>(pstTask);
    MB_BLK           dstBlk         = RK_NULL;

    s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, ctx->u32SrcSize);
    if (s32Ret != RK_SUCCESS) {
        return s32Ret;
    }
    memcpy(RK_MPI_MB_Handle2VirAddr(dstBlk),
           RK_MPI_MB_Handle2VirAddr(srcBlk), ctx->u32SrcSize);

    videoFrameOut.u32Width      = ctx->s32SrcWidth;
    videoFrameOut.u32Height     = ctx->s32SrcHeight;
    videoFrameOut.u32VirWidth   = ctx->s32SrcVirWidth;
    videoFrameOut.u32VirHeight  = ctx->s32SrcVirHeight;
    videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
    videoFrameOut.u32TimeRef    = 0;
    videoFrameOut.u64PTS        = 0;
    videoFrameOut.pMbBlk        = dstBlk;

    pTaskAttr->stImgIn.stVFrame = videoFrameOut;
    pTaskAttr->stImgOut.stVFrame = videoFrameOut;
    unit_test_set_vgs_cover_array_info(pstVgsAddCover, ctx, u32ArraySize);
    return s32Ret;
}

RK_S32 unit_test_set_vgs_osd_array_info(
        VGS_ADD_OSD_S *pstOsd, const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize) {
    RK_U32          u32Ratio[VGS_MAX_TASK_NUM] = {2, 4,  6,  8,  10,  2,  4,  6};
    RK_U32          u32OsdWidth                = ctx->s32OsdWidth;
    RK_U32          u32OsdHeight               = ctx->s32OsdHeight;
    RK_U32          u32OsdPixFormat            = RK_FMT_YUV420SP;
    RK_U32          u32OsdCompressMode         = COMPRESS_MODE_NONE;
    RK_S32          s32Ret                     = RK_SUCCESS;
    MB_BLK          osdBlk                     = RK_NULL;
    RK_S32          s32SrcWidth                = ctx->s32SrcWidth;
    RK_S32          s32SrcHeight               = ctx->s32SrcHeight;
    const char      *osdFilePath               = ctx->osdFilePath;
    RK_U32          u32OsdSize                 = 0;
    PIC_BUF_ATTR_S stPicBufAttr;
    MB_PIC_CAL_S stMbPicCalResult;

    stPicBufAttr.u32Width = u32OsdWidth;
    stPicBufAttr.u32Height = u32OsdHeight;
    stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)u32OsdPixFormat;
    stPicBufAttr.enCompMode = (COMPRESS_MODE_E)u32OsdCompressMode;
    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;
    }
    u32OsdSize = stMbPicCalResult.u32MBSize;
    for (RK_S32 i = 0; i < u32ArraySize; i++) {
        s32Ret = unit_test_vgs_generate_source(osdFilePath, &osdBlk, u32OsdSize);

        if (s32Ret != RK_SUCCESS) {
            return s32Ret;
        }
        if (u32Ratio[i]) {
            pstOsd[i].stRect.s32X      = s32SrcWidth / u32Ratio[i];
            pstOsd[i].stRect.s32Y      = s32SrcHeight /  u32Ratio[i];
            pstOsd[i].stRect.u32Width  = u32OsdWidth;
            pstOsd[i].stRect.u32Height = u32OsdHeight;
            pstOsd[i].enPixelFmt       = RK_FMT_YUV420SP;
            pstOsd[i].u32FgAlpha       = 0xff;  // no alpha
            pstOsd[i].pMbBlk           = osdBlk;
        }
    }
    return s32Ret;
}

RK_S32 unit_test_vgs_generate_osd_task_array(
        const VGS_TASK_ATTR_S *pstTask, VGS_ADD_OSD_S *pstOsd,
        const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize, MB_BLK srcBlk) {
    RK_S32           s32Ret            = RK_SUCCESS;
    VGS_TASK_ATTR_S *pTaskAttr         = const_cast<VGS_TASK_ATTR_S *>(pstTask);
    VIDEO_FRAME_S    videoFrameOut     = {0};
    MB_BLK           dstBlk            = RK_NULL;

    s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, ctx->u32SrcSize);
    if (s32Ret != RK_SUCCESS) {
        return s32Ret;
    }
    memcpy(RK_MPI_MB_Handle2VirAddr(dstBlk),
           RK_MPI_MB_Handle2VirAddr(srcBlk), ctx->u32SrcSize);

    videoFrameOut.u32Width       = ctx->s32SrcWidth;
    videoFrameOut.u32Height      = ctx->s32SrcHeight;
    videoFrameOut.u32VirWidth    = ctx->s32SrcVirWidth;
    videoFrameOut.u32VirHeight   = ctx->s32SrcVirHeight;
    videoFrameOut.enPixelFormat  = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
    videoFrameOut.u32TimeRef     = 0;
    videoFrameOut.u64PTS         = 0;
    videoFrameOut.pMbBlk        = dstBlk;

    pTaskAttr->stImgOut.stVFrame = videoFrameOut;
    pTaskAttr->stImgIn.stVFrame = videoFrameOut;
    unit_test_set_vgs_osd_array_info(pstOsd, ctx, u32ArraySize);
    return s32Ret;
}

RK_VOID unit_test_set_vgs_drawline_array_info(
        VGS_DRAW_LINE_S *pstDrawLine, const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize) {
    RK_U32   u32Color[VGS_MAX_TASK_NUM] = {0xff00ff00, 0x0000ff00, 0xff000000,  0x00ff00ff,  0xff00ff00};
    RK_U32   u32Ratio[VGS_MAX_TASK_NUM] = {2, 4,  6,  8,  10,  2,  4,  6};
    RK_U32   u32Thick[VGS_MAX_TASK_NUM] = {10, 5,  20,  15,  10,  2,  4,  6};
    RK_S32   s32SrcWidth                = ctx->s32SrcWidth;
    RK_S32   s32SrcHeight               = ctx->s32SrcHeight;
    for (RK_S32 i = 0; i < u32ArraySize; i++) {
        if (u32Ratio[i]) {
            pstDrawLine[i].stStartPoint.s32X      = s32SrcWidth / u32Ratio[i];
            pstDrawLine[i].stStartPoint.s32Y      = s32SrcHeight /  u32Ratio[i];
            pstDrawLine[i].stEndPoint.s32X        = s32SrcWidth / u32Ratio[i] * 2;
            pstDrawLine[i].stEndPoint.s32Y        = s32SrcHeight / u32Ratio[i] * 2;
            pstDrawLine[i].u32Color               = u32Color[i];  // green
            pstDrawLine[i].u32Thick               = u32Thick[i];
        }
    }
}

RK_S32 unit_test_vgs_generate_drawline_task_array(
        const VGS_TASK_ATTR_S *pstTask, VGS_DRAW_LINE_S *pstDrawLine,
        const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize, MB_BLK srcBlk) {
    RK_S32           s32Ret             = RK_SUCCESS;
    VGS_TASK_ATTR_S *pTaskAttr          = const_cast<VGS_TASK_ATTR_S *>(pstTask);
    VIDEO_FRAME_S    videoFrameOut      = {0};
    MB_BLK           dstBlk             = RK_NULL;

    s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, ctx->u32SrcSize);
    if (s32Ret != RK_SUCCESS) {
        return s32Ret;
    }
    memcpy(RK_MPI_MB_Handle2VirAddr(dstBlk),
           RK_MPI_MB_Handle2VirAddr(srcBlk), ctx->u32SrcSize);

    videoFrameOut.u32Width      = ctx->s32SrcWidth;
    videoFrameOut.u32Height     = ctx->s32SrcHeight;
    videoFrameOut.u32VirWidth   = ctx->s32SrcVirWidth;
    videoFrameOut.u32VirHeight  = ctx->s32SrcVirHeight;
    videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
    videoFrameOut.u32TimeRef    = 0;
    videoFrameOut.u64PTS        = 0;
    videoFrameOut.pMbBlk        = dstBlk;

    pTaskAttr->stImgOut.stVFrame = videoFrameOut;
    pTaskAttr->stImgIn.stVFrame = videoFrameOut;
    unit_test_set_vgs_drawline_array_info(pstDrawLine, ctx, u32ArraySize);
    return s32Ret;
}

RK_VOID unit_test_set_vgs_mosaic_array_info(
        VGS_MOSAIC_S *pstVgsMosaic, const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize) {
    VGS_MOSAIC_BLK_SIZE_E u32BlkSize[VGS_MAX_TASK_NUM]  = {RK_MOSAIC_BLK_SIZE_8, RK_MOSAIC_BLK_SIZE_16,
        RK_MOSAIC_BLK_SIZE_32,  RK_MOSAIC_BLK_SIZE_64};
    RK_U32               u32Ratio[VGS_MAX_TASK_NUM]     = {4, 2, 6, 4, 10, 2, 4, 6};
    RK_S32               s32SrcWidth                    = ctx->s32SrcWidth;
    RK_S32               s32SrcHeight                   = ctx->s32SrcHeight;
    for (RK_S32 i = 0; i < u32ArraySize; i++) {
        if (u32Ratio[i]) {
            pstVgsMosaic[i].enBlkSize = u32BlkSize[i];
            pstVgsMosaic[i].stDstRect.s32X      = s32SrcWidth / u32Ratio[i];
            pstVgsMosaic[i].stDstRect.s32Y      = s32SrcHeight /  u32Ratio[i];
            pstVgsMosaic[i].stDstRect.u32Width  = s32SrcWidth /  u32Ratio[i];
            pstVgsMosaic[i].stDstRect.u32Height = s32SrcHeight /  u32Ratio[i];
        }
    }
}

RK_S32 unit_test_vgs_generate_mosaic_task_array(
        const VGS_TASK_ATTR_S *pstTask, VGS_MOSAIC_S *astVgsMosaic,
        const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize, MB_BLK srcBlk) {
    RK_S32           s32Ret           = RK_SUCCESS;
    VIDEO_FRAME_S    videoFrameOut    = {0};
    VGS_TASK_ATTR_S *pTaskAttr        = const_cast<VGS_TASK_ATTR_S *>(pstTask);
    MB_BLK           dstBlk           = RK_NULL;

    s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, ctx->u32SrcSize);
    if (s32Ret != RK_SUCCESS) {
        return s32Ret;
    }
    memcpy(RK_MPI_MB_Handle2VirAddr(dstBlk),
           RK_MPI_MB_Handle2VirAddr(srcBlk), ctx->u32SrcSize);

    videoFrameOut.u32Width      = ctx->s32SrcWidth;
    videoFrameOut.u32Height     = ctx->s32SrcHeight;
    videoFrameOut.u32VirWidth   = ctx->s32SrcVirWidth;
    videoFrameOut.u32VirHeight  = ctx->s32SrcVirHeight;
    videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
    videoFrameOut.u32TimeRef    = 0;
    videoFrameOut.u64PTS        = 0;
    videoFrameOut.pMbBlk        = dstBlk;

    pTaskAttr->stImgIn.stVFrame = videoFrameOut;
    pTaskAttr->stImgOut.stVFrame = videoFrameOut;
    unit_test_set_vgs_mosaic_array_info(astVgsMosaic, ctx, u32ArraySize);
    return s32Ret;
}

RK_S32 unit_test_vgs_output_one_task(
        const VGS_TASK_ATTR_S *pstTask, const TEST_VGS_CTX_S *ctx, RK_U32 jobId, RK_U32 taskId) {
    RK_S32           s32Ret             = RK_SUCCESS;
    char             yuv_out_path[1024] = {0};
    VGS_TASK_ATTR_S *pTaskAttr          = const_cast<VGS_TASK_ATTR_S *>(pstTask);
    VIDEO_FRAME_S    videoFrameOut      = pTaskAttr->stImgOut.stVFrame;
    MB_BLK           bBlk               = videoFrameOut.pMbBlk;
    RK_VOID         *pstFrame           = RK_MPI_MB_Handle2VirAddr(bBlk);
    const char      *dstFilePath        = ctx->dstFilePath;
    PIC_BUF_ATTR_S stPicBufAttr;
    MB_PIC_CAL_S stMbPicCalResult;

    stPicBufAttr.u32Width = videoFrameOut.u32Width;
    stPicBufAttr.u32Height = videoFrameOut.u32Height;
    stPicBufAttr.enPixelFormat = videoFrameOut.enPixelFormat;
    stPicBufAttr.enCompMode = videoFrameOut.enCompressMode;
    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_U32 u32OutputSize = stMbPicCalResult.u32MBSize;

    snprintf(yuv_out_path,
            sizeof(yuv_out_path),
            "%svgs_out_%dx%d_j_%d_t_%d.yuv",
            dstFilePath,
            videoFrameOut.u32VirWidth,
            videoFrameOut.u32VirHeight, jobId, 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_ERR_SYS_NULL_PTR;
    }
    if (file) {
        if (pstFrame) {
            RK_LOGD("get frame data = %p, size = %d, bBlk:%p ", pstFrame, u32OutputSize, bBlk);
            fwrite(pstFrame, 1, u32OutputSize, file);
            fflush(file);
        }
        fclose(file);
        file = NULL;
    }
    RK_MPI_MB_ReleaseMB(bBlk);
    return RK_SUCCESS;
}

RK_S32 unit_test_vgs_out_all_task(
        VGS_HANDLE hHandle, VGS_TASK_ATTR_S *pstTask,
        const TEST_VGS_CTX_S *ctx, RK_S32 jobId, RK_U32 u32TestTime) {
    RK_S32 s32Ret = RK_SUCCESS;
    for (RK_S32 i =0; i < u32TestTime; i++) {
        unit_test_vgs_output_one_task(&pstTask[i], ctx, jobId, i);
    }
    return RK_SUCCESS;
}

RK_S32 unit_test_release_task_ctx(TEST_TASK_CTX_S *taskCtx) {
    RK_S32   s32Ret               = RK_SUCCESS;
    VGS_ADD_OSD_S   *enOsdInfo    = taskCtx->enOsdInfo;
    for (RK_S32 i = 0; i < VGS_MAX_TASK_NUM; i++) {
        if ((enOsdInfo[i]).pMbBlk) {
            s32Ret = RK_MPI_MB_ReleaseMB((enOsdInfo[i]).pMbBlk);
        }
    }
    return s32Ret;
}

RK_S32 unit_test_vgs_add_one_task(
        VGS_HANDLE hHandle, VGS_TASK_ATTR_S *pstTask, const TEST_VGS_CTX_S *ctx,
        TEST_TASK_CTX_S *taskCtx, MB_BLK srcBlk, RK_S32 taskId) {
    RK_S32          s32Ret                          = RK_SUCCESS;
    VGS_ADD_COVER_S *enCoverInfo                    = taskCtx->enCoverInfo;
    VGS_ADD_OSD_S   *enOsdInfo                      = taskCtx->enOsdInfo;
    VGS_MOSAIC_S    *enMosaicInfo                   = taskCtx->enMosaicInfo;
    VGS_DRAW_LINE_S *enDrawLine                     = taskCtx->enDrawLine;
    VGS_CROP_INFO_S *pstCropInfo                    = &(taskCtx->stCropInfo);
    RK_S32          testTaskType                    = ctx->s32TaskType;
    RK_S32          s32TaskNum                      = ctx->s32TaskNum;
    RK_U32          u32ArraySize                    = ctx->u32TaskArraySize;
    RK_S32          s32Angle                        = ctx->s32Angle;
    switch (testTaskType) {
        case VGS_TASK_TYPE_SCALE:
            s32Ret = unit_test_vgs_generate_scale_task(pstTask, ctx, srcBlk);
            if (s32Ret != RK_SUCCESS) {
                return s32Ret;
            }
            s32Ret = RK_MPI_VGS_AddScaleTask(hHandle, pstTask, VGS_SCLCOEF_NORMAL);
            break;
        case VGS_TASK_TYPE_ROTATE:
            s32Ret = unit_test_vgs_generate_rotation_task(pstTask, ctx, srcBlk);
            if (s32Ret != RK_SUCCESS) {
                return s32Ret;
            }
            s32Ret = RK_MPI_VGS_AddRotationTask(hHandle, pstTask, ROTATION_E(s32Angle));
            break;
        case VGS_TASK_TYPE_CROP:
            s32Ret = unit_test_vgs_generate_crop_task(pstTask, pstCropInfo, ctx, srcBlk);
            if (s32Ret != RK_SUCCESS) {
                return s32Ret;
            }
            s32Ret = RK_MPI_VGS_AddCropTask(hHandle, pstTask, pstCropInfo);
            break;
        case VGS_TASK_TYPE_DRAW_LINE:
            s32Ret = unit_test_vgs_generate_drawline_task_array(pstTask, enDrawLine, ctx, u32ArraySize, srcBlk);
            if (s32Ret != RK_SUCCESS) {
                return s32Ret;
            }
            if (u32ArraySize == 1) {
                s32Ret = RK_MPI_VGS_AddDrawLineTask(hHandle, pstTask, enDrawLine);
            } else {
                s32Ret = RK_MPI_VGS_AddDrawLineTaskArray(hHandle, pstTask, enDrawLine, u32ArraySize);
            }
            break;
        case VGS_TASK_TYPE_COVER:
            s32Ret = unit_test_vgs_generate_cover_task_array(pstTask, enCoverInfo, ctx, u32ArraySize, srcBlk);
            if (s32Ret != RK_SUCCESS) {
                return s32Ret;
            }
            if (u32ArraySize == 1) {
                s32Ret = RK_MPI_VGS_AddCoverTask(hHandle, pstTask, enCoverInfo);
            } else {
                s32Ret = RK_MPI_VGS_AddCoverTaskArray(hHandle, pstTask, enCoverInfo, u32ArraySize);
            }
            break;
        case VGS_TASK_TYPE_OSD:
            s32Ret = unit_test_vgs_generate_osd_task_array(
                pstTask, &enOsdInfo[taskId*u32ArraySize], ctx, u32ArraySize, srcBlk);
            if (s32Ret != RK_SUCCESS) {
                return s32Ret;
            }
            if (u32ArraySize == 1) {
                s32Ret = RK_MPI_VGS_AddOsdTask(hHandle, pstTask, enOsdInfo);
            } else {
                s32Ret = RK_MPI_VGS_AddOsdTaskArray(hHandle, pstTask, &enOsdInfo[taskId*u32ArraySize], u32ArraySize);
            }
            break;
        case VGS_TASK_TYPE_MOSAIC:
            s32Ret = unit_test_vgs_generate_mosaic_task_array(pstTask, enMosaicInfo, ctx, u32ArraySize, srcBlk);
            if (s32Ret != RK_SUCCESS) {
                return s32Ret;
            }
            if (u32ArraySize == 1) {
                s32Ret = RK_MPI_VGS_AddMosaicTask(hHandle, pstTask, enMosaicInfo);
            } else {
                s32Ret = RK_MPI_VGS_AddMosaicTaskArray(hHandle, pstTask, enMosaicInfo, u32ArraySize);
            }
            break;
        default:
            break;
    }
    if (s32Ret != RK_SUCCESS) {
        RK_MPI_VGS_CancelJob(hHandle);
        return s32Ret;
    }
    if (taskId == (s32TaskNum -1)) {
        s32Ret = RK_MPI_VGS_EndJob(hHandle);
    }
    if (s32Ret != RK_SUCCESS) {
        RK_MPI_VGS_CancelJob(hHandle);
    }
    return s32Ret;
}

RK_S32 unit_test_vgs_add_all_task(
       VGS_HANDLE hHandle, VGS_TASK_ATTR_S *pstTask, const TEST_VGS_CTX_S *ctx, TEST_TASK_CTX_S *taskCtx,
       RK_U32 u32TestTime, MB_BLK srcBlk, RK_S32 *u32AllTestTime) {
    RK_S32          s32Ret                          = RK_SUCCESS;
    VGS_ADD_COVER_S *enCoverInfo                    = taskCtx->enCoverInfo;
    VGS_ADD_OSD_S   *enOsdInfo                      = taskCtx->enOsdInfo;
    VGS_MOSAIC_S    *enMosaicInfo                   = taskCtx->enMosaicInfo;
    VGS_DRAW_LINE_S *enDrawLine                     = taskCtx->enDrawLine;
    RK_U32          u32TaskIndex                    = 0;
    RK_U32          u32ArraySize                    = 4;
    RK_U32          u32ScaleWidth                   = 0;
    RK_U32          u32ScaleHeight                  = 0;
    RK_U32          u32Angle                        = ctx->s32Angle;
    for (RK_S32 i = 0; i < u32TestTime; i++) {
        u32ScaleWidth = ctx->s32DstWidth;
        u32ScaleHeight = ctx->s32DstHeight;
        s32Ret = unit_test_vgs_generate_scale_task(&pstTask[u32TaskIndex], ctx, srcBlk);
        if (s32Ret != RK_SUCCESS) {
            return s32Ret;
        }
        s32Ret = RK_MPI_VGS_AddScaleTask(hHandle, &pstTask[u32TaskIndex], VGS_SCLCOEF_NORMAL);
        if (s32Ret != RK_SUCCESS) {
            RK_MPI_VGS_CancelJob(hHandle);
            return s32Ret;
        }
        u32TaskIndex++;
    }
    for (RK_S32 i = 0; i < u32TestTime; i++) {
        s32Ret = unit_test_vgs_generate_rotation_task(&pstTask[u32TaskIndex], ctx, srcBlk);
        if (s32Ret != RK_SUCCESS) {
            return s32Ret;
        }
        s32Ret = RK_MPI_VGS_AddRotationTask(hHandle, &pstTask[u32TaskIndex], (ROTATION_E)u32Angle);
        if (s32Ret != RK_SUCCESS) {
            RK_MPI_VGS_CancelJob(hHandle);
            return s32Ret;
        }
        u32TaskIndex++;
    }
    for (RK_S32 i = 0; i < u32TestTime; i++) {
        s32Ret = unit_test_vgs_generate_cover_task_array(
            &pstTask[u32TaskIndex], enCoverInfo, ctx, u32ArraySize, srcBlk);
        if (s32Ret != RK_SUCCESS) {
            return s32Ret;
        }
        s32Ret = RK_MPI_VGS_AddCoverTaskArray(hHandle, &pstTask[u32TaskIndex], enCoverInfo, u32ArraySize);
        if (s32Ret != RK_SUCCESS) {
            RK_MPI_VGS_CancelJob(hHandle);
            return s32Ret;
        }
        u32TaskIndex++;
    }
    for (RK_S32 i = 0; i < u32TestTime; i++) {
        s32Ret = unit_test_vgs_generate_osd_task_array(
            &pstTask[u32TaskIndex],  &enOsdInfo[i*u32ArraySize], ctx, u32ArraySize, srcBlk);
        if (s32Ret != RK_SUCCESS) {
            return s32Ret;
        }
        RK_MPI_VGS_AddOsdTaskArray(hHandle, &pstTask[u32TaskIndex], &enOsdInfo[i*u32ArraySize], u32ArraySize);
        if (s32Ret != RK_SUCCESS) {
            RK_MPI_VGS_CancelJob(hHandle);
            return s32Ret;
        }
        u32TaskIndex++;
    }
    for (RK_S32 i = 0; i < u32TestTime; i++) {
        s32Ret = unit_test_vgs_generate_drawline_task_array(
            &pstTask[u32TaskIndex], enDrawLine, ctx, u32ArraySize, srcBlk);
        if (s32Ret != RK_SUCCESS) {
            return s32Ret;
        }
        s32Ret = RK_MPI_VGS_AddDrawLineTaskArray(hHandle, &pstTask[u32TaskIndex], enDrawLine, u32ArraySize);
        if (s32Ret != RK_SUCCESS) {
            RK_MPI_VGS_CancelJob(hHandle);
            return s32Ret;
        }
        u32TaskIndex++;
    }

    for (RK_S32 i = 0; i < u32TestTime; i++) {
        s32Ret = unit_test_vgs_generate_mosaic_task_array(
            &pstTask[u32TaskIndex], enMosaicInfo, ctx, u32ArraySize, srcBlk);
        if (s32Ret != RK_SUCCESS) {
            return s32Ret;
        }
        s32Ret = RK_MPI_VGS_AddMosaicTaskArray(hHandle, &pstTask[u32TaskIndex], enMosaicInfo, u32ArraySize);
        if (s32Ret != RK_SUCCESS) {
            RK_MPI_VGS_CancelJob(hHandle);
            return s32Ret;
        }
        u32TaskIndex++;
    }

    s32Ret = RK_MPI_VGS_EndJob(hHandle);
    if (s32Ret != RK_SUCCESS) {
        RK_MPI_VGS_CancelJob(hHandle);
        return s32Ret;
    }

    *u32AllTestTime = u32TaskIndex;
    return s32Ret;
}

RK_U32 unit_test_vgs_get_size(TEST_VGS_CTX_S *ctx) {
    RK_S32 s32Ret = RK_SUCCESS;
    PIC_BUF_ATTR_S stPicBufAttr;
    MB_PIC_CAL_S   stMbPicCalResult;

    if (ctx->s32SrcVirWidth == 0) {
        ctx->s32SrcVirWidth = ctx->s32SrcWidth;
    }
    if (ctx->s32SrcVirHeight == 0) {
        ctx->s32SrcVirHeight = ctx->s32SrcHeight;
    }

    stPicBufAttr.u32Width = ctx->s32SrcVirWidth;
    stPicBufAttr.u32Height = ctx->s32SrcVirHeight;
    stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
    stPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32SrcCompressMode;
    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;
}

RK_S32 unit_test_vgs_one_job(TEST_VGS_CTX_S *ctx) {
    RK_S32 s32Ret                               = RK_SUCCESS;
    MB_BLK srcBlk                               = NULL;
    RK_S32  s32TaskNum                          = ctx->s32TaskNum;
    RK_S32  s32JobId                            = ctx->s32JobIdx;
    RK_S32  s32TaskMode                         = ctx->s32TaskMode;
    const char *srcFilePath                     = ctx->srcFilePath;
    RK_S32  s32SrcPixFormat                     = ctx->s32SrcPixFormat;
    RK_S32  s32SrcCompressMode                  = ctx->s32SrcCompressMode;
    RK_S32 u32OneTaskTestTime                   = s32TaskNum;
    RK_S32 u32AllTaskTestTime                   = 0;
    VGS_HANDLE hHandleAll[VGS_MAX_JOB_NUM]      = {0};
    VGS_TASK_ATTR_S stTask[VGS_MAX_TASK_NUM]    = {0};
    VGS_HANDLE hHandle                          = hHandleAll[s32JobId];
    RK_U32 s32SrcWidth                          = ctx->s32SrcWidth;
    RK_U32 s32SrcHeight                         = ctx->s32SrcHeight;
    TEST_TASK_CTX_S taskCtx;

    memset(&taskCtx, 0, sizeof(TEST_TASK_CTX_S));
    ctx->u32SrcSize = unit_test_vgs_get_size(ctx);
    s32Ret = unit_test_vgs_generate_source(srcFilePath, &srcBlk, ctx->u32SrcSize);
    if (s32Ret != RK_SUCCESS) {
        goto __FAILED;
    }
    s32Ret = RK_MPI_VGS_BeginJob(&hHandle);
    if (s32Ret != RK_SUCCESS) {
        goto __FAILED;
    }
    if (s32TaskMode == VGS_TASK_MODE_ONE) {
        for (RK_S32 taskId = 0; taskId < s32TaskNum; taskId++) {
            s32Ret = unit_test_vgs_add_one_task(hHandle, &stTask[taskId], ctx, &taskCtx, srcBlk, taskId);
            if (s32Ret != RK_SUCCESS) {
                goto __FAILED;
            }
        }
        for (RK_S32 taskId = 0; taskId < s32TaskNum; taskId++) {
            s32Ret = unit_test_vgs_output_one_task(&stTask[taskId], ctx, s32JobId, taskId);
            if (s32Ret != RK_SUCCESS) {
                goto __FAILED;
            }
        }
    } else if (s32TaskMode == VGS_TASK_MODE_ALL) {
        s32Ret = unit_test_vgs_add_all_task(
            hHandle, stTask, ctx, &taskCtx, u32OneTaskTestTime, srcBlk, &u32AllTaskTestTime);
        if (s32Ret != RK_SUCCESS) {
            goto __FAILED;
        }
        s32Ret = unit_test_vgs_out_all_task(hHandle, stTask, ctx, s32JobId, u32AllTaskTestTime);
        if (s32Ret != RK_SUCCESS) {
            goto __FAILED;
        }
    }
    unit_test_release_task_ctx(&taskCtx);
    RK_MPI_SYS_Free(srcBlk);
    RK_LOGD("single vgs test jobid %d running success.", s32JobId);
    return s32Ret;
__FAILED:
    unit_test_release_task_ctx(&taskCtx);
    RK_MPI_SYS_Free(srcBlk);
    RK_LOGE("single vgs test jobid %d running failed.", s32JobId);
    return s32Ret;
}

static void *unit_test_vgs_counts(void *arg) {
    TEST_VGS_CTX_S *ctx               = reinterpret_cast<TEST_VGS_CTX_S *>(arg);
    RK_S32  s32LoopCout               = ctx->s32LoopCount;
    RK_S32  s32LoopNum                = 0;
    RK_S32 s32Ret                     = RK_SUCCESS;
    for (RK_S32 i = 0; i < s32LoopCout; i++) {
        s32Ret = unit_test_vgs_one_job(ctx);
        if (s32Ret != RK_SUCCESS) {
           s32LoopNum = i;
           goto __FAILED;
        }
    }
     return RK_NULL;
__FAILED:
    RK_LOGE("single vgs test %d running failed.", s32LoopNum);
    return RK_NULL;
}

RK_S32 unit_test_vgs_all_job(TEST_VGS_CTX_S *ctx) {
    RK_S32 s32Ret                  = RK_SUCCESS;
    RK_S32  s32JobId               = ctx->s32JobIdx;
    RK_S32 u32JobTestTime          = ctx->s32JobNum;
    const char *srcFilePath        = ctx->srcFilePath;
    RK_S32 u32OneTaskTestTime      = 1;
    RK_S32 u32AllTaskTestTime      = 0;
    void  *pSrcData                = RK_NULL;
    MB_BLK srcBlk                  = RK_NULL;
    VGS_HANDLE hHandleAll[VGS_MAX_JOB_NUM];
    VGS_TASK_ATTR_S stTask[VGS_MAX_TASK_NUM];
    TEST_TASK_CTX_S taskCtx;

    memset(&taskCtx, 0, sizeof(TEST_TASK_CTX_S));
    ctx->u32SrcSize = unit_test_vgs_get_size(ctx);
    s32Ret = unit_test_vgs_generate_source(srcFilePath, &srcBlk, ctx->u32SrcSize);
    if (s32Ret == RK_SUCCESS) {
        for (RK_S32 i = 0; i < u32JobTestTime; i++) {
            VGS_HANDLE hHandle = hHandleAll[i];
            s32Ret = RK_MPI_VGS_BeginJob(&hHandle);
            if (s32Ret == RK_SUCCESS) {
                s32Ret = unit_test_vgs_add_all_task(
                    hHandle, stTask, ctx, &taskCtx, u32OneTaskTestTime, srcBlk, &u32AllTaskTestTime);
                if (s32Ret == RK_SUCCESS) {
                    s32Ret = unit_test_vgs_out_all_task(hHandle, stTask, ctx, s32JobId, u32AllTaskTestTime);
                }
            }
        }
    }
    unit_test_release_task_ctx(&taskCtx);
    RK_MPI_SYS_Free(srcBlk);
    return s32Ret;
}

RK_S32 unit_test_mpi_vgs(TEST_VGS_CTX_S *ctx) {
    RK_S32 s32Ret = RK_SUCCESS;
    pthread_t tids[VGS_MAX_JOB_NUM];
    TEST_VGS_CTX_S tmpCtx[VGS_MAX_JOB_NUM];

    for (RK_S32 jobIndex = 0; jobIndex < ctx->s32JobNum; jobIndex++) {
        memcpy(&(tmpCtx[jobIndex]), ctx, sizeof(TEST_VGS_CTX_S));
        pthread_create(&tids[jobIndex], 0, unit_test_vgs_counts, reinterpret_cast<void *>(&tmpCtx[jobIndex]));
        ctx->s32JobIdx++;
    }

    for (RK_S32 jobIndex = 0; jobIndex < ctx->s32JobNum; jobIndex++) {
        pthread_join(tids[jobIndex], RK_NULL);
    }

    return s32Ret;
}

static const char *const usages[] = {
    "./rk_mpi_vgs_test [-i SRC_PATH] [-o DST_PATH] [--src_width SRC_WIDTH]"
    "[--src_height SRC_HEIGHT] [--dst_width DST_WIDTH] [--dst_height DST_HEIGHT]",
    NULL,
};

static void mpi_vgs_test_show_options(const TEST_VGS_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("osd file name          : %s\n", ctx->osdFilePath);
    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("task type              : %d\n", ctx->s32TaskType);
    RK_PRINT("task mode              : %d\n", ctx->s32TaskMode);
    RK_PRINT("task array size        : %d\n", ctx->u32TaskArraySize);
    RK_PRINT("rotate task angle      : %d\n", ctx->s32Angle);
    RK_PRINT("input width            : %d\n", ctx->s32SrcWidth);
    RK_PRINT("input height           : %d\n", ctx->s32SrcHeight);
    RK_PRINT("input vir width        : %d\n", ctx->s32SrcVirWidth);
    RK_PRINT("input vir 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("osd width              : %d\n", ctx->s32OsdWidth);
    RK_PRINT("osd height             : %d\n", ctx->s32OsdHeight);
    RK_PRINT("osd compress mode      : %d\n", ctx->s32OsdCompressMode);
    RK_PRINT("osd pixel format       : %d\n", ctx->s32OsdPixFormat);
    RK_PRINT("crop x                 : %d\n", ctx->stCropRect.s32X);
    RK_PRINT("crop y                 : %d\n", ctx->stCropRect.s32Y);
    RK_PRINT("crop w                 : %d\n", ctx->stCropRect.u32Width);
    RK_PRINT("crop h                 : %d\n", ctx->stCropRect.u32Height);
}
int main(int argc, const char **argv) {
    TEST_VGS_CTX_S ctx;
    memset(&ctx, 0, sizeof(TEST_VGS_CTX_S));
    RK_S32 s32Ret = RK_SUCCESS;
    //  set default params.
    ctx.dstFilePath     = RK_NULL;
    ctx.s32LoopCount    = 1;
    ctx.s32JobNum       = 1;
    ctx.s32TaskNum      = 1;
    ctx.s32TaskType      = VGS_TASK_TYPE_COVER;
    ctx.u32TaskArraySize  = 1;
    ctx.s32SrcCompressMode  = 0;
    ctx.s32SrcPixFormat     = RK_FMT_YUV420SP;
    ctx.s32DstCompressMode  = 0;
    ctx.s32DstPixFormat     = 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_STRING('o', "output", &(ctx.dstFilePath),
                    "output file path. e.g.(/userdata/vgs/). default(NULL).", NULL, 0, 0),
        OPT_INTEGER('n', "loop_count", &(ctx.s32LoopCount),
                    "loop running 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_STRING('\0', "osd_file", &(ctx.osdFilePath),
                    "osd file path. e.g.(/userdata/vgs/). default(NULL).", NULL, 0, 0),
        OPT_INTEGER('\0', "task_type", &(ctx.s32TaskType),
                    "vgs task type. range(1,6). 1.scale. 2.rotate. 3.draw_line. 4.cover. 5.osd. 6.mosaic.", NULL, 0, 0),
        OPT_INTEGER('\0', "task_mode", &(ctx.s32TaskMode),
                    "task mode. 1: only one task type in one job. 2: all task type in one job. default(1)", NULL, 0, 0),
        OPT_INTEGER('\0', "task_array_size", &(ctx.u32TaskArraySize),
                    "array task size range(1,100). default(1)", NULL, 0, 0),
        OPT_INTEGER('\0', "angle", &(ctx.s32Angle),
                    "rotate task angle. 0:0. 1:90. 2:180. 3:270. default(1)", NULL, 0, 0),
        OPT_INTEGER('\0', "src_width", &(ctx.s32SrcWidth),
                    "src width. e.g.(1920). <required>", NULL, 0, 0),
        OPT_INTEGER('\0', "src_height", &(ctx.s32SrcHeight),
                    "src height. e.g.(1080). <required>", NULL, 0, 0),
        OPT_INTEGER('\0', "src_vir_width", &(ctx.s32SrcVirWidth),
                    "src vir width. e.g.(1920).", NULL, 0, 0),
        OPT_INTEGER('\0', "src_vir_height", &(ctx.s32SrcVirHeight),
                    "src vir height. e.g.(1080).", NULL, 0, 0),
        OPT_INTEGER('\0', "src_compress", &(ctx.s32SrcCompressMode),
                    "src compress mode. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "src_format", &(ctx.s32SrcPixFormat),
                    "src pixel format. default(0. 0 is NV12).", NULL, 0, 0),
        OPT_INTEGER('\0', "dst_width", &(ctx.s32DstWidth),
                    "dst width. e.g.(1920). <required>", NULL, 0, 0),
        OPT_INTEGER('\0', "dst_height", &(ctx.s32DstHeight),
                    "dst height. e.g.(1080). <required>", NULL, 0, 0),
        OPT_INTEGER('\0', "dst_compress", &(ctx.s32DstCompressMode),
                    "dst compress mode. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "dst_format", &(ctx.s32DstPixFormat),
                    "dst pixel format. default(0. 0 is NV12).", NULL, 0, 0),
        OPT_INTEGER('\0', "osd_width", &(ctx.s32OsdWidth),
                    "osd width. e.g.(1920). <required on OSD>", NULL, 0, 0),
        OPT_INTEGER('\0', "osd_height", &(ctx.s32OsdHeight),
                    "osd height. e.g.(1080). <required on OSD>", NULL, 0, 0),
        OPT_INTEGER('\0', "osd_compress", &(ctx.s32OsdCompressMode),
                    "osd compress mode. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "osd_format", &(ctx.s32OsdPixFormat),
                    "osd pixel format. default(0. 0 is NV12).", NULL, 0, 0),
        OPT_INTEGER('\0', "crop_x", &(ctx.stCropRect.s32X),
                    "crop ratio rect x. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "crop_y", &(ctx.stCropRect.s32Y),
                    "crop ratio rect y. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "crop_w", &(ctx.stCropRect.u32Width),
                    "crop ratio rect width. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "crop_h", &(ctx.stCropRect.u32Height),
                    "crop ratio rect height. default(0).", 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_vgs_test_show_options(&ctx);

    if (ctx.srcFilePath == RK_NULL
        || ctx.s32SrcWidth <= 0
        || ctx.s32SrcHeight <= 0
        || ctx.s32DstWidth <= 0
        || ctx.s32DstHeight <= 0) {
        argparse_usage(&argparse);
        goto __FAILED;
    }
    s32Ret = RK_MPI_SYS_Init();
    if (s32Ret != RK_SUCCESS) {
        goto __FAILED;
    }
    unit_test_mpi_vgs(&ctx);
    s32Ret = RK_MPI_SYS_Exit();
    if (s32Ret != RK_SUCCESS) {
        goto __FAILED;
    }
    RK_LOGD("test done !\n");
__FAILED:
    return 0;
}