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 <pthread.h>
23 #include <string.h>
24 #include <cerrno>
25 #include "test_comm_vgs.h"
26 #include "test_comm_imgproc.h"
27 #include "test_comm_sys.h"
28 #include "test_comm_utils.h"
29 #include "rk_mpi_vgs.h"
30 #include "rk_mpi_cal.h"
31 #include "rk_mpi_mb.h"
32 #include "rk_mpi_mmz.h"
33 #include "rk_mpi_sys.h"
34 #include "rk_common.h"
35 #include "rk_debug.h"
36
TEST_VGS_Save_DstFrame(TEST_VGS_PROC_CTX_S * pstCtx)37 RK_S32 TEST_VGS_Save_DstFrame(TEST_VGS_PROC_CTX_S *pstCtx) {
38 RK_S32 s32Ret = RK_SUCCESS;
39 MB_PIC_CAL_S stCalResult;
40 PIC_BUF_ATTR_S stPicBufAttr;
41 RK_U32 u32DstWidth = pstCtx->stImgOut.stVFrame.u32Width;
42 RK_U32 u32DstHeight = pstCtx->stImgOut.stVFrame.u32Height;
43 RK_U32 u32DstPixelFormat = pstCtx->stImgOut.stVFrame.enPixelFormat;
44 RK_S32 s32DstCompressMode = pstCtx->stImgOut.stVFrame.enCompressMode;
45 stPicBufAttr.u32Width = u32DstWidth;
46 stPicBufAttr.u32Height = u32DstHeight;
47 stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)u32DstPixelFormat;
48 stPicBufAttr.enCompMode = (COMPRESS_MODE_E)s32DstCompressMode;
49
50 s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stPicBufAttr, &stCalResult);
51 if (pstCtx->dstFileName != RK_NULL) {
52 FILE *fp = fopen(pstCtx->dstFileName, "wb+");
53 if (fp == RK_NULL) {
54 RK_LOGE("fopen %s failed, error: %s", pstCtx->dstFileName, strerror(errno));
55 return RK_FAILURE;
56 }
57 fwrite(RK_MPI_MB_Handle2VirAddr(pstCtx->stImgOut.stVFrame.pMbBlk),
58 1, stCalResult.u32MBSize, fp);
59 fflush(fp);
60 fclose(fp);
61 }
62 return s32Ret;
63 }
64
TEST_VGS_AddTask(TEST_VGS_PROC_CTX_S * pstCtx,VGS_HANDLE jobHandle)65 RK_S32 TEST_VGS_AddTask(TEST_VGS_PROC_CTX_S *pstCtx, VGS_HANDLE jobHandle) {
66 RK_S32 s32Ret = RK_SUCCESS;
67 VGS_TASK_ATTR_S stTask;
68 stTask.stImgIn = pstCtx->stImgIn;
69 stTask.stImgOut = pstCtx->stImgOut;
70 switch (pstCtx->opType) {
71 case VGS_OP_QUICK_RESIZE: {
72 s32Ret = RK_MPI_VGS_AddScaleTask(jobHandle, &stTask, VGS_SCLCOEF_NORMAL);
73 } break;
74 default: {
75 RK_LOGE("unknown operation type %d", pstCtx->opType);
76 break;
77 }
78 }
79 return s32Ret;
80 }
81
TEST_VGS_BeginJob(VGS_HANDLE * jobHandle)82 RK_S32 TEST_VGS_BeginJob(VGS_HANDLE *jobHandle) {
83 RK_S32 ret = RK_MPI_VGS_BeginJob(jobHandle);
84 return ret;
85 }
86
TEST_VGS_EndJob(VGS_HANDLE jobHandle)87 RK_S32 TEST_VGS_EndJob(VGS_HANDLE jobHandle) {
88 RK_S32 s32Ret = RK_SUCCESS;
89 s32Ret = RK_MPI_VGS_EndJob(jobHandle);
90 if (s32Ret != RK_SUCCESS) {
91 RK_MPI_VGS_CancelJob(jobHandle);
92 return RK_FAILURE;
93 }
94 return s32Ret;
95 }
96
TEST_VGS_LoadSrcFrame(TEST_VGS_PROC_CTX_S * pstCtx)97 RK_S32 TEST_VGS_LoadSrcFrame(TEST_VGS_PROC_CTX_S *pstCtx) {
98 RK_S32 s32Ret = RK_SUCCESS;
99 PIC_BUF_ATTR_S stPicBufAttr;
100 VIDEO_FRAME_INFO_S *stVideoFrame = &(pstCtx->stImgIn);
101 RK_U8 *pstVideoFrame;
102 RK_U32 u32VirSrcWidth = 0;
103 RK_U32 u32VirSrcHeight = 0;
104 RK_U32 u32SrcWidth = pstCtx->stImgIn.stVFrame.u32Width;
105 RK_U32 u32SrcHeight = pstCtx->stImgIn.stVFrame.u32Height;
106 PIXEL_FORMAT_E u32SrcPixelFormat = pstCtx->stImgIn.stVFrame.enPixelFormat;
107 COMPRESS_MODE_E u32SrcCompressMode = pstCtx->stImgIn.stVFrame.enCompressMode;
108
109 stPicBufAttr.u32Width = u32SrcWidth;
110 stPicBufAttr.u32Height = u32SrcHeight;
111 stPicBufAttr.enPixelFormat = u32SrcPixelFormat;
112 stPicBufAttr.enCompMode = u32SrcCompressMode;
113 s32Ret = TEST_SYS_CreateVideoFrame(&stPicBufAttr, stVideoFrame);
114 u32VirSrcWidth = stVideoFrame->stVFrame.u32VirWidth;
115 u32VirSrcHeight = stVideoFrame->stVFrame.u32VirHeight;
116 if (s32Ret != RK_SUCCESS) {
117 goto __FAILED;
118 }
119
120 pstVideoFrame = (RK_U8 *)RK_MPI_MB_Handle2VirAddr(stVideoFrame->stVFrame.pMbBlk);
121 s32Ret = TEST_COMM_FillImage(
122 pstVideoFrame,
123 u32SrcWidth, u32SrcHeight,
124 RK_MPI_CAL_COMM_GetHorStride(u32VirSrcWidth, u32SrcPixelFormat),
125 u32VirSrcHeight,
126 u32SrcPixelFormat, 1);
127
128 if (s32Ret != RK_SUCCESS) {
129 goto __FAILED;
130 }
131
132 RK_MPI_SYS_MmzFlushCache(stVideoFrame->stVFrame.pMbBlk, RK_FALSE);
133
134 __FAILED:
135 if (s32Ret != RK_SUCCESS) {
136 RK_MPI_MB_ReleaseMB(stVideoFrame->stVFrame.pMbBlk);
137 }
138 return s32Ret;
139 }
140
TEST_VGS_CreateDstFrame(TEST_VGS_PROC_CTX_S * pstCtx)141 RK_S32 TEST_VGS_CreateDstFrame(TEST_VGS_PROC_CTX_S *pstCtx) {
142 RK_S32 s32Ret = RK_SUCCESS;
143 PIC_BUF_ATTR_S stPicBufAttr;
144 VIDEO_FRAME_INFO_S *stVideoFrame = &(pstCtx->stImgOut);
145
146 RK_U32 u32DstWidth = pstCtx->stImgOut.stVFrame.u32Width;
147 RK_U32 u32DstHeight = pstCtx->stImgOut.stVFrame.u32Height;
148 RK_U32 u32DstPixelFormat = pstCtx->stImgOut.stVFrame.enPixelFormat;
149 RK_S32 s32DstCompressMode = pstCtx->stImgOut.stVFrame.enCompressMode;
150
151 stPicBufAttr.u32Width = u32DstWidth;
152 stPicBufAttr.u32Height = u32DstHeight;
153 stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)u32DstPixelFormat;
154 stPicBufAttr.enCompMode = (COMPRESS_MODE_E)s32DstCompressMode;
155
156 s32Ret = TEST_SYS_CreateVideoFrame(&stPicBufAttr, stVideoFrame);
157 if (s32Ret != RK_SUCCESS) {
158 goto __FAILED;
159 }
160
161 __FAILED:
162 if (s32Ret != RK_SUCCESS) {
163 RK_MPI_MB_ReleaseMB(stVideoFrame->stVFrame.pMbBlk);
164 }
165 return s32Ret;
166 }
167
TEST_VGS_ProcessJob(TEST_VGS_PROC_CTX_S * pstCtx,VIDEO_FRAME_INFO_S * pstFrames)168 RK_S32 TEST_VGS_ProcessJob(TEST_VGS_PROC_CTX_S *pstCtx, VIDEO_FRAME_INFO_S *pstFrames) {
169 RK_S32 s32Ret = RK_SUCCESS;
170 RK_S64 s64StartTime = 0ll;
171 RK_S64 s64EndTime = 0ll;
172 VGS_HANDLE jobHandle;
173 s32Ret = TEST_VGS_BeginJob(&jobHandle);
174 RK_S32 s32TaskNum = (pstCtx->s32TaskNum == 0) ? 1 : pstCtx->s32TaskNum;
175
176 for (RK_S32 taskIdx = 0; taskIdx < s32TaskNum; taskIdx++) {
177 s32Ret = TEST_VGS_AddTask(pstCtx, jobHandle);
178 if (s32Ret != RK_SUCCESS) {
179 goto __FAILED;
180 }
181 }
182
183 s32Ret = TEST_VGS_EndJob(jobHandle);
184 if (s32Ret != RK_SUCCESS) {
185 goto __FAILED;
186 }
187
188 __FAILED:
189 if (s32Ret != RK_SUCCESS) {
190 RK_MPI_MB_ReleaseMB(pstCtx->stImgIn.stVFrame.pMbBlk);
191 RK_MPI_MB_ReleaseMB(pstCtx->stImgOut.stVFrame.pMbBlk);
192 }
193 return s32Ret;
194 }
195
TEST_VGS_SingleProc(void * pArgs)196 void* TEST_VGS_SingleProc(void *pArgs) {
197 RK_S32 s32Ret = RK_SUCCESS;
198 TEST_VGS_PROC_CTX_S *pstCtx = reinterpret_cast<TEST_VGS_PROC_CTX_S *>(pArgs);
199 VIDEO_FRAME_INFO_S pstFrames;
200
201 s32Ret = TEST_VGS_ProcessJob(pstCtx, &pstFrames);
202 if (s32Ret != RK_SUCCESS) {
203 goto __FAILED;
204 }
205 TEST_VGS_Save_DstFrame(pstCtx);
206
207 __FAILED:
208 RK_MPI_MB_ReleaseMB(pstCtx->stImgIn.stVFrame.pMbBlk);
209 RK_MPI_MB_ReleaseMB(pstCtx->stImgOut.stVFrame.pMbBlk);
210 return RK_NULL;
211 }
212
TEST_VGS_MultiProc(void * pArgs)213 void* TEST_VGS_MultiProc(void *pArgs) {
214 RK_S32 s32Ret = RK_SUCCESS;
215 TEST_VGS_PROC_CTX_S *pstCtx = reinterpret_cast<TEST_VGS_PROC_CTX_S *>(pArgs);
216 VIDEO_FRAME_INFO_S pstFrames;
217
218 TEST_VGS_LoadSrcFrame(pstCtx);
219 TEST_VGS_CreateDstFrame(pstCtx);
220 for (RK_S32 i = 0; i < pstCtx->s32ProcessTimes; i++) {
221 s32Ret = TEST_VGS_ProcessJob(pstCtx, &pstFrames);
222 }
223 RK_MPI_MB_ReleaseMB(pstCtx->stImgIn.stVFrame.pMbBlk);
224 RK_MPI_MB_ReleaseMB(pstCtx->stImgOut.stVFrame.pMbBlk);
225 return RK_NULL;
226 }
227
TEST_VGS_MultiTest(TEST_VGS_PROC_CTX_S * ctx)228 RK_S32 TEST_VGS_MultiTest(TEST_VGS_PROC_CTX_S *ctx) {
229 RK_S32 s32Ret = RK_SUCCESS;
230 pthread_t tids[VGS_MAX_JOB_NUM];
231 TEST_VGS_PROC_CTX_S tmpCtx[VGS_MAX_JOB_NUM];
232 RK_S64 s64StartTime = 0ll;
233 RK_S64 s64EndTime = 0ll;
234 s64StartTime = TEST_COMM_GetNowUs();
235
236 for (RK_S32 jobIndex = 0; jobIndex < ctx->s32JobNum; jobIndex++) {
237 memcpy(&(tmpCtx[jobIndex]), ctx, sizeof(TEST_VGS_PROC_CTX_S));
238 pthread_create(&tids[jobIndex], 0, TEST_VGS_MultiProc, reinterpret_cast<void *>(&tmpCtx[jobIndex]));
239 }
240
241
242 for (RK_S32 jobIndex = 0; jobIndex < ctx->s32JobNum; jobIndex++) {
243 void *retval;
244 s32Ret = pthread_join(tids[jobIndex], &retval);
245 if (s32Ret != RK_SUCCESS) {
246 RK_LOGE("vgs multi test error test id:%d", tids[jobIndex]);
247 s32Ret = RK_FAILURE;
248 }
249 }
250
251 s64EndTime = TEST_COMM_GetNowUs();
252 RK_S32 s32TaskNum = (ctx->s32TaskNum == 0) ? 1 : ctx->s32TaskNum;
253 RK_S32 runningTimes = ctx->s32JobNum * s32TaskNum * ctx->s32ProcessTimes;
254 RK_DOUBLE s32fps = (RK_DOUBLE)runningTimes * 1000000 / (s64EndTime - s64StartTime);
255 RK_LOGD("run count:%d, run totalTime:%lld, run fps:%f",
256 runningTimes, (s64EndTime - s64StartTime), s32fps);
257
258 return s32Ret;
259 }
260
261 #ifdef __cplusplus
262 #if __cplusplus
263 }
264 #endif
265 #endif /* End of #ifdef __cplusplus */
266