new/external/rockit/mpi/example/common/test_comm_venc.cpp
2025-05-10 21:58:58 +08:00

628 lines
22 KiB
C++

/*
* Copyright 2021 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.
*/
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif /* End of #ifdef __cplusplus */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <errno.h>
#include "test_comm_venc.h"
#include "test_comm_imgproc.h"
#include "rk_comm_venc.h"
#include "rk_common.h"
#include "rk_debug.h"
#include "rk_mpi_venc.h"
#include "rk_mpi_cal.h"
#include "rk_mpi_sys.h"
#include "rk_mpi_mb.h"
#define TEST_VENC_PATH_LENGTH 128
#define TEST_VENC_TIME_OUT_MS 100
typedef struct test_venc_getstream_s {
RK_BOOL bThreadStart;
FILE *fp;
pthread_t VencPid;
MB_POOL pool;
COMMON_TEST_VENC_CTX_S stVencCtx;
} TEST_VENC_THREAD_S;
// get stream thread info
static TEST_VENC_THREAD_S gGSThread[VENC_MAX_CHN_NUM];
// send frame thread info
static TEST_VENC_THREAD_S gSFThread[VENC_MAX_CHN_NUM];
static RK_S32 TEST_VENC_StartSendFrame(COMMON_TEST_VENC_CTX_S *vencCtx);
static RK_S32 TEST_VENC_StopSendFrame(VENC_CHN VencChn);
static RK_S32 TEST_VENC_StartGetStream(COMMON_TEST_VENC_CTX_S *vencCtx);
static RK_S32 TEST_VENC_StopGetStream(VENC_CHN VencChn);
static RK_VOID TEST_VECN_DestroyPool(VENC_CHN VencChn);
RK_S32 TEST_VENC_Create(COMMON_TEST_VENC_CTX_S *vencCtx) {
RK_S32 s32Ret = RK_SUCCESS;
VENC_CHN_ATTR_S stAttr;
memset(&stAttr, 0, sizeof(VENC_CHN_ATTR_S));
stAttr.stVencAttr.enType = vencCtx->enType;
if (vencCtx->enType == RK_VIDEO_ID_AVC)
stAttr.stVencAttr.u32Profile = H264E_PROFILE_HIGH;
else if (vencCtx->enType == RK_VIDEO_ID_HEVC)
stAttr.stVencAttr.u32Profile = H265E_PROFILE_MAIN;
stAttr.stVencAttr.enPixelFormat = vencCtx->enPixFmt;
stAttr.stVencAttr.u32PicWidth = vencCtx->u32Width;
stAttr.stVencAttr.u32PicHeight = vencCtx->u32Height;
stAttr.stVencAttr.u32VirWidth = vencCtx->u32Width;
stAttr.stVencAttr.u32VirHeight = vencCtx->u32Height;
stAttr.stVencAttr.u32StreamBufCnt = vencCtx->u32StreamBufCnt;
stAttr.stVencAttr.u32BufSize = vencCtx->u32Width * vencCtx->u32Height;
s32Ret = RK_MPI_VENC_CreateChn(vencCtx->VencChn, &stAttr);
return s32Ret;
}
RK_S32 TEST_VENC_Start(COMMON_TEST_VENC_CTX_S *vencCtx) {
RK_S32 s32Ret = RK_SUCCESS;
VENC_RECV_PIC_PARAM_S stRecvParam;
memset(&stRecvParam, 0, sizeof(VENC_RECV_PIC_PARAM_S));
stRecvParam.s32RecvPicNum = -1;
s32Ret = TEST_VENC_Create(vencCtx);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
s32Ret = RK_MPI_VENC_StartRecvFrame(vencCtx->VencChn, &stRecvParam);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
s32Ret = TEST_VENC_StartSendFrame(vencCtx);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
s32Ret = TEST_VENC_StartGetStream(vencCtx);
return s32Ret;
}
RK_S32 TEST_VENC_Stop(VENC_CHN VencChn) {
RK_S32 s32Ret = RK_SUCCESS;
s32Ret = TEST_VENC_StopSendFrame(VencChn);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
s32Ret = TEST_VENC_StopGetStream(VencChn);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
s32Ret = RK_MPI_VENC_StopRecvFrame(VencChn);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
s32Ret = RK_MPI_VENC_DestroyChn(VencChn);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
TEST_VECN_DestroyPool(VencChn);
return s32Ret;
}
// should TEST_VENC_Create first
RK_S32 TEST_VENC_SnapStart(COMMON_TEST_VENC_CTX_S *vencCtx) {
RK_S32 s32Ret = RK_SUCCESS;
VENC_RECV_PIC_PARAM_S stRecvParam;
memset(&stRecvParam, 0, sizeof(VENC_RECV_PIC_PARAM_S));
stRecvParam.s32RecvPicNum = vencCtx->s32RecvPicNum;
s32Ret = RK_MPI_VENC_StartRecvFrame(vencCtx->VencChn, &stRecvParam);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
s32Ret = TEST_VENC_StartSendFrame(vencCtx);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
return s32Ret;
}
RK_S32 TEST_VENC_SnapStop(VENC_CHN VencChn) {
RK_S32 s32Ret = RK_SUCCESS;
s32Ret = TEST_VENC_StopSendFrame(VencChn);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
s32Ret = RK_MPI_VENC_StopRecvFrame(VencChn);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
s32Ret = RK_MPI_VENC_DestroyChn(VencChn);
if (s32Ret != RK_SUCCESS) {
return s32Ret;
}
TEST_VECN_DestroyPool(VencChn);
return s32Ret;
}
RK_S32 TEST_VENC_SnapProcess(COMMON_TEST_VENC_CTX_S *vencCtx) {
FILE *fp = RK_NULL;
void *pData = RK_NULL;
RK_S32 s32Ret = RK_SUCCESS;
RK_S32 s32StreamCnt = 0;
VENC_STREAM_S stVencStream;
if (vencCtx->pSaveStreamPath != RK_NULL) {
fp = fopen(vencCtx->pSaveStreamPath, "wb");
if (fp == RK_NULL) {
RK_LOGE("can't open file %s!", vencCtx->pSaveStreamPath);
return RK_FAILURE;
}
}
stVencStream.pstPack = reinterpret_cast<VENC_PACK_S *>(malloc(sizeof(VENC_PACK_S)));
while (1) {
s32Ret = RK_MPI_VENC_GetStream(vencCtx->VencChn, &stVencStream, TEST_VENC_TIME_OUT_MS);
if (s32Ret >= 0) {
if (fp != RK_NULL) {
pData = RK_MPI_MB_Handle2VirAddr(stVencStream.pstPack->pMbBlk);
RK_MPI_SYS_MmzFlushCache(stVencStream.pstPack->pMbBlk, RK_TRUE);
fwrite(pData, 1, stVencStream.pstPack->u32Len, fp);
fflush(fp);
}
if (stVencStream.pstPack->bStreamEnd == RK_TRUE) {
RK_LOGI("get chn %d stream %d", vencCtx->VencChn, stVencStream.u32Seq + 1);
RK_LOGI("chn %d reach EOS stream", vencCtx->VencChn);
RK_MPI_VENC_ReleaseStream(vencCtx->VencChn, &stVencStream);
break;
}
RK_MPI_VENC_ReleaseStream(vencCtx->VencChn, &stVencStream);
} else {
usleep(1000llu);
}
}
if (stVencStream.pstPack)
free(stVencStream.pstPack);
if (fp)
fclose(fp);
return RK_SUCCESS;
}
static RK_VOID TEST_VECN_DestroyPool(VENC_CHN VencChn) {
if (gSFThread[VencChn].pool)
RK_MPI_MB_DestroyPool(gSFThread[VencChn].pool);
}
static RK_VOID* TEST_VENC_GetVencStreamProc(RK_VOID *p) {
TEST_VENC_THREAD_S *pstThreadInfo = (TEST_VENC_THREAD_S *)p;
void *pData = RK_NULL;
RK_S32 s32Ret = RK_SUCCESS;
VENC_STREAM_S stVencStream;
stVencStream.pstPack = reinterpret_cast<VENC_PACK_S *>(malloc(sizeof(VENC_PACK_S)));
while (RK_TRUE == pstThreadInfo->bThreadStart) {
s32Ret = RK_MPI_VENC_GetStream(pstThreadInfo->stVencCtx.VencChn, &stVencStream, TEST_VENC_TIME_OUT_MS);
if (s32Ret >= 0) {
if (pstThreadInfo->fp != RK_NULL) {
pData = RK_MPI_MB_Handle2VirAddr(stVencStream.pstPack->pMbBlk);
RK_MPI_SYS_MmzFlushCache(stVencStream.pstPack->pMbBlk, RK_TRUE);
fwrite(pData, 1, stVencStream.pstPack->u32Len, pstThreadInfo->fp);
fflush(pstThreadInfo->fp);
}
if (stVencStream.pstPack->bStreamEnd == RK_TRUE) {
RK_LOGI("get chn %d stream %d", pstThreadInfo->stVencCtx.VencChn, stVencStream.u32Seq + 1);
RK_LOGI("chn %d reach EOS stream", pstThreadInfo->stVencCtx.VencChn);
RK_MPI_VENC_ReleaseStream(pstThreadInfo->stVencCtx.VencChn, &stVencStream);
break;
}
RK_MPI_VENC_ReleaseStream(pstThreadInfo->stVencCtx.VencChn, &stVencStream);
} else {
usleep(1000llu);
}
}
if (stVencStream.pstPack)
free(stVencStream.pstPack);
return RK_NULL;
}
static RK_S32 TEST_VENC_StartGetStream(COMMON_TEST_VENC_CTX_S *vencCtx) {
RK_S32 s32Ret = 0;
if (vencCtx->pSaveStreamPath != RK_NULL) {
gGSThread[vencCtx->VencChn].fp = fopen(vencCtx->pSaveStreamPath, "wb");
if (gGSThread[vencCtx->VencChn].fp == RK_NULL) {
RK_LOGE("can't open file %s!", vencCtx->pSaveStreamPath);
return RK_FAILURE;
}
}
gGSThread[vencCtx->VencChn].bThreadStart = RK_TRUE;
memcpy(&gGSThread[vencCtx->VencChn].stVencCtx, vencCtx, sizeof(COMMON_TEST_VENC_CTX_S));
s32Ret = pthread_create(&(gGSThread[vencCtx->VencChn].VencPid), 0,
TEST_VENC_GetVencStreamProc,
(RK_VOID *)&(gGSThread[vencCtx->VencChn]));
if (s32Ret != 0) {
return s32Ret;
}
return s32Ret;
}
static RK_S32 TEST_VENC_StopGetStream(VENC_CHN VencChn) {
if (RK_TRUE == gGSThread[VencChn].bThreadStart) {
gGSThread[VencChn].bThreadStart = RK_FALSE;
pthread_join(gGSThread[VencChn].VencPid, 0);
if (gGSThread[VencChn].fp != RK_NULL) {
fclose(gGSThread[VencChn].fp);
gGSThread[VencChn].fp = RK_NULL;
}
}
return RK_SUCCESS;
}
static void* TEST_VENC_SendVencFrameProc(void *pArgs) {
TEST_VENC_THREAD_S *pstThreadInfo = (TEST_VENC_THREAD_S *)pArgs;
RK_S32 s32Ret = RK_SUCCESS;
VENC_CHN VencChn = pstThreadInfo->stVencCtx.VencChn;
RK_U8 *pVirAddr = RK_NULL;
RK_U32 u32SrcSize = 0;
MB_BLK blk = RK_NULL;
RK_U32 u32BufferSize = 0;
RK_S32 s32FrameCount = 0;
RK_S32 s32ReachEOS = 0;
VENC_CHN_ATTR_S stChnAttr;
VIDEO_FRAME_INFO_S stFrame;
MB_POOL_CONFIG_S stMbPoolCfg;
PIC_BUF_ATTR_S stPicBufAttr;
MB_PIC_CAL_S stMbPicCalResult;
s32Ret = RK_MPI_VENC_GetChnAttr(VencChn, &stChnAttr);
if (s32Ret != RK_SUCCESS) {
RK_LOGE("RK_MPI_VENC_GetChnAttr failed 0x%x", s32Ret);
return RK_NULL;
}
stPicBufAttr.u32Width = stChnAttr.stVencAttr.u32PicWidth;
stPicBufAttr.u32Height = stChnAttr.stVencAttr.u32PicHeight;
stPicBufAttr.enCompMode = COMPRESS_MODE_NONE;
stPicBufAttr.enPixelFormat = pstThreadInfo->stVencCtx.enPixFmt;
s32Ret = RK_MPI_CAL_COMM_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
if (s32Ret != RK_SUCCESS) {
RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
return RK_NULL;
}
u32BufferSize = stMbPicCalResult.u32MBSize;
memset(&stMbPoolCfg, 0, sizeof(MB_POOL_CONFIG_S));
stMbPoolCfg.u64MBSize = u32BufferSize;
stMbPoolCfg.u32MBCnt = pstThreadInfo->stVencCtx.u32StreamBufCnt;
stMbPoolCfg.enAllocType = MB_ALLOC_TYPE_DMA;
pstThreadInfo->pool = RK_MPI_MB_CreatePool(&stMbPoolCfg);
while (RK_TRUE == pstThreadInfo->bThreadStart) {
blk = RK_MPI_MB_GetMB(pstThreadInfo->pool, u32BufferSize, RK_TRUE);
pVirAddr = reinterpret_cast<RK_U8 *>(RK_MPI_MB_Handle2VirAddr(blk));
if (pstThreadInfo->fp != RK_NULL) {
u32SrcSize = fread(pVirAddr, 1, u32BufferSize, pstThreadInfo->fp);
if (u32SrcSize <= 0) {
s32ReachEOS = 1;
}
} else {
s32Ret = TEST_COMM_FillImage(pVirAddr, stChnAttr.stVencAttr.u32PicWidth,
stChnAttr.stVencAttr.u32PicHeight,
RK_MPI_CAL_COMM_GetHorStride(stMbPicCalResult.u32VirWidth,
pstThreadInfo->stVencCtx.enPixFmt),
stMbPicCalResult.u32VirHeight,
pstThreadInfo->stVencCtx.enPixFmt,
s32FrameCount);
if (s32Ret != RK_SUCCESS) {
RK_MPI_MB_ReleaseMB(blk);
goto __FAILED;
}
}
RK_MPI_SYS_MmzFlushCache(blk, RK_FALSE);
memset(&stFrame, 0, sizeof(VIDEO_FRAME_INFO_S));
stFrame.stVFrame.pMbBlk = blk;
stFrame.stVFrame.u32Width = stChnAttr.stVencAttr.u32PicWidth;
stFrame.stVFrame.u32Height = stChnAttr.stVencAttr.u32PicHeight;
stFrame.stVFrame.u32VirWidth = stMbPicCalResult.u32VirWidth;
stFrame.stVFrame.u32VirHeight = stMbPicCalResult.u32VirHeight;
stFrame.stVFrame.enPixelFormat = pstThreadInfo->stVencCtx.enPixFmt;
stFrame.stVFrame.u32FrameFlag |= s32ReachEOS ? FRAME_FLAG_SNAP_END : 0;
__RETRY:
if (RK_FALSE == pstThreadInfo->bThreadStart) {
break;
}
s32Ret = RK_MPI_VENC_SendFrame(pstThreadInfo->stVencCtx.VencChn,
&stFrame,
TEST_VENC_TIME_OUT_MS);
if (s32Ret < 0) {
usleep(10000llu);
goto __RETRY;
} else {
s32FrameCount++;
if (!pstThreadInfo->stVencCtx.u32ReadPicNum ||
(pstThreadInfo->stVencCtx.u32ReadPicNum &&
s32FrameCount < pstThreadInfo->stVencCtx.u32ReadPicNum)) {
RK_MPI_MB_ReleaseMB(blk);
blk = RK_NULL;
} else {
// not need read the input data for performance test.
if (pstThreadInfo->stVencCtx.s32RecvPicNum > 0 &&
s32FrameCount > pstThreadInfo->stVencCtx.s32RecvPicNum) {
s32ReachEOS = 1;
break;
}
goto __RETRY;
}
}
if (s32ReachEOS) {
RK_LOGI("chn %d reach EOS.", pstThreadInfo->stVencCtx.VencChn);
break;
}
}
__FAILED:
if (blk)
RK_MPI_MB_ReleaseMB(blk);
RK_LOGI("chn %d frame %d", 0, s32FrameCount);
return RK_NULL;
}
// TODO(@team): now can't support output frame path
static RK_S32 TEST_VENC_StartSendFrame(COMMON_TEST_VENC_CTX_S *vencCtx) {
RK_S32 s32Ret = 0;
if (vencCtx->pSrcFramePath != RK_NULL) {
gSFThread[vencCtx->VencChn].fp = fopen(vencCtx->pSrcFramePath, "r");
if (gSFThread[vencCtx->VencChn].fp == RK_NULL) {
RK_LOGE("can't open file %s!", vencCtx->pSrcFramePath);
return RK_FAILURE;
}
}
gSFThread[vencCtx->VencChn].bThreadStart = RK_TRUE;
memcpy(&gSFThread[vencCtx->VencChn].stVencCtx, vencCtx, sizeof(COMMON_TEST_VENC_CTX_S));
s32Ret = pthread_create(&(gSFThread[vencCtx->VencChn].VencPid), 0,
TEST_VENC_SendVencFrameProc,
(RK_VOID *)&(gSFThread[vencCtx->VencChn]));
if (s32Ret != 0) {
return s32Ret;
}
return s32Ret;
}
static RK_S32 TEST_VENC_StopSendFrame(VENC_CHN VencChn) {
if (RK_TRUE == gSFThread[VencChn].bThreadStart) {
gSFThread[VencChn].bThreadStart = RK_FALSE;
pthread_join(gSFThread[VencChn].VencPid, 0);
if (gSFThread[VencChn].fp != RK_NULL) {
fclose(gSFThread[VencChn].fp);
gSFThread[VencChn].fp = RK_NULL;
}
}
return RK_SUCCESS;
}
RK_S32 TEST_VENC_SET_BitRate(VENC_RC_ATTR_S *pRcAttr, RK_U32 u32BitRate, RK_U32 u32BitRateMax, RK_U32 u32BitRateMin) {
switch (pRcAttr->enRcMode) {
case VENC_RC_MODE_MJPEGCBR:
pRcAttr->stMjpegCbr.u32BitRate = u32BitRate;
break;
case VENC_RC_MODE_H264CBR:
pRcAttr->stH264Cbr.u32BitRate = u32BitRate;
break;
case VENC_RC_MODE_H265CBR:
pRcAttr->stH265Cbr.u32BitRate = u32BitRate;
break;
case VENC_RC_MODE_MJPEGVBR:
pRcAttr->stMjpegVbr.u32BitRate = u32BitRate;
pRcAttr->stMjpegVbr.u32MaxBitRate = u32BitRateMax;
pRcAttr->stMjpegVbr.u32MinBitRate = u32BitRateMin;
break;
case VENC_RC_MODE_H264VBR:
pRcAttr->stH264Vbr.u32BitRate = u32BitRate;
pRcAttr->stH264Vbr.u32MaxBitRate = u32BitRateMax;
pRcAttr->stH264Vbr.u32MinBitRate = u32BitRateMin;
break;
case VENC_RC_MODE_H265VBR:
pRcAttr->stH265Vbr.u32BitRate = u32BitRate;
pRcAttr->stH265Vbr.u32MaxBitRate = u32BitRateMax;
pRcAttr->stH265Vbr.u32MinBitRate = u32BitRateMin;
break;
case VENC_RC_MODE_H264AVBR:
pRcAttr->stH264Avbr.u32BitRate = u32BitRate;
pRcAttr->stH264Avbr.u32MaxBitRate = u32BitRateMax;
pRcAttr->stH264Avbr.u32MinBitRate = u32BitRateMin;
break;
case VENC_RC_MODE_H265AVBR:
pRcAttr->stH265Avbr.u32BitRate = u32BitRate;
pRcAttr->stH265Avbr.u32MaxBitRate = u32BitRateMax;
pRcAttr->stH265Avbr.u32MinBitRate = u32BitRateMin;
break;
default:
return RK_ERR_VENC_NOT_SUPPORT;
}
return RK_SUCCESS;
}
RK_S32 TEST_VENC_SET_StatTime(VENC_RC_ATTR_S *pRcAttr, RK_U32 u32StatTime) {
switch (pRcAttr->enRcMode) {
case VENC_RC_MODE_MJPEGCBR:
pRcAttr->stMjpegCbr.u32StatTime = u32StatTime;
break;
case VENC_RC_MODE_H264CBR:
pRcAttr->stH264Cbr.u32StatTime = u32StatTime;
break;
case VENC_RC_MODE_H265CBR:
pRcAttr->stH265Cbr.u32StatTime = u32StatTime;
break;
case VENC_RC_MODE_MJPEGVBR:
pRcAttr->stMjpegVbr.u32StatTime = u32StatTime;
break;
case VENC_RC_MODE_H264VBR:
pRcAttr->stH264Vbr.u32StatTime = u32StatTime;
break;
case VENC_RC_MODE_H265VBR:
pRcAttr->stH265Vbr.u32StatTime = u32StatTime;
break;
case VENC_RC_MODE_H264AVBR:
pRcAttr->stH264Avbr.u32StatTime = u32StatTime;
break;
case VENC_RC_MODE_H265AVBR:
pRcAttr->stH265Avbr.u32StatTime = u32StatTime;
break;
default:
return RK_ERR_VENC_NOT_SUPPORT;
}
return RK_SUCCESS;
}
RK_S32 TEST_VENC_SET_GopSize(VENC_RC_ATTR_S *pRcAttr, RK_U32 u32GopSize) {
switch (pRcAttr->enRcMode) {
case VENC_RC_MODE_H264CBR:
pRcAttr->stH264Cbr.u32Gop = u32GopSize;
break;
case VENC_RC_MODE_H265CBR:
pRcAttr->stH265Cbr.u32Gop = u32GopSize;
break;
case VENC_RC_MODE_H264VBR:
pRcAttr->stH264Vbr.u32Gop = u32GopSize;
break;
case VENC_RC_MODE_H265VBR:
pRcAttr->stH265Vbr.u32Gop = u32GopSize;
break;
case VENC_RC_MODE_H264AVBR:
pRcAttr->stH264Avbr.u32Gop = u32GopSize;
break;
case VENC_RC_MODE_H265AVBR:
pRcAttr->stH265Avbr.u32Gop = u32GopSize;
break;
default:
return RK_ERR_VENC_NOT_SUPPORT;
}
return RK_SUCCESS;
}
RK_S32 TEST_VENC_SET_FrameRate(VENC_RC_ATTR_S *pRcAttr, RK_U32 u32Fps) {
switch (pRcAttr->enRcMode) {
case VENC_RC_MODE_MJPEGCBR:
pRcAttr->stMjpegCbr.u32SrcFrameRateNum = u32Fps;
pRcAttr->stMjpegCbr.u32SrcFrameRateDen = 1;
pRcAttr->stMjpegCbr.fr32DstFrameRateNum = u32Fps;
pRcAttr->stMjpegCbr.fr32DstFrameRateDen = 1;
break;
case VENC_RC_MODE_H264CBR:
pRcAttr->stH264Cbr.u32SrcFrameRateNum = u32Fps;
pRcAttr->stH264Cbr.u32SrcFrameRateDen = 1;
pRcAttr->stH264Cbr.fr32DstFrameRateNum = u32Fps;
pRcAttr->stH264Cbr.fr32DstFrameRateDen = 1;
break;
case VENC_RC_MODE_H265CBR:
pRcAttr->stH265Cbr.u32SrcFrameRateNum = u32Fps;
pRcAttr->stH265Cbr.u32SrcFrameRateDen = 1;
pRcAttr->stH265Cbr.fr32DstFrameRateNum = u32Fps;
pRcAttr->stH265Cbr.fr32DstFrameRateDen = 1;
break;
case VENC_RC_MODE_MJPEGVBR:
pRcAttr->stMjpegVbr.u32SrcFrameRateNum = u32Fps;
pRcAttr->stMjpegVbr.u32SrcFrameRateDen = 1;
pRcAttr->stMjpegVbr.fr32DstFrameRateNum = u32Fps;
pRcAttr->stMjpegVbr.fr32DstFrameRateDen = 1;
break;
case VENC_RC_MODE_H264VBR:
pRcAttr->stH264Vbr.u32SrcFrameRateNum = u32Fps;
pRcAttr->stH264Vbr.u32SrcFrameRateDen = 1;
pRcAttr->stH264Vbr.fr32DstFrameRateNum = u32Fps;
pRcAttr->stH264Vbr.fr32DstFrameRateDen = 1;
break;
case VENC_RC_MODE_H265VBR:
pRcAttr->stH265Vbr.u32SrcFrameRateNum = u32Fps;
pRcAttr->stH265Vbr.u32SrcFrameRateDen = 1;
pRcAttr->stH265Vbr.fr32DstFrameRateNum = u32Fps;
pRcAttr->stH265Vbr.fr32DstFrameRateDen = 1;
break;
case VENC_RC_MODE_H264AVBR:
pRcAttr->stH264Avbr.u32SrcFrameRateNum = u32Fps;
pRcAttr->stH264Avbr.u32SrcFrameRateDen = 1;
pRcAttr->stH264Avbr.fr32DstFrameRateNum = u32Fps;
pRcAttr->stH264Avbr.fr32DstFrameRateDen = 1;
break;
case VENC_RC_MODE_H265AVBR:
pRcAttr->stH265Avbr.u32SrcFrameRateNum = u32Fps;
pRcAttr->stH265Avbr.u32SrcFrameRateDen = 1;
pRcAttr->stH265Avbr.fr32DstFrameRateNum = u32Fps;
pRcAttr->stH265Avbr.fr32DstFrameRateDen = 1;
break;
default:
return RK_ERR_VENC_NOT_SUPPORT;
}
return RK_SUCCESS;
}
RK_S32 TEST_VENC_SET_FixQp(VENC_RC_ATTR_S *pRcAttr, RK_U32 u32FixIQp,
RK_U32 u32FixPQp, RK_U32 u32FixBQp) {
switch (pRcAttr->enRcMode) {
case VENC_RC_MODE_MJPEGFIXQP:
pRcAttr->stMjpegFixQp.u32Qfactor = u32FixIQp;
break;
case VENC_RC_MODE_H264FIXQP:
pRcAttr->stH264FixQp.u32IQp = u32FixIQp;
pRcAttr->stH264FixQp.u32PQp = u32FixPQp;
pRcAttr->stH264FixQp.u32BQp = u32FixBQp;
break;
case VENC_RC_MODE_H265FIXQP:
pRcAttr->stH265FixQp.u32IQp = u32FixIQp;
pRcAttr->stH265FixQp.u32PQp = u32FixPQp;
pRcAttr->stH265FixQp.u32BQp = u32FixBQp;
break;
default:
return RK_ERR_VENC_NOT_SUPPORT;
}
return RK_SUCCESS;
}
#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* End of #ifdef __cplusplus */