1 /*
2 * Copyright 2021 Rockchip Electronics Co. LTD
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #ifdef __cplusplus
17 #if __cplusplus
18 extern "C" {
19 #endif
20 #endif /* End of #ifdef __cplusplus */
21
22 #include <string.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <pthread.h>
26 #include <unistd.h>
27 #include <errno.h>
28
29 #include "test_comm_venc.h"
30 #include "test_comm_imgproc.h"
31
32 #include "rk_comm_venc.h"
33 #include "rk_common.h"
34 #include "rk_debug.h"
35 #include "rk_mpi_venc.h"
36 #include "rk_mpi_cal.h"
37 #include "rk_mpi_sys.h"
38 #include "rk_mpi_mb.h"
39
40 #define TEST_VENC_PATH_LENGTH 128
41 #define TEST_VENC_TIME_OUT_MS 100
42
43 typedef struct test_venc_getstream_s {
44 RK_BOOL bThreadStart;
45 FILE *fp;
46 pthread_t VencPid;
47 MB_POOL pool;
48 COMMON_TEST_VENC_CTX_S stVencCtx;
49 } TEST_VENC_THREAD_S;
50
51 // get stream thread info
52 static TEST_VENC_THREAD_S gGSThread[VENC_MAX_CHN_NUM];
53 // send frame thread info
54 static TEST_VENC_THREAD_S gSFThread[VENC_MAX_CHN_NUM];
55
56
57 static RK_S32 TEST_VENC_StartSendFrame(COMMON_TEST_VENC_CTX_S *vencCtx);
58 static RK_S32 TEST_VENC_StopSendFrame(VENC_CHN VencChn);
59 static RK_S32 TEST_VENC_StartGetStream(COMMON_TEST_VENC_CTX_S *vencCtx);
60 static RK_S32 TEST_VENC_StopGetStream(VENC_CHN VencChn);
61 static RK_VOID TEST_VECN_DestroyPool(VENC_CHN VencChn);
62
TEST_VENC_Create(COMMON_TEST_VENC_CTX_S * vencCtx)63 RK_S32 TEST_VENC_Create(COMMON_TEST_VENC_CTX_S *vencCtx) {
64 RK_S32 s32Ret = RK_SUCCESS;
65 VENC_CHN_ATTR_S stAttr;
66
67 memset(&stAttr, 0, sizeof(VENC_CHN_ATTR_S));
68
69 stAttr.stVencAttr.enType = vencCtx->enType;
70 if (vencCtx->enType == RK_VIDEO_ID_AVC)
71 stAttr.stVencAttr.u32Profile = H264E_PROFILE_HIGH;
72 else if (vencCtx->enType == RK_VIDEO_ID_HEVC)
73 stAttr.stVencAttr.u32Profile = H265E_PROFILE_MAIN;
74 stAttr.stVencAttr.enPixelFormat = vencCtx->enPixFmt;
75 stAttr.stVencAttr.u32PicWidth = vencCtx->u32Width;
76 stAttr.stVencAttr.u32PicHeight = vencCtx->u32Height;
77 stAttr.stVencAttr.u32VirWidth = vencCtx->u32Width;
78 stAttr.stVencAttr.u32VirHeight = vencCtx->u32Height;
79 stAttr.stVencAttr.u32StreamBufCnt = vencCtx->u32StreamBufCnt;
80 stAttr.stVencAttr.u32BufSize = vencCtx->u32Width * vencCtx->u32Height;
81 s32Ret = RK_MPI_VENC_CreateChn(vencCtx->VencChn, &stAttr);
82
83 return s32Ret;
84 }
85
TEST_VENC_Start(COMMON_TEST_VENC_CTX_S * vencCtx)86 RK_S32 TEST_VENC_Start(COMMON_TEST_VENC_CTX_S *vencCtx) {
87 RK_S32 s32Ret = RK_SUCCESS;
88 VENC_RECV_PIC_PARAM_S stRecvParam;
89
90 memset(&stRecvParam, 0, sizeof(VENC_RECV_PIC_PARAM_S));
91 stRecvParam.s32RecvPicNum = -1;
92
93 s32Ret = TEST_VENC_Create(vencCtx);
94 if (s32Ret != RK_SUCCESS) {
95 return s32Ret;
96 }
97 s32Ret = RK_MPI_VENC_StartRecvFrame(vencCtx->VencChn, &stRecvParam);
98 if (s32Ret != RK_SUCCESS) {
99 return s32Ret;
100 }
101 s32Ret = TEST_VENC_StartSendFrame(vencCtx);
102 if (s32Ret != RK_SUCCESS) {
103 return s32Ret;
104 }
105 s32Ret = TEST_VENC_StartGetStream(vencCtx);
106
107 return s32Ret;
108 }
109
TEST_VENC_Stop(VENC_CHN VencChn)110 RK_S32 TEST_VENC_Stop(VENC_CHN VencChn) {
111 RK_S32 s32Ret = RK_SUCCESS;
112
113 s32Ret = TEST_VENC_StopSendFrame(VencChn);
114 if (s32Ret != RK_SUCCESS) {
115 return s32Ret;
116 }
117 s32Ret = TEST_VENC_StopGetStream(VencChn);
118 if (s32Ret != RK_SUCCESS) {
119 return s32Ret;
120 }
121 s32Ret = RK_MPI_VENC_StopRecvFrame(VencChn);
122 if (s32Ret != RK_SUCCESS) {
123 return s32Ret;
124 }
125 s32Ret = RK_MPI_VENC_DestroyChn(VencChn);
126 if (s32Ret != RK_SUCCESS) {
127 return s32Ret;
128 }
129 TEST_VECN_DestroyPool(VencChn);
130
131 return s32Ret;
132 }
133
134 // should TEST_VENC_Create first
TEST_VENC_SnapStart(COMMON_TEST_VENC_CTX_S * vencCtx)135 RK_S32 TEST_VENC_SnapStart(COMMON_TEST_VENC_CTX_S *vencCtx) {
136 RK_S32 s32Ret = RK_SUCCESS;
137 VENC_RECV_PIC_PARAM_S stRecvParam;
138
139 memset(&stRecvParam, 0, sizeof(VENC_RECV_PIC_PARAM_S));
140 stRecvParam.s32RecvPicNum = vencCtx->s32RecvPicNum;
141
142 s32Ret = RK_MPI_VENC_StartRecvFrame(vencCtx->VencChn, &stRecvParam);
143 if (s32Ret != RK_SUCCESS) {
144 return s32Ret;
145 }
146 s32Ret = TEST_VENC_StartSendFrame(vencCtx);
147 if (s32Ret != RK_SUCCESS) {
148 return s32Ret;
149 }
150
151 return s32Ret;
152 }
153
TEST_VENC_SnapStop(VENC_CHN VencChn)154 RK_S32 TEST_VENC_SnapStop(VENC_CHN VencChn) {
155 RK_S32 s32Ret = RK_SUCCESS;
156
157 s32Ret = TEST_VENC_StopSendFrame(VencChn);
158 if (s32Ret != RK_SUCCESS) {
159 return s32Ret;
160 }
161 s32Ret = RK_MPI_VENC_StopRecvFrame(VencChn);
162 if (s32Ret != RK_SUCCESS) {
163 return s32Ret;
164 }
165 s32Ret = RK_MPI_VENC_DestroyChn(VencChn);
166 if (s32Ret != RK_SUCCESS) {
167 return s32Ret;
168 }
169 TEST_VECN_DestroyPool(VencChn);
170
171 return s32Ret;
172 }
173
TEST_VENC_SnapProcess(COMMON_TEST_VENC_CTX_S * vencCtx)174 RK_S32 TEST_VENC_SnapProcess(COMMON_TEST_VENC_CTX_S *vencCtx) {
175 FILE *fp = RK_NULL;
176 void *pData = RK_NULL;
177 RK_S32 s32Ret = RK_SUCCESS;
178 RK_S32 s32StreamCnt = 0;
179 VENC_STREAM_S stVencStream;
180
181 if (vencCtx->pSaveStreamPath != RK_NULL) {
182 fp = fopen(vencCtx->pSaveStreamPath, "wb");
183 if (fp == RK_NULL) {
184 RK_LOGE("can't open file %s!", vencCtx->pSaveStreamPath);
185 return RK_FAILURE;
186 }
187 }
188 stVencStream.pstPack = reinterpret_cast<VENC_PACK_S *>(malloc(sizeof(VENC_PACK_S)));
189
190 while (1) {
191 s32Ret = RK_MPI_VENC_GetStream(vencCtx->VencChn, &stVencStream, TEST_VENC_TIME_OUT_MS);
192 if (s32Ret >= 0) {
193 if (fp != RK_NULL) {
194 pData = RK_MPI_MB_Handle2VirAddr(stVencStream.pstPack->pMbBlk);
195 RK_MPI_SYS_MmzFlushCache(stVencStream.pstPack->pMbBlk, RK_TRUE);
196 fwrite(pData, 1, stVencStream.pstPack->u32Len, fp);
197 fflush(fp);
198 }
199 if (stVencStream.pstPack->bStreamEnd == RK_TRUE) {
200 RK_LOGI("get chn %d stream %d", vencCtx->VencChn, stVencStream.u32Seq + 1);
201 RK_LOGI("chn %d reach EOS stream", vencCtx->VencChn);
202 RK_MPI_VENC_ReleaseStream(vencCtx->VencChn, &stVencStream);
203 break;
204 }
205 RK_MPI_VENC_ReleaseStream(vencCtx->VencChn, &stVencStream);
206 } else {
207 usleep(1000llu);
208 }
209 }
210
211 if (stVencStream.pstPack)
212 free(stVencStream.pstPack);
213 if (fp)
214 fclose(fp);
215
216 return RK_SUCCESS;
217 }
218
TEST_VECN_DestroyPool(VENC_CHN VencChn)219 static RK_VOID TEST_VECN_DestroyPool(VENC_CHN VencChn) {
220 if (gSFThread[VencChn].pool)
221 RK_MPI_MB_DestroyPool(gSFThread[VencChn].pool);
222 }
223
TEST_VENC_GetVencStreamProc(RK_VOID * p)224 static RK_VOID* TEST_VENC_GetVencStreamProc(RK_VOID *p) {
225 TEST_VENC_THREAD_S *pstThreadInfo = (TEST_VENC_THREAD_S *)p;
226 void *pData = RK_NULL;
227 RK_S32 s32Ret = RK_SUCCESS;
228 VENC_STREAM_S stVencStream;
229
230 stVencStream.pstPack = reinterpret_cast<VENC_PACK_S *>(malloc(sizeof(VENC_PACK_S)));
231
232 while (RK_TRUE == pstThreadInfo->bThreadStart) {
233 s32Ret = RK_MPI_VENC_GetStream(pstThreadInfo->stVencCtx.VencChn, &stVencStream, TEST_VENC_TIME_OUT_MS);
234 if (s32Ret >= 0) {
235 if (pstThreadInfo->fp != RK_NULL) {
236 pData = RK_MPI_MB_Handle2VirAddr(stVencStream.pstPack->pMbBlk);
237 RK_MPI_SYS_MmzFlushCache(stVencStream.pstPack->pMbBlk, RK_TRUE);
238 fwrite(pData, 1, stVencStream.pstPack->u32Len, pstThreadInfo->fp);
239 fflush(pstThreadInfo->fp);
240 }
241 if (stVencStream.pstPack->bStreamEnd == RK_TRUE) {
242 RK_LOGI("get chn %d stream %d", pstThreadInfo->stVencCtx.VencChn, stVencStream.u32Seq + 1);
243 RK_LOGI("chn %d reach EOS stream", pstThreadInfo->stVencCtx.VencChn);
244 RK_MPI_VENC_ReleaseStream(pstThreadInfo->stVencCtx.VencChn, &stVencStream);
245 break;
246 }
247 RK_MPI_VENC_ReleaseStream(pstThreadInfo->stVencCtx.VencChn, &stVencStream);
248 } else {
249 usleep(1000llu);
250 }
251 }
252
253 if (stVencStream.pstPack)
254 free(stVencStream.pstPack);
255
256 return RK_NULL;
257 }
258
TEST_VENC_StartGetStream(COMMON_TEST_VENC_CTX_S * vencCtx)259 static RK_S32 TEST_VENC_StartGetStream(COMMON_TEST_VENC_CTX_S *vencCtx) {
260 RK_S32 s32Ret = 0;
261
262 if (vencCtx->pSaveStreamPath != RK_NULL) {
263 gGSThread[vencCtx->VencChn].fp = fopen(vencCtx->pSaveStreamPath, "wb");
264 if (gGSThread[vencCtx->VencChn].fp == RK_NULL) {
265 RK_LOGE("can't open file %s!", vencCtx->pSaveStreamPath);
266 return RK_FAILURE;
267 }
268 }
269 gGSThread[vencCtx->VencChn].bThreadStart = RK_TRUE;
270 memcpy(&gGSThread[vencCtx->VencChn].stVencCtx, vencCtx, sizeof(COMMON_TEST_VENC_CTX_S));
271
272 s32Ret = pthread_create(&(gGSThread[vencCtx->VencChn].VencPid), 0,
273 TEST_VENC_GetVencStreamProc,
274 (RK_VOID *)&(gGSThread[vencCtx->VencChn]));
275 if (s32Ret != 0) {
276 return s32Ret;
277 }
278
279 return s32Ret;
280 }
281
TEST_VENC_StopGetStream(VENC_CHN VencChn)282 static RK_S32 TEST_VENC_StopGetStream(VENC_CHN VencChn) {
283 if (RK_TRUE == gGSThread[VencChn].bThreadStart) {
284 gGSThread[VencChn].bThreadStart = RK_FALSE;
285 pthread_join(gGSThread[VencChn].VencPid, 0);
286 if (gGSThread[VencChn].fp != RK_NULL) {
287 fclose(gGSThread[VencChn].fp);
288 gGSThread[VencChn].fp = RK_NULL;
289 }
290 }
291
292 return RK_SUCCESS;
293 }
294
TEST_VENC_SendVencFrameProc(void * pArgs)295 static void* TEST_VENC_SendVencFrameProc(void *pArgs) {
296 TEST_VENC_THREAD_S *pstThreadInfo = (TEST_VENC_THREAD_S *)pArgs;
297 RK_S32 s32Ret = RK_SUCCESS;
298 VENC_CHN VencChn = pstThreadInfo->stVencCtx.VencChn;
299 RK_U8 *pVirAddr = RK_NULL;
300 RK_U32 u32SrcSize = 0;
301 MB_BLK blk = RK_NULL;
302 RK_U32 u32BufferSize = 0;
303 RK_S32 s32FrameCount = 0;
304 RK_S32 s32ReachEOS = 0;
305 VENC_CHN_ATTR_S stChnAttr;
306 VIDEO_FRAME_INFO_S stFrame;
307 MB_POOL_CONFIG_S stMbPoolCfg;
308 PIC_BUF_ATTR_S stPicBufAttr;
309 MB_PIC_CAL_S stMbPicCalResult;
310
311 s32Ret = RK_MPI_VENC_GetChnAttr(VencChn, &stChnAttr);
312 if (s32Ret != RK_SUCCESS) {
313 RK_LOGE("RK_MPI_VENC_GetChnAttr failed 0x%x", s32Ret);
314 return RK_NULL;
315 }
316 stPicBufAttr.u32Width = stChnAttr.stVencAttr.u32PicWidth;
317 stPicBufAttr.u32Height = stChnAttr.stVencAttr.u32PicHeight;
318 stPicBufAttr.enCompMode = COMPRESS_MODE_NONE;
319 stPicBufAttr.enPixelFormat = pstThreadInfo->stVencCtx.enPixFmt;
320 s32Ret = RK_MPI_CAL_COMM_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
321 if (s32Ret != RK_SUCCESS) {
322 RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
323 return RK_NULL;
324 }
325 u32BufferSize = stMbPicCalResult.u32MBSize;
326 memset(&stMbPoolCfg, 0, sizeof(MB_POOL_CONFIG_S));
327 stMbPoolCfg.u64MBSize = u32BufferSize;
328 stMbPoolCfg.u32MBCnt = pstThreadInfo->stVencCtx.u32StreamBufCnt;
329 stMbPoolCfg.enAllocType = MB_ALLOC_TYPE_DMA;
330 pstThreadInfo->pool = RK_MPI_MB_CreatePool(&stMbPoolCfg);
331
332 while (RK_TRUE == pstThreadInfo->bThreadStart) {
333 blk = RK_MPI_MB_GetMB(pstThreadInfo->pool, u32BufferSize, RK_TRUE);
334 pVirAddr = reinterpret_cast<RK_U8 *>(RK_MPI_MB_Handle2VirAddr(blk));
335 if (pstThreadInfo->fp != RK_NULL) {
336 u32SrcSize = fread(pVirAddr, 1, u32BufferSize, pstThreadInfo->fp);
337 if (u32SrcSize <= 0) {
338 s32ReachEOS = 1;
339 }
340 } else {
341 s32Ret = TEST_COMM_FillImage(pVirAddr, stChnAttr.stVencAttr.u32PicWidth,
342 stChnAttr.stVencAttr.u32PicHeight,
343 RK_MPI_CAL_COMM_GetHorStride(stMbPicCalResult.u32VirWidth,
344 pstThreadInfo->stVencCtx.enPixFmt),
345 stMbPicCalResult.u32VirHeight,
346 pstThreadInfo->stVencCtx.enPixFmt,
347 s32FrameCount);
348 if (s32Ret != RK_SUCCESS) {
349 RK_MPI_MB_ReleaseMB(blk);
350 goto __FAILED;
351 }
352 }
353 RK_MPI_SYS_MmzFlushCache(blk, RK_FALSE);
354 memset(&stFrame, 0, sizeof(VIDEO_FRAME_INFO_S));
355 stFrame.stVFrame.pMbBlk = blk;
356 stFrame.stVFrame.u32Width = stChnAttr.stVencAttr.u32PicWidth;
357 stFrame.stVFrame.u32Height = stChnAttr.stVencAttr.u32PicHeight;
358 stFrame.stVFrame.u32VirWidth = stMbPicCalResult.u32VirWidth;
359 stFrame.stVFrame.u32VirHeight = stMbPicCalResult.u32VirHeight;
360 stFrame.stVFrame.enPixelFormat = pstThreadInfo->stVencCtx.enPixFmt;
361 stFrame.stVFrame.u32FrameFlag |= s32ReachEOS ? FRAME_FLAG_SNAP_END : 0;
362 __RETRY:
363 if (RK_FALSE == pstThreadInfo->bThreadStart) {
364 break;
365 }
366 s32Ret = RK_MPI_VENC_SendFrame(pstThreadInfo->stVencCtx.VencChn,
367 &stFrame,
368 TEST_VENC_TIME_OUT_MS);
369 if (s32Ret < 0) {
370 usleep(10000llu);
371 goto __RETRY;
372 } else {
373 s32FrameCount++;
374 if (!pstThreadInfo->stVencCtx.u32ReadPicNum ||
375 (pstThreadInfo->stVencCtx.u32ReadPicNum &&
376 s32FrameCount < pstThreadInfo->stVencCtx.u32ReadPicNum)) {
377 RK_MPI_MB_ReleaseMB(blk);
378 blk = RK_NULL;
379 } else {
380 // not need read the input data for performance test.
381 if (pstThreadInfo->stVencCtx.s32RecvPicNum > 0 &&
382 s32FrameCount > pstThreadInfo->stVencCtx.s32RecvPicNum) {
383 s32ReachEOS = 1;
384 break;
385 }
386 goto __RETRY;
387 }
388 }
389 if (s32ReachEOS) {
390 RK_LOGI("chn %d reach EOS.", pstThreadInfo->stVencCtx.VencChn);
391 break;
392 }
393 }
394
395 __FAILED:
396 if (blk)
397 RK_MPI_MB_ReleaseMB(blk);
398 RK_LOGI("chn %d frame %d", 0, s32FrameCount);
399
400 return RK_NULL;
401 }
402
403 // TODO(@team): now can't support output frame path
TEST_VENC_StartSendFrame(COMMON_TEST_VENC_CTX_S * vencCtx)404 static RK_S32 TEST_VENC_StartSendFrame(COMMON_TEST_VENC_CTX_S *vencCtx) {
405 RK_S32 s32Ret = 0;
406
407 if (vencCtx->pSrcFramePath != RK_NULL) {
408 gSFThread[vencCtx->VencChn].fp = fopen(vencCtx->pSrcFramePath, "r");
409 if (gSFThread[vencCtx->VencChn].fp == RK_NULL) {
410 RK_LOGE("can't open file %s!", vencCtx->pSrcFramePath);
411 return RK_FAILURE;
412 }
413 }
414 gSFThread[vencCtx->VencChn].bThreadStart = RK_TRUE;
415 memcpy(&gSFThread[vencCtx->VencChn].stVencCtx, vencCtx, sizeof(COMMON_TEST_VENC_CTX_S));
416
417 s32Ret = pthread_create(&(gSFThread[vencCtx->VencChn].VencPid), 0,
418 TEST_VENC_SendVencFrameProc,
419 (RK_VOID *)&(gSFThread[vencCtx->VencChn]));
420 if (s32Ret != 0) {
421 return s32Ret;
422 }
423
424 return s32Ret;
425 }
426
TEST_VENC_StopSendFrame(VENC_CHN VencChn)427 static RK_S32 TEST_VENC_StopSendFrame(VENC_CHN VencChn) {
428 if (RK_TRUE == gSFThread[VencChn].bThreadStart) {
429 gSFThread[VencChn].bThreadStart = RK_FALSE;
430 pthread_join(gSFThread[VencChn].VencPid, 0);
431 if (gSFThread[VencChn].fp != RK_NULL) {
432 fclose(gSFThread[VencChn].fp);
433 gSFThread[VencChn].fp = RK_NULL;
434 }
435 }
436
437 return RK_SUCCESS;
438 }
439
TEST_VENC_SET_BitRate(VENC_RC_ATTR_S * pRcAttr,RK_U32 u32BitRate,RK_U32 u32BitRateMax,RK_U32 u32BitRateMin)440 RK_S32 TEST_VENC_SET_BitRate(VENC_RC_ATTR_S *pRcAttr, RK_U32 u32BitRate, RK_U32 u32BitRateMax, RK_U32 u32BitRateMin) {
441 switch (pRcAttr->enRcMode) {
442 case VENC_RC_MODE_MJPEGCBR:
443 pRcAttr->stMjpegCbr.u32BitRate = u32BitRate;
444 break;
445 case VENC_RC_MODE_H264CBR:
446 pRcAttr->stH264Cbr.u32BitRate = u32BitRate;
447 break;
448 case VENC_RC_MODE_H265CBR:
449 pRcAttr->stH265Cbr.u32BitRate = u32BitRate;
450 break;
451 case VENC_RC_MODE_MJPEGVBR:
452 pRcAttr->stMjpegVbr.u32BitRate = u32BitRate;
453 pRcAttr->stMjpegVbr.u32MaxBitRate = u32BitRateMax;
454 pRcAttr->stMjpegVbr.u32MinBitRate = u32BitRateMin;
455 break;
456 case VENC_RC_MODE_H264VBR:
457 pRcAttr->stH264Vbr.u32BitRate = u32BitRate;
458 pRcAttr->stH264Vbr.u32MaxBitRate = u32BitRateMax;
459 pRcAttr->stH264Vbr.u32MinBitRate = u32BitRateMin;
460 break;
461 case VENC_RC_MODE_H265VBR:
462 pRcAttr->stH265Vbr.u32BitRate = u32BitRate;
463 pRcAttr->stH265Vbr.u32MaxBitRate = u32BitRateMax;
464 pRcAttr->stH265Vbr.u32MinBitRate = u32BitRateMin;
465 break;
466 case VENC_RC_MODE_H264AVBR:
467 pRcAttr->stH264Avbr.u32BitRate = u32BitRate;
468 pRcAttr->stH264Avbr.u32MaxBitRate = u32BitRateMax;
469 pRcAttr->stH264Avbr.u32MinBitRate = u32BitRateMin;
470 break;
471 case VENC_RC_MODE_H265AVBR:
472 pRcAttr->stH265Avbr.u32BitRate = u32BitRate;
473 pRcAttr->stH265Avbr.u32MaxBitRate = u32BitRateMax;
474 pRcAttr->stH265Avbr.u32MinBitRate = u32BitRateMin;
475 break;
476 default:
477 return RK_ERR_VENC_NOT_SUPPORT;
478 }
479
480 return RK_SUCCESS;
481 }
482
TEST_VENC_SET_StatTime(VENC_RC_ATTR_S * pRcAttr,RK_U32 u32StatTime)483 RK_S32 TEST_VENC_SET_StatTime(VENC_RC_ATTR_S *pRcAttr, RK_U32 u32StatTime) {
484 switch (pRcAttr->enRcMode) {
485 case VENC_RC_MODE_MJPEGCBR:
486 pRcAttr->stMjpegCbr.u32StatTime = u32StatTime;
487 break;
488 case VENC_RC_MODE_H264CBR:
489 pRcAttr->stH264Cbr.u32StatTime = u32StatTime;
490 break;
491 case VENC_RC_MODE_H265CBR:
492 pRcAttr->stH265Cbr.u32StatTime = u32StatTime;
493 break;
494 case VENC_RC_MODE_MJPEGVBR:
495 pRcAttr->stMjpegVbr.u32StatTime = u32StatTime;
496 break;
497 case VENC_RC_MODE_H264VBR:
498 pRcAttr->stH264Vbr.u32StatTime = u32StatTime;
499 break;
500 case VENC_RC_MODE_H265VBR:
501 pRcAttr->stH265Vbr.u32StatTime = u32StatTime;
502 break;
503 case VENC_RC_MODE_H264AVBR:
504 pRcAttr->stH264Avbr.u32StatTime = u32StatTime;
505 break;
506 case VENC_RC_MODE_H265AVBR:
507 pRcAttr->stH265Avbr.u32StatTime = u32StatTime;
508 break;
509 default:
510 return RK_ERR_VENC_NOT_SUPPORT;
511 }
512
513 return RK_SUCCESS;
514 }
515
TEST_VENC_SET_GopSize(VENC_RC_ATTR_S * pRcAttr,RK_U32 u32GopSize)516 RK_S32 TEST_VENC_SET_GopSize(VENC_RC_ATTR_S *pRcAttr, RK_U32 u32GopSize) {
517 switch (pRcAttr->enRcMode) {
518 case VENC_RC_MODE_H264CBR:
519 pRcAttr->stH264Cbr.u32Gop = u32GopSize;
520 break;
521 case VENC_RC_MODE_H265CBR:
522 pRcAttr->stH265Cbr.u32Gop = u32GopSize;
523 break;
524 case VENC_RC_MODE_H264VBR:
525 pRcAttr->stH264Vbr.u32Gop = u32GopSize;
526 break;
527 case VENC_RC_MODE_H265VBR:
528 pRcAttr->stH265Vbr.u32Gop = u32GopSize;
529 break;
530 case VENC_RC_MODE_H264AVBR:
531 pRcAttr->stH264Avbr.u32Gop = u32GopSize;
532 break;
533 case VENC_RC_MODE_H265AVBR:
534 pRcAttr->stH265Avbr.u32Gop = u32GopSize;
535 break;
536 default:
537 return RK_ERR_VENC_NOT_SUPPORT;
538 }
539
540 return RK_SUCCESS;
541 }
542
TEST_VENC_SET_FrameRate(VENC_RC_ATTR_S * pRcAttr,RK_U32 u32Fps)543 RK_S32 TEST_VENC_SET_FrameRate(VENC_RC_ATTR_S *pRcAttr, RK_U32 u32Fps) {
544 switch (pRcAttr->enRcMode) {
545 case VENC_RC_MODE_MJPEGCBR:
546 pRcAttr->stMjpegCbr.u32SrcFrameRateNum = u32Fps;
547 pRcAttr->stMjpegCbr.u32SrcFrameRateDen = 1;
548 pRcAttr->stMjpegCbr.fr32DstFrameRateNum = u32Fps;
549 pRcAttr->stMjpegCbr.fr32DstFrameRateDen = 1;
550 break;
551 case VENC_RC_MODE_H264CBR:
552 pRcAttr->stH264Cbr.u32SrcFrameRateNum = u32Fps;
553 pRcAttr->stH264Cbr.u32SrcFrameRateDen = 1;
554 pRcAttr->stH264Cbr.fr32DstFrameRateNum = u32Fps;
555 pRcAttr->stH264Cbr.fr32DstFrameRateDen = 1;
556 break;
557 case VENC_RC_MODE_H265CBR:
558 pRcAttr->stH265Cbr.u32SrcFrameRateNum = u32Fps;
559 pRcAttr->stH265Cbr.u32SrcFrameRateDen = 1;
560 pRcAttr->stH265Cbr.fr32DstFrameRateNum = u32Fps;
561 pRcAttr->stH265Cbr.fr32DstFrameRateDen = 1;
562 break;
563 case VENC_RC_MODE_MJPEGVBR:
564 pRcAttr->stMjpegVbr.u32SrcFrameRateNum = u32Fps;
565 pRcAttr->stMjpegVbr.u32SrcFrameRateDen = 1;
566 pRcAttr->stMjpegVbr.fr32DstFrameRateNum = u32Fps;
567 pRcAttr->stMjpegVbr.fr32DstFrameRateDen = 1;
568 break;
569 case VENC_RC_MODE_H264VBR:
570 pRcAttr->stH264Vbr.u32SrcFrameRateNum = u32Fps;
571 pRcAttr->stH264Vbr.u32SrcFrameRateDen = 1;
572 pRcAttr->stH264Vbr.fr32DstFrameRateNum = u32Fps;
573 pRcAttr->stH264Vbr.fr32DstFrameRateDen = 1;
574 break;
575 case VENC_RC_MODE_H265VBR:
576 pRcAttr->stH265Vbr.u32SrcFrameRateNum = u32Fps;
577 pRcAttr->stH265Vbr.u32SrcFrameRateDen = 1;
578 pRcAttr->stH265Vbr.fr32DstFrameRateNum = u32Fps;
579 pRcAttr->stH265Vbr.fr32DstFrameRateDen = 1;
580 break;
581 case VENC_RC_MODE_H264AVBR:
582 pRcAttr->stH264Avbr.u32SrcFrameRateNum = u32Fps;
583 pRcAttr->stH264Avbr.u32SrcFrameRateDen = 1;
584 pRcAttr->stH264Avbr.fr32DstFrameRateNum = u32Fps;
585 pRcAttr->stH264Avbr.fr32DstFrameRateDen = 1;
586 break;
587 case VENC_RC_MODE_H265AVBR:
588 pRcAttr->stH265Avbr.u32SrcFrameRateNum = u32Fps;
589 pRcAttr->stH265Avbr.u32SrcFrameRateDen = 1;
590 pRcAttr->stH265Avbr.fr32DstFrameRateNum = u32Fps;
591 pRcAttr->stH265Avbr.fr32DstFrameRateDen = 1;
592 break;
593 default:
594 return RK_ERR_VENC_NOT_SUPPORT;
595 }
596
597 return RK_SUCCESS;
598 }
599
TEST_VENC_SET_FixQp(VENC_RC_ATTR_S * pRcAttr,RK_U32 u32FixIQp,RK_U32 u32FixPQp,RK_U32 u32FixBQp)600 RK_S32 TEST_VENC_SET_FixQp(VENC_RC_ATTR_S *pRcAttr, RK_U32 u32FixIQp,
601 RK_U32 u32FixPQp, RK_U32 u32FixBQp) {
602 switch (pRcAttr->enRcMode) {
603 case VENC_RC_MODE_MJPEGFIXQP:
604 pRcAttr->stMjpegFixQp.u32Qfactor = u32FixIQp;
605 break;
606 case VENC_RC_MODE_H264FIXQP:
607 pRcAttr->stH264FixQp.u32IQp = u32FixIQp;
608 pRcAttr->stH264FixQp.u32PQp = u32FixPQp;
609 pRcAttr->stH264FixQp.u32BQp = u32FixBQp;
610 break;
611 case VENC_RC_MODE_H265FIXQP:
612 pRcAttr->stH265FixQp.u32IQp = u32FixIQp;
613 pRcAttr->stH265FixQp.u32PQp = u32FixPQp;
614 pRcAttr->stH265FixQp.u32BQp = u32FixBQp;
615 break;
616 default:
617 return RK_ERR_VENC_NOT_SUPPORT;
618 }
619
620 return RK_SUCCESS;
621 }
622
623 #ifdef __cplusplus
624 #if __cplusplus
625 }
626 #endif
627 #endif /* End of #ifdef __cplusplus */
628