628 lines
22 KiB
C++
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 */
|