xref: /OK3568_Linux_fs/external/rockit/mpi/example/mod/test_mpi_avs.cpp (revision 4882a59341e53eb6f0b4789bf948001014eff981)

/*
 * 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: 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.
 *
 */

#include <string>
#include <cstring>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/poll.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>

#include "rk_mpi_avs.h"
#include "rk_mpi_cal.h"
#include "rk_mpi_mb.h"
#include "rk_mpi_mmz.h"
#include "rk_mpi_venc.h"
#include "rk_mpi_vpss.h"
#include "rk_mpi_vo.h"
#include "rk_mpi_sys.h"

#include "test_common.h"
#include "test_comm_argparse.h"
#include "test_comm_avs.h"
#include "test_comm_vpss.h"
#include "test_comm_sys.h"
#include "test_comm_utils.h"

/* for RK3588 */
#define RK3588_VO_DEV_HDMI         0
#define RK3588_VO_DEV_MIPI         3

static RK_BOOL bExit = RK_FALSE;

typedef struct rkVPSS_CFG_S {
    VPSS_GRP        VpssGrp;
    RK_U32          u32VpssChnCnt;
    VPSS_GRP_ATTR_S stGrpVpssAttr;
    VPSS_CHN_ATTR_S stVpssChnAttr[VPSS_MAX_CHN_NUM];
} VPSS_CFG_S;

typedef struct rkVENC_CFG_S {
    VENC_CHN VencChn;
    VENC_CHN_ATTR_S stAttr;
} VENC_CFG_S;

typedef struct _rkVO_CFG_S {
    VO_DEV                s32DevId;
    VO_CHN                s32ChnId;
    VO_LAYER              s32LayerId;
    VO_VIDEO_LAYER_ATTR_S stVoLayerAttr;
    VO_CHN_ATTR_S         stVoChnAttr;
    VO_CSC_S              stVoCscAttr;
} VO_CFG_S;

static RK_S32 create_venc(VENC_CFG_S *ctx) {
    RK_S32 s32Ret = RK_SUCCESS;
    VENC_RECV_PIC_PARAM_S   stRecvParam;

    memset(&stRecvParam, 0, sizeof(VENC_RECV_PIC_PARAM_S));
    stRecvParam.s32RecvPicNum = -1;

    s32Ret = RK_MPI_VENC_CreateChn(ctx->VencChn, &ctx->stAttr);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("venc [%d] RK_MPI_VENC_CreateChn failed: %#x!",
                ctx->VencChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("venc [%d] RK_MPI_VENC_CreateChn already.", ctx->VencChn);

    s32Ret = RK_MPI_VENC_StartRecvFrame(ctx->VencChn, &stRecvParam);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("venc [%d] RK_MPI_VENC_StartRecvFrame failed: %#x!",
                ctx->VencChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("venc [%d] RK_MPI_VENC_StartRecvFrame already.", ctx->VencChn);

    return RK_SUCCESS;
}

static RK_S32 destroy_venc(VENC_CFG_S *ctx) {
    RK_S32 s32Ret = RK_SUCCESS;

    s32Ret = RK_MPI_VENC_StopRecvFrame(ctx->VencChn);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("venc [%d] RK_MPI_VENC_StopRecvFrame failed: %#x!",
                ctx->VencChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("venc [%d] RK_MPI_VENC_StopRecvFrame already.", ctx->VencChn);

    s32Ret = RK_MPI_VENC_DestroyChn(ctx->VencChn);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("venc [%d] RK_MPI_VENC_DestroyChn failed: %#x!",
                ctx->VencChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("venc [%d] RK_MPI_VENC_DestroyChn already.", ctx->VencChn);

    return RK_SUCCESS;
}

static RK_S32 create_vo(VO_CFG_S *ctx) {
    RK_S32 s32Ret = RK_SUCCESS;
    RK_U32 u32DispBufLen;
    VO_PUB_ATTR_S VoPubAttr;
    VO_LAYER VoLayer = ctx->s32LayerId;
    VO_DEV VoDev = ctx->s32DevId;
    VO_CHN VoChn = ctx->s32ChnId;

    memset(&VoPubAttr, 0, sizeof(VO_PUB_ATTR_S));

    s32Ret = RK_MPI_VO_GetPubAttr(VoDev, &VoPubAttr);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_GetPubAttr failed: %#x!",
                VoDev, VoLayer, VoChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_GetPubAttr already.",
            VoDev, VoLayer, VoChn);

    if (RK3588_VO_DEV_HDMI == VoDev) {
        VoPubAttr.enIntfType = VO_INTF_HDMI;
        VoPubAttr.enIntfSync = VO_OUTPUT_1080P60;
    } else if (RK3588_VO_DEV_MIPI == VoDev) {
        VoPubAttr.enIntfType = VO_INTF_MIPI;
        VoPubAttr.enIntfSync = VO_OUTPUT_DEFAULT;
    }

    s32Ret = RK_MPI_VO_SetPubAttr(VoDev, &VoPubAttr);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_GetPubAttr failed: %#x!",
                VoDev, VoLayer, VoChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_SetPubAttr already.",
            VoDev, VoLayer, VoChn);

    s32Ret = RK_MPI_VO_Enable(VoDev);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_Enable failed: %#x!",
                VoDev, VoLayer, VoChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_Enable already.",
            VoDev, VoLayer, VoChn);

    s32Ret = RK_MPI_VO_GetLayerDispBufLen(VoLayer, &u32DispBufLen);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_GetLayerDispBufLen failed: %#x!",
                VoDev, VoLayer, VoChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_GetLayerDispBufLen already.",
            VoDev, VoLayer, VoChn);

    u32DispBufLen = 3;
    s32Ret = RK_MPI_VO_SetLayerDispBufLen(VoLayer, u32DispBufLen);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_GetLayerDispBufLen %d failed: %#x!",
                VoDev, VoLayer, VoChn, u32DispBufLen, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_GetLayerDispBufLen %d already.",
            VoDev, VoLayer, VoChn, u32DispBufLen);

    s32Ret = RK_MPI_VO_BindLayer(VoLayer, VoDev, VO_LAYER_MODE_GRAPHIC);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_BindLayer failed: %#x!",
                VoDev, VoLayer, VoChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_BindLayer already.",
            VoDev, VoLayer, VoChn);

    s32Ret = RK_MPI_VO_SetLayerAttr(VoLayer, &ctx->stVoLayerAttr);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_SetLayerAttr failed: %#x!",
                VoDev, VoLayer, VoChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_SetLayerAttr already.",
            VoDev, VoLayer, VoChn);

#if VO_RGA
    s32Ret = RK_MPI_VO_SetLayerSpliceMode(VoLayer, VO_SPLICE_MODE_RGA);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("RK_MPI_VO_SetLayerSpliceMode failed: %#x", s32Ret);
        return RK_FAILURE;
    }
#endif

    s32Ret = RK_MPI_VO_EnableLayer(VoLayer);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_EnableLayer failed: %#x!",
                VoDev, VoLayer, VoChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_EnableLayer already.",
            VoDev, VoLayer, VoChn);

    s32Ret = RK_MPI_VO_SetChnAttr(VoLayer, VoChn, &ctx->stVoChnAttr);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_SetChnAttr failed: %#x!",
                VoDev, VoLayer, VoChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_SetChnAttr already.",
            VoDev, VoLayer, VoChn);

    s32Ret = RK_MPI_VO_SetLayerCSC(VoLayer, &ctx->stVoCscAttr);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_SetChnAttr failed: %#x!",
                VoDev, VoLayer, VoChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_SetChnAttr already.",
            VoDev, VoLayer, VoChn);

    s32Ret = RK_MPI_VO_EnableChn(VoLayer, VoChn);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_EnableChn failed: %#x!",
                VoDev, VoLayer, VoChn, s32Ret);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_EnableChn already.",
            VoDev, VoLayer, VoChn);

    return s32Ret;
}

static RK_S32 destroy_vo(VO_CFG_S *ctx) {
    RK_S32 s32Ret = RK_SUCCESS;
    VO_LAYER VoLayer = ctx->s32LayerId;
    VO_DEV VoDev = ctx->s32DevId;
    VO_CHN VoChn = ctx->s32ChnId;

    s32Ret = RK_MPI_VO_DisableChn(VoDev, VoChn);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_DisableChn failed: %#x!",
                VoDev, VoLayer, VoChn);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_DisableChn already.",
            VoDev, VoLayer, VoChn);

    s32Ret = RK_MPI_VO_DisableLayer(VoLayer);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_DisableLayer failed: %#x!",
                VoDev, VoLayer, VoChn);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_DisableLayer already.",
            VoDev, VoLayer, VoChn);

    s32Ret = RK_MPI_VO_Disable(VoDev);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] RK_MPI_VO_Disable failed: %#x!",
                VoDev, VoLayer, VoChn);
        return s32Ret;
    }
    RK_LOGV("vo [%d, %d, %d] RK_MPI_VO_Disable already.",
            VoDev, VoLayer, VoChn);

    return s32Ret;
}

static RK_S32 test_single_avs_loop(TEST_AVS_CTX_S *ctx) {
    RK_S32 s32Ret = RK_SUCCESS;

    s32Ret = TEST_AVS_UnitTest(ctx);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("TEST_AVS_UnitTest failed: %#x!", s32Ret);
        goto __FAILED;
    }

__FAILED:

    return s32Ret;
}

static RK_VOID sigterm_handler(int sig) {
    RK_PRINT("signal %d\n", sig);
    bExit = RK_TRUE;
}

static RK_S32 test_avs_vpss_venc_loop(TEST_AVS_CTX_S *pstAvsCtx) {
    RK_PRINT(" Media link: \n");
    RK_PRINT(" %d pool -> avs -> vpss -> venc(H264) \n", pstAvsCtx->s32PipeNum);
    RK_PRINT("                        -> venc(H265) \n");

    RK_S32 s32Ret     = RK_SUCCESS;
    RK_S32 loopCount  = 0;
    RK_S32 vpssChnCnt = 1;
    RK_S32 vencChnCnt = vpssChnCnt;
    RK_S32 vpssOutputWidth[vpssChnCnt] = {3840};
    RK_S32 vpssOutputHeight[vpssChnCnt] = {2160};

    VPSS_CFG_S  pstVpssCtx;
    VENC_CFG_S *pstVencCtx;
    VIDEO_FRAME_INFO_S **pstPipeFrames;

    pstVencCtx = reinterpret_cast<VENC_CFG_S *>
                                (malloc(sizeof(VENC_CFG_S) * vencChnCnt));
    memset(pstVencCtx, 0, sizeof(VENC_CFG_S) * vencChnCnt);
    pstPipeFrames = reinterpret_cast<VIDEO_FRAME_INFO_S **>(
                        malloc(sizeof(VIDEO_FRAME_INFO_S *) * AVS_PIPE_NUM));
    for (RK_S32 i = 0; i < AVS_PIPE_NUM; i++) {
        pstPipeFrames[i] = reinterpret_cast<VIDEO_FRAME_INFO_S *>(malloc(sizeof(VIDEO_FRAME_INFO_S)));
        memset(pstPipeFrames[i], 0, sizeof(VIDEO_FRAME_INFO_S));
    }

    s32Ret = TEST_AVS_ModCreateFramePool(pstAvsCtx);
    if (s32Ret != RK_SUCCESS) {
        goto __FREE_PIPE_FRAME;
    }

    /* avs create */
    s32Ret = TEST_AVS_ModInit(pstAvsCtx);
    if (s32Ret != RK_SUCCESS) {
        goto __DESTROY_FRAME_POOL;
    }

    /* vpss config init */
    pstVpssCtx.VpssGrp                                   = 0;
    pstVpssCtx.u32VpssChnCnt                             = vpssChnCnt;
    pstVpssCtx.stGrpVpssAttr.u32MaxW                     = 8192;
    pstVpssCtx.stGrpVpssAttr.u32MaxH                     = 8192;
    pstVpssCtx.stGrpVpssAttr.enPixelFormat               = RK_FMT_YUV420SP;
    pstVpssCtx.stGrpVpssAttr.stFrameRate.s32SrcFrameRate = -1;
    pstVpssCtx.stGrpVpssAttr.stFrameRate.s32DstFrameRate = -1;
    pstVpssCtx.stGrpVpssAttr.enCompressMode              = COMPRESS_MODE_NONE;
    for (RK_S32 i = 0; i < vpssChnCnt; i ++) {
        pstVpssCtx.stVpssChnAttr[i].enChnMode                   = VPSS_CHN_MODE_USER;
        pstVpssCtx.stVpssChnAttr[i].enDynamicRange              = DYNAMIC_RANGE_SDR8;
        pstVpssCtx.stVpssChnAttr[i].enPixelFormat               = RK_FMT_YUV420SP;
        pstVpssCtx.stVpssChnAttr[i].stFrameRate.s32SrcFrameRate = -1;
        pstVpssCtx.stVpssChnAttr[i].stFrameRate.s32DstFrameRate = -1;
        pstVpssCtx.stVpssChnAttr[i].u32Width                    = vpssOutputWidth[i];
        pstVpssCtx.stVpssChnAttr[i].u32Height                   = vpssOutputHeight[i];
        pstVpssCtx.stVpssChnAttr[i].enCompressMode              = COMPRESS_AFBC_16x16;
        pstVpssCtx.stVpssChnAttr[i].u32FrameBufCnt              = 3;
        pstVpssCtx.stVpssChnAttr[i].u32Depth                    = 1;
    }

    /* vpss create */
    s32Ret = TEST_VPSS_Start(pstVpssCtx.VpssGrp, pstVpssCtx.u32VpssChnCnt,
                        &pstVpssCtx.stGrpVpssAttr, pstVpssCtx.stVpssChnAttr);
    if (s32Ret != RK_SUCCESS) {
        goto __DESTROY_AVS;
    }

    for (RK_S32 i = 0; i < vencChnCnt; i++) {
        /* venc config init */
        PIC_BUF_ATTR_S   stPicBufAttr;
        MB_PIC_CAL_S     stMbPicCalResult;

        stPicBufAttr.u32Width      = vpssOutputWidth[i];
        stPicBufAttr.u32Height     = vpssOutputHeight[i];
        stPicBufAttr.enCompMode    = COMPRESS_AFBC_16x16;
        stPicBufAttr.enPixelFormat = RK_FMT_YUV420SP;

        s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
        if (s32Ret != RK_SUCCESS) {
            RK_LOGE("get picture buffer size failed: %#x!", s32Ret);
            goto __DESTROY_VENC;
        }

        pstVencCtx[i].VencChn = i;
        pstVencCtx[i].stAttr.stVencAttr.enPixelFormat   = RK_FMT_YUV420SP;
        pstVencCtx[i].stAttr.stVencAttr.u32PicWidth     = vpssOutputWidth[i];
        pstVencCtx[i].stAttr.stVencAttr.u32PicHeight    = vpssOutputHeight[i];
        pstVencCtx[i].stAttr.stVencAttr.u32VirWidth     = vpssOutputWidth[i];
        pstVencCtx[i].stAttr.stVencAttr.u32VirHeight    = vpssOutputHeight[i];
        pstVencCtx[i].stAttr.stVencAttr.u32StreamBufCnt = 3;
        pstVencCtx[i].stAttr.stVencAttr.u32BufSize      = stMbPicCalResult.u32MBSize;
        if (i % 2 == 0) {
            pstVencCtx[i].stAttr.stVencAttr.enType             = RK_VIDEO_ID_AVC;
            pstVencCtx[i].stAttr.stVencAttr.u32Profile         = H264E_PROFILE_HIGH;
            pstVencCtx[i].stAttr.stRcAttr.enRcMode             = VENC_RC_MODE_H264CBR;
            pstVencCtx[i].stAttr.stRcAttr.stH264Cbr.u32Gop     = 60;
            pstVencCtx[i].stAttr.stRcAttr.stH264Cbr.u32BitRate = 65536;
        } else {
            pstVencCtx[i].stAttr.stVencAttr.enType             = RK_VIDEO_ID_HEVC;
            pstVencCtx[i].stAttr.stVencAttr.u32Profile         = H265E_PROFILE_MAIN;
            pstVencCtx[i].stAttr.stRcAttr.enRcMode             = VENC_RC_MODE_H265CBR;
            pstVencCtx[i].stAttr.stRcAttr.stH265Cbr.u32Gop     = 60;
            pstVencCtx[i].stAttr.stRcAttr.stH264Cbr.u32BitRate = 16384;
        }
        /* venc create */
        s32Ret = create_venc(&pstVencCtx[i]);
        if (s32Ret != RK_SUCCESS) {
            goto __DESTROY_VENC;
        }
    }

    /* bind avs -> vpss */
    s32Ret = TEST_SYS_AvsBindVpss(0, 0, pstVpssCtx.VpssGrp);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("bind failed: %x, avs [%d, %d] -> vpss [%d]",
                s32Ret, 0, 0, pstVpssCtx.VpssGrp);
        goto __DESTROY_VENC;
    }
    RK_LOGV("bind success, avs [%d, %d] -> vpss [%d]",
            0, 0, pstVpssCtx.VpssGrp);

    /* bind vpss -> venc */
    for (RK_S32 i = 0; i < vpssChnCnt; i++) {
        s32Ret = TEST_SYS_VpssBindVenc(0, i, i);
        if (s32Ret != RK_SUCCESS) {
            RK_LOGE("bind failed: %x, vpss [%d, %d] -> venc [%d]",
                    s32Ret, 0, i, i);
            goto __UNBIND_AVS_VPSS;
        }
        RK_LOGV("bind success, vpss [%d, %d] -> venc [%d]",
                0, i, i);
    }

    /* thread: do somethings */
    signal(SIGINT, sigterm_handler);
    if (pstAvsCtx->s32LoopCount > 0) {
        VENC_STREAM_S stVencStream;
        stVencStream.pstPack = reinterpret_cast<VENC_PACK_S *>(malloc(sizeof(VENC_PACK_S)));

        while (!bExit && loopCount < pstAvsCtx->s32LoopCount) {
            s32Ret = TEST_AVS_ModGetFrameFromPool(pstAvsCtx, pstPipeFrames);

            s32Ret = TEST_AVS_ModSendFrame(pstAvsCtx->s32GrpIndex, pstAvsCtx->s32PipeNum, pstPipeFrames);
            if (s32Ret != RK_SUCCESS) {
                TEST_AVS_ModReleaseFrameToPool(pstAvsCtx, pstPipeFrames);
                continue;
            }

            TEST_AVS_ModReleaseFrameToPool(pstAvsCtx, pstPipeFrames);

            for (RK_S32 i = 0; i < vencChnCnt; i++) {
                s32Ret = RK_MPI_VENC_GetStream(i, &stVencStream, 100);
                if (s32Ret >= 0) {
                    RK_MPI_VENC_ReleaseStream(i, &stVencStream);
                }
            }

            usleep(33 * 1000);
            loopCount++;
        }

        if (stVencStream.pstPack) {
            free(stVencStream.pstPack);
        }
    }

__UNBIND_VPSS_VENC:
    /* unbind avs -> vpss */
    s32Ret = TEST_SYS_AvsUnbindVpss(0, 0, pstVpssCtx.VpssGrp);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("unbind failed: %x, avs [%d, %d] -> vpss [%d]",
                s32Ret, 0, 0, pstVpssCtx.VpssGrp);
    }
    RK_LOGV("unbind success, avs [%d, %d] -> vpss [%d]",
            0 , 0, pstVpssCtx.VpssGrp);

__UNBIND_AVS_VPSS:
    /* unbind vpss -> venc */
    for (RK_S32 i = 0; i < vpssChnCnt; i++) {
        s32Ret = TEST_SYS_VpssUnbindVenc(0, i, i);
        if (s32Ret != RK_SUCCESS) {
            RK_LOGE("unbind failed: %x, vpss [%d, %d] -> venc [%d]",
                    s32Ret, pstVpssCtx.VpssGrp, i, i);
        }
        RK_LOGV("unbind success, vpss [%d, %d] -> venc [%d]",
                pstVpssCtx.VpssGrp, i, i);
    }

__DESTROY_VENC:
    /* destroy venc */
    for (RK_S32 i = 0; i < vencChnCnt; i++) {
        s32Ret = destroy_venc(&pstVencCtx[i]);
        if (s32Ret != RK_SUCCESS) {
            RK_LOGE("venc [%d] destroy_venc failed: %#x", i, s32Ret);
        }
        RK_LOGV("venc [%d] destroy_venc already.", i);
    }

__DESTROY_VPSS:
    /* destroy vpss */
    s32Ret = TEST_VPSS_Stop(pstVpssCtx.VpssGrp, pstVpssCtx.u32VpssChnCnt);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vpss [%d] TEST_VPSS_Stop failed: %#x", pstVpssCtx.VpssGrp, s32Ret);
    }
    RK_LOGV("vpss [%d] TEST_VPSS_Stop already.", pstVpssCtx.VpssGrp);

__DESTROY_AVS:
    /* destroy avs */
    s32Ret = TEST_AVS_ModDeInit(pstAvsCtx);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("avs [%d] TEST_AVS_ModDeInit failed: %#x", pstAvsCtx->s32GrpIndex, s32Ret);
    }
    RK_LOGV("avs [%d] TEST_AVS_ModDeInit already.", pstAvsCtx->s32GrpIndex);

__DESTROY_FRAME_POOL:

    s32Ret = TEST_AVS_ModDestroyFramePool(pstAvsCtx);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("avs [%d] TEST_AVS_ModDestroyFramePool failed: %#x",
                pstAvsCtx->s32GrpIndex, s32Ret);
    }
    RK_LOGV("avs [%d] TEST_AVS_ModDestroyFramePool already.",
            pstAvsCtx->s32GrpIndex);

__FREE_PIPE_FRAME:

    for (RK_S32 i = 0; i < AVS_PIPE_NUM; i++) {
        RK_SAFE_FREE(pstPipeFrames[i]);
    }

    RK_SAFE_FREE(pstPipeFrames);

__FREE_VENC_CFG:

    RK_SAFE_FREE(pstVencCtx);

    return s32Ret;
}

static RK_S32 test_avs_vo_loop(TEST_AVS_CTX_S *pstAvsCtx) {
    RK_PRINT(" Media link: \n");
    RK_PRINT(" %d avs -> vo (HDMI) \n", pstAvsCtx->s32PipeNum);

    RK_S32 s32Ret    = RK_SUCCESS;
    RK_S32 loopCount = 0;
    VO_CFG_S pstVoCtx;
    VIDEO_FRAME_INFO_S **pstPipeFrames;

    pstPipeFrames = reinterpret_cast<VIDEO_FRAME_INFO_S **>(
                        malloc(sizeof(VIDEO_FRAME_INFO_S *) * AVS_PIPE_NUM));
    for (RK_S32 i = 0; i < AVS_PIPE_NUM; i++) {
        pstPipeFrames[i] = reinterpret_cast<VIDEO_FRAME_INFO_S *>(malloc(sizeof(VIDEO_FRAME_INFO_S)));
        memset(pstPipeFrames[i], 0, sizeof(VIDEO_FRAME_INFO_S));
    }

    s32Ret = TEST_AVS_ModCreateFramePool(pstAvsCtx);
    if (s32Ret != RK_SUCCESS) {
        goto __FREE_PIPE_FRAME;
    }

    /* avs create */
    s32Ret = TEST_AVS_ModInit(pstAvsCtx);
    if (s32Ret != RK_SUCCESS) {
        goto __DESTROY_FRAME_POOL;
    }

    /* vo config init */
    pstVoCtx.s32LayerId = 0;
    pstVoCtx.s32DevId   = RK3588_VO_DEV_HDMI;

    if (RK3588_VO_DEV_HDMI == pstVoCtx.s32DevId) {
        pstVoCtx.stVoLayerAttr.stDispRect.u32Width = 1920;
        pstVoCtx.stVoLayerAttr.stDispRect.u32Height = 1080;
    } else if (RK3588_VO_DEV_MIPI == pstVoCtx.s32DevId) {
        pstVoCtx.stVoLayerAttr.stDispRect.u32Width = 1080;
        pstVoCtx.stVoLayerAttr.stDispRect.u32Height = 1920;
    }
    pstVoCtx.stVoLayerAttr.enPixFormat = RK_FMT_RGB888;

    pstVoCtx.s32ChnId = 0;
    pstVoCtx.stVoCscAttr.enCscMatrix = VO_CSC_MATRIX_IDENTITY;
    pstVoCtx.stVoCscAttr.u32Contrast = 50;
    pstVoCtx.stVoCscAttr.u32Hue = 50;
    pstVoCtx.stVoCscAttr.u32Luma = 50;
    pstVoCtx.stVoCscAttr.u32Satuature = 50;

    pstVoCtx.stVoLayerAttr.stDispRect.s32X = 0;
    pstVoCtx.stVoLayerAttr.stDispRect.s32Y = 0;
    pstVoCtx.stVoLayerAttr.stImageSize.u32Width =
        pstVoCtx.stVoLayerAttr.stDispRect.u32Width;
    pstVoCtx.stVoLayerAttr.stImageSize.u32Height =
        pstVoCtx.stVoLayerAttr.stDispRect.u32Height;

    pstVoCtx.stVoLayerAttr.u32DispFrmRt = 30;
    pstVoCtx.stVoChnAttr.stRect.s32X = 0;
    pstVoCtx.stVoChnAttr.stRect.s32Y = 0;
    pstVoCtx.stVoChnAttr.stRect.u32Width =
        pstVoCtx.stVoLayerAttr.stImageSize.u32Width;
    pstVoCtx.stVoChnAttr.stRect.u32Height =
        pstVoCtx.stVoLayerAttr.stImageSize.u32Height;
    pstVoCtx.stVoChnAttr.bDeflicker = RK_FALSE;
    pstVoCtx.stVoChnAttr.u32Priority = 1;
    pstVoCtx.stVoChnAttr.u32FgAlpha = 128;
    pstVoCtx.stVoChnAttr.u32BgAlpha = 0;

    /* vo creat */
    s32Ret = create_vo(&pstVoCtx);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] create failed: %x",
                pstVoCtx.s32DevId,
                pstVoCtx.s32LayerId,
                pstVoCtx.s32ChnId,
                s32Ret);
        goto __DESTROY_AVS;
    }

    /* bind avs -> vo */
    s32Ret = TEST_SYS_AvsBindVo(0, 0, 0, 0);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("bind failed: %x, avs [%d, %d] -> vo [%d, %d]",
                s32Ret, 0, 0, 0, 0);
        goto __DESTROY_VO;
    }
    RK_LOGV("bind success, avs [%d, %d] -> vo [%d, %d]",
            0 , 0, 0, 0);

    /* thread: do somethings */
    signal(SIGINT, sigterm_handler);
    if (pstAvsCtx->s32LoopCount > 0) {
        while (!bExit && loopCount < pstAvsCtx->s32LoopCount) {
            s32Ret = TEST_AVS_ModGetFrameFromPool(pstAvsCtx, pstPipeFrames);

            s32Ret = TEST_AVS_ModSendFrame(pstAvsCtx->s32GrpIndex, pstAvsCtx->s32PipeNum, pstPipeFrames);
            if (s32Ret != RK_SUCCESS) {
                TEST_AVS_ModReleaseFrameToPool(pstAvsCtx, pstPipeFrames);
                continue;
            }

            TEST_AVS_ModReleaseFrameToPool(pstAvsCtx, pstPipeFrames);
            usleep(1000);
            loopCount++;
        }
    }

__UNBIND_AVS_VO:
    /* unbind avs -> vo */
    s32Ret = TEST_SYS_AvsUnbindVo(0, 0, 0, 0);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("bind failed: %x, avs [%d, %d] -> vo [%d, %d]",
                s32Ret, pstAvsCtx->s32GrpIndex, 0,
                pstVoCtx.s32DevId, pstVoCtx.s32ChnId);
    }
    RK_LOGV("unbind success, avs [%d, %d] -> vo [%d, %d]",
            pstAvsCtx->s32GrpIndex, 0,
            pstVoCtx.s32DevId, pstVoCtx.s32ChnId);

__DESTROY_VO:
    /* destroy vo */
    s32Ret = destroy_vo(&pstVoCtx);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("vo [%d, %d, %d] destroy_vo failed: %#x",
                pstVoCtx.s32DevId, pstVoCtx.s32LayerId,
                pstVoCtx.s32ChnId, s32Ret);
    }
    RK_LOGV("vo [%d, %d, %d] destroy_vo already.",
            pstVoCtx.s32DevId, pstVoCtx.s32LayerId,
            pstVoCtx.s32ChnId);

__DESTROY_AVS:
    /* destroy avs */
    s32Ret = TEST_AVS_ModDeInit(pstAvsCtx);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("avs [%d] TEST_AVS_ModDeInit failed: %#x", pstAvsCtx->s32GrpIndex, s32Ret);
    }
    RK_LOGV("avs [%d] TEST_AVS_ModDeInit already.", pstAvsCtx->s32GrpIndex);

__DESTROY_FRAME_POOL:
    s32Ret = TEST_AVS_ModDestroyFramePool(pstAvsCtx);
    if (s32Ret != RK_SUCCESS) {
        RK_LOGE("avs [%d] TEST_AVS_ModDestroyFramePool failed: %#x",
                pstAvsCtx->s32GrpIndex, s32Ret);
    }
    RK_LOGV("avs [%d] TEST_AVS_ModDestroyFramePool already.",
            pstAvsCtx->s32GrpIndex);

__FREE_PIPE_FRAME:
    for (RK_S32 i = 0; i < AVS_PIPE_NUM; i++) {
        RK_SAFE_FREE(pstPipeFrames[i]);
    }

    RK_SAFE_FREE(pstPipeFrames);

    return s32Ret;
}

static const char *const usages[] = {
    "./rk_mpi_avs_test [--test_mode TEST_MODE] [-c COMPRESS_MODE] [-n LOOP_COUNT] [-p PIPE_NUM]",
    RK_NULL,
};

static void mpi_avs_test_show_options(const TEST_AVS_CTX_S *ctx) {
    RK_PRINT("cmd parse result:\n");
    RK_PRINT("input file path      : %s\n", ctx->srcFilePath);
    RK_PRINT("output file path     : %s\n", ctx->dstFilePath);
    RK_PRINT("test mode            : %d\n", ctx->enTestMode);
    RK_PRINT("group number         : %d\n", ctx->s32GrpNum);
    RK_PRINT("pipe number          : %d\n", ctx->s32PipeNum);
    RK_PRINT("channel number       : %d\n", ctx->s32ChnNum);
    RK_PRINT("loop count           : %d\n", ctx->s32LoopCount);
    RK_PRINT("input width          : %d\n", ctx->u32SrcWidth);
    RK_PRINT("input height         : %d\n", ctx->u32SrcHeight);
    RK_PRINT("input virtual width  : %d\n", ctx->u32SrcVirWidth);
    RK_PRINT("input virtual height : %d\n", ctx->u32SrcVirHeight);
    RK_PRINT("input pixel format   : %d\n", ctx->enSrcPixFormat);
    RK_PRINT("input compress mode  : %d\n", ctx->enSrcCompressMode);
    RK_PRINT("output width         : %d\n", ctx->u32DstWidth);
    RK_PRINT("output height        : %d\n", ctx->u32DstHeight);
    RK_PRINT("output pixel format  : %d\n", ctx->enDstPixFormat);
    RK_PRINT("output compress mode : %d\n", ctx->enDstCompressMode);
    RK_PRINT("work mode            : %d\n", ctx->enAvsWorkMode);
    RK_PRINT("projection mode      : %d\n", ctx->enAvsProjMode);
    RK_PRINT("params sources       : %d\n", ctx->enParamSource);
    RK_PRINT("lut file path        : %s\n", ctx->lutFilePath);
    RK_PRINT("lut accuracy         : %d\n", ctx->enLutAccuracy);
    RK_PRINT("lut fuse width       : %d\n", ctx->enLutFuseWidth);
    RK_PRINT("lut step x           : %d\n", ctx->stLutStep.enStepX);
    RK_PRINT("lut step y           : %d\n", ctx->stLutStep.enStepY);
    RK_PRINT("calib file name      : %s\n", ctx->calibFileName);
    RK_PRINT("mesh file path       : %s\n", ctx->meshFilePath);
    RK_PRINT("avs frame sync       : %d\n", ctx->bFrameSync);
    RK_PRINT("center x             : %d\n", ctx->stCenter.s32X);
    RK_PRINT("center x             : %d\n", ctx->stCenter.s32Y);
    RK_PRINT("fov x                : %d\n", ctx->stFov.u32FOVX);
    RK_PRINT("fov y                : %d\n", ctx->stFov.u32FOVY);
    RK_PRINT("rotation ori yaw     : %d\n", ctx->stOriRotation.s32Yaw);
    RK_PRINT("rotation ori pitch   : %d\n", ctx->stOriRotation.s32Pitch);
    RK_PRINT("rotation ori roll    : %d\n", ctx->stOriRotation.s32Roll);
    RK_PRINT("rotation yaw         : %d\n", ctx->stRotation.s32Yaw);
    RK_PRINT("rotation pitch       : %d\n", ctx->stRotation.s32Pitch);
    RK_PRINT("rotation roll        : %d\n", ctx->stRotation.s32Roll);
    RK_PRINT("distance             : %3.2f\n", ctx->fDistance);
    RK_PRINT("enable comm mb pool  : %d\n", ctx->bCommPool);
}

RK_S32 main(int argc, const char **argv) {
    RK_S32 s32Ret = RK_FAILURE;
    TEST_AVS_CTX_S   ctx;

    memset(&ctx, 0, sizeof(TEST_AVS_CTX_S));

    ctx.dstFilePath        = RK_NULL;

    ctx.s32LoopCount       = 1;
    ctx.enTestMode         = TEST_MODE_AVS_ONLY;
    ctx.enParamSource      = AVS_PARAM_SOURCE_CALIB;
    ctx.bFrameSync         = RK_FALSE;
    ctx.enAvsWorkMode      = AVS_MODE_BLEND;
    ctx.s32GrpNum          = 1;
    ctx.s32ChnNum          = 1;
    ctx.s32PipeNum         = 6;
    ctx.s32GrpIndex        = 0;
    ctx.u32ChnDepth        = 1;
    ctx.u32FrameBufCnt     = 3;
    ctx.s32SrcChnRate      = -1;
    ctx.s32DstChnRate      = -1;
    ctx.s32SrcGrpRate      = -1;
    ctx.s32DstGrpRate      = -1;
    ctx.fDistance          = 1.0;

    RK_LOGE("avs test running enter!");

    struct argparse_option options[] = {
        OPT_HELP(),
        OPT_GROUP("basic options:"),
        OPT_STRING('i', "input",  &(ctx.srcFilePath),
                   "input file name. e.g.(/userdata/6x_equirectangular/input_image/). default(NULL).", NULL, 0, 0),
        OPT_STRING('o', "output", &(ctx.dstFilePath),
                    "output file path. e.g.(/userdata/res/). default(NULL).", NULL, 0, 0),
        OPT_INTEGER('\0', "test_mode", &(ctx.enTestMode),
                    "test mode. default(0. 0: avs single mod test, 1: multi mods bind test).", NULL, 0, 0),
        OPT_INTEGER('n', "loop count", &(ctx.s32LoopCount),
                    "loop running count. default(1).", NULL, 0, 0),
        OPT_INTEGER('g', "group_count", &(ctx.s32GrpNum),
                    "the count of avs group. default(1).", NULL, 0, 0),
        OPT_INTEGER('p', "pipe_count", &(ctx.s32PipeNum),
                    "the count of avs pipe. default(6).", NULL, 0, 0),
        OPT_INTEGER('c', "channel_count", &(ctx.s32ChnNum),
                    "the count of avs channel. default(1).", NULL, 0, 0),
        OPT_INTEGER('w', "src_width", &(ctx.u32SrcWidth),
                    "src width. e.g.(2560). <required>.", NULL, 0, 0),
        OPT_INTEGER('h', "src_height", &(ctx.u32SrcHeight),
                    "src height. e.g.(1520). <required>.", NULL, 0, 0),
        OPT_INTEGER('\0', "src_vir_width", &(ctx.u32SrcVirWidth),
                    "src virtual width. e.g.(2560). default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "src_vir_height", &(ctx.u32SrcVirHeight),
                    "src virtual height. e.g.(1520). default(0).", NULL, 0, 0),
        OPT_INTEGER('f', "src_format", &(ctx.enSrcPixFormat),
                    "src pixel format. default(only 0. 0 is NV12).", NULL, 0, 0),
        OPT_INTEGER('m', "src_compress", &(ctx.enSrcCompressMode),
                    "src compress mode. default(0. 0: NONE, 1: AFBC).", NULL, 0, 0),
        OPT_INTEGER('W', "dst_width", &(ctx.u32DstWidth),
                    "dst width. e.g.(8192). <required>.", NULL, 0, 0),
        OPT_INTEGER('H', "dst_height", &(ctx.u32DstHeight),
                    "dst height. e.g.(3840). <required>.", NULL, 0, 0),
        OPT_INTEGER('M', "dst_compress", &(ctx.enDstCompressMode),
                    "dst compress mode. default(0. 0: NONE, 1: AFBC).", NULL, 0, 0),
        OPT_INTEGER('F', "dst_format", &(ctx.enDstPixFormat),
                    "dst pixel format. default(only 0. 0 is NV12).", NULL, 0, 0),
        OPT_INTEGER('\0', "work_mode", &(ctx.enAvsWorkMode),
                    "work mode. default(0. 0: BLEND, 1: NOBLEND_VER, 2: NOBLEND_HOR, 3: NOBLEND_QR).",
                    NULL, 0, 0),
        OPT_INTEGER('\0', "proj_mode", &(ctx.enAvsProjMode),
                    "projection mode. default(0. 0: EQUIRECTANGULAR, 1: RECTILINEAR, 2: CYLINDRICAL,"
                    "3: CUBE_MAP, 4: EQUIRECTANGULAR_TRANS).",
                    NULL, 0, 0),
        OPT_INTEGER('\0', "frame_sync", &(ctx.bFrameSync),
                    "whether enable avs frame sync. default(0. 0: Disable, 1: Enable).", NULL, 0, 0),
        OPT_INTEGER('\0', "param_source", &(ctx.enParamSource),
                    "params required for stitch are obtained by lut or calib. default(1. 0: Lut, 1: Calib).",
                    NULL, 0, 0),
        OPT_STRING('\0', "lut_file_path",  &(ctx.lutFilePath),
                    "lut file path. e.g.(/userdata/6x_equirectangular/middle_lut/). default(NULL).", NULL, 0, 0),
        OPT_INTEGER('\0', "lut_accuracy", &(ctx.enLutAccuracy),
                    "lut accuracy. default(0, 0: HIGH, 1: LOW).", NULL, 0, 0),
        OPT_INTEGER('\0', "lut_use_width", &(ctx.enLutFuseWidth),
                    "lut fuse width. default(0, 0: 128 pixel, 1: 256 pixel, 2: 512 pixel).", NULL, 0, 0),
        OPT_INTEGER('\0', "lut_step_x", &(ctx.stLutStep.enStepX),
                    "lut step in the x-axis direction. default(0, 0: 16 pixel, 1: 32 pixel, 2: 64 pixel).", NULL, 0, 0),
        OPT_INTEGER('\0', "lut_step_y", &(ctx.stLutStep.enStepY),
                    "lut step in the y-axis direction. default(0, 0: 16 pixel, 1: 32 pixel, 2: 64 pixel).", NULL, 0, 0),
        OPT_STRING('\0', "calib_file_name",  &(ctx.calibFileName),
                   "calib file name. e.g.(/userdata/avs/6x_equirectangular/avs_calib/calib_file.pto). default(NULL).",
                   NULL, 0, 0),
        OPT_STRING('\0', "mesh_file_path",  &(ctx.meshFilePath),
                   "mesh file path. e.g.(/userdata/avs/6x_equirectangular/avs_mesh/). default(NULL).", NULL, 0, 0),
        OPT_INTEGER('\0', "center_x", &(ctx.stCenter.s32X),
                    "center point in the x-axis direction. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "center_y", &(ctx.stCenter.s32Y),
                    "center point in the y-axis direction. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "fov_x", &(ctx.stFov.u32FOVX),
                    "fov size in the x-axis direction. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "fov_y", &(ctx.stFov.u32FOVY),
                    "fov size in the y-axis direction. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "ori_yaw", &(ctx.stOriRotation.s32Yaw),
                    "ori rotation in the yaw direction. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "ori_pitch", &(ctx.stOriRotation.s32Pitch),
                    "ori rotation in the pitch direction. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "ori_roll", &(ctx.stOriRotation.s32Roll),
                    "ori rotation in the roll direction. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "yaw", &(ctx.stRotation.s32Yaw),
                    "rotation in the yaw direction. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "pitch", &(ctx.stRotation.s32Pitch),
                    "rotation in the pitch direction. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "distance", &(ctx.fDistance),
                    "optimal stitch distance. default(1.0).", NULL, 0, 0),
        OPT_INTEGER('\0', "src_grp_rate", &(ctx.s32SrcGrpRate),
                    "src avs group frame rate, default(-1).", NULL, 0, 0),
        OPT_INTEGER('\0', "dst_grp_rate", &(ctx.s32DstGrpRate),
                    "dst avs group frame rate, default(-1).", NULL, 0, 0),
        OPT_INTEGER('d', "chn_depth", &(ctx.u32ChnDepth),
                    "channel output depth, default(3)", NULL, 0, 0),
        OPT_INTEGER('b', "chn_buf_cnt", &(ctx.u32FrameBufCnt),
                    "channel output buf cnt, default(3)", NULL, 0, 0),
        OPT_INTEGER('\0', "roll", &(ctx.stRotation.s32Roll),
                    "rotation in the roll direction. default(0).", NULL, 0, 0),
        OPT_INTEGER('\0', "src_chn_rate", &(ctx.s32SrcChnRate),
                    "src avs channel frame rate, default(-1).", NULL, 0, 0),
        OPT_INTEGER('\0', "dst_chn_rate", &(ctx.s32DstChnRate),
                    "dst avs channel frame rate, default(-1).", NULL, 0, 0),
        OPT_BOOLEAN('\0', "comm_mb_pool", &(ctx.bCommPool),
                    "whether enable common mb pool, default(0, 0: Disable, 1: Enable).", NULL, 0, 0),
        OPT_GROUP("external options:"),
        OPT_BOOLEAN('\0', "get_final_lut", &(ctx.bGetFinalLut),
                    "whether get final lut, default(0, 0: Disable, 1: Enable).", 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_avs_test_show_options(&ctx);

    if (ctx.u32SrcWidth <= 0
        || ctx.u32SrcHeight <= 0
        || ctx.u32DstWidth <= 0
        || ctx.u32DstHeight <= 0) {
        argparse_usage(&argparse);
        return RK_FAILURE;
    }

    s32Ret = RK_MPI_SYS_Init();
    if (s32Ret != RK_SUCCESS) {
        return s32Ret;
    }

    switch (ctx.enTestMode) {
        case TEST_MODE_AVS_ONLY: {
            s32Ret = test_single_avs_loop(&ctx);
            if (s32Ret != RK_SUCCESS) {
                goto __FAILED;
            }
        } break;
        case TEST_MODE_AVS_VO: {
            s32Ret = test_avs_vo_loop(&ctx);
            if (s32Ret != RK_SUCCESS) {
                goto __FAILED;
            }
        } break;
        case TEST_MODE_AVS_VPSS_VENC: {
            s32Ret = test_avs_vpss_venc_loop(&ctx);
            if (s32Ret != RK_SUCCESS) {
                goto __FAILED;
            }
        } break;
        default:
            RK_LOGE("unsupport test mode: %d", ctx.enTestMode);
        break;
    }

    s32Ret = RK_MPI_SYS_Exit();
    if (s32Ret != RK_SUCCESS) {
        return s32Ret;
    }
    RK_LOGV("test running ok.");

    return RK_SUCCESS;

__FAILED:
    RK_LOGE("test running exit: %x", s32Ret);
    RK_MPI_SYS_Exit();

    return s32Ret;
}