1 /*
2 * Copyright 2020 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 */
17
18 #undef DBG_MOD_ID
19 #define DBG_MOD_ID RK_ID_VGS
20
21 #include <cstdio>
22 #include <cerrno>
23 #include <cstring>
24 #include <pthread.h>
25 #include "rk_type.h"
26 #include "rk_debug.h"
27 #include "rk_mpi_vgs.h"
28 #include "rk_mpi_mb.h"
29 #include "rk_mpi_sys.h"
30 #include "rk_mpi_cal.h"
31
32 #include "test_comm_vgs.h"
33 #include "test_comm_argparse.h"
34
35 typedef enum rkVGS_TASK_TYPE_E {
36 VGS_TASK_TYPE_NONE = 0,
37 VGS_TASK_TYPE_SCALE,
38 VGS_TASK_TYPE_ROTATE,
39 VGS_TASK_TYPE_DRAW_LINE,
40 VGS_TASK_TYPE_COVER,
41 VGS_TASK_TYPE_OSD,
42 VGS_TASK_TYPE_MOSAIC,
43 VGS_TASK_TYPE_CROP,
44 VGS_TASK_TYPE_BUTT
45 } VGS_TASK_TYPE_E;
46
47 typedef enum rkVGS_TASK_MODE_E {
48 VGS_TASK_MODE_NONE = 0,
49 VGS_TASK_MODE_ONE,
50 VGS_TASK_MODE_ALL,
51 VGS_TASK_MODE_BUTT
52 } VGS_TASK_MODE_E;
53
54 typedef struct _rkMpiVgsCtx {
55 const char *srcFilePath;
56 const char *dstFilePath;
57 const char *osdFilePath;
58 RK_S32 s32LoopCount;
59 RK_S32 s32JobNum;
60 RK_S32 s32TaskNum;
61 RK_S32 s32TaskType;
62 RK_S32 s32TaskMode;
63 RK_U32 u32TaskArraySize;
64 RK_S32 s32Angle;
65 RK_S32 s32SrcWidth;
66 RK_S32 s32SrcHeight;
67 RK_S32 s32SrcVirWidth;
68 RK_S32 s32SrcVirHeight;
69 RK_S32 s32SrcCompressMode;
70 RK_S32 s32SrcPixFormat;
71 RK_S32 s32DstWidth;
72 RK_S32 s32DstHeight;
73 RK_S32 s32DstCompressMode;
74 RK_S32 s32DstPixFormat;
75 RK_S32 s32OsdWidth;
76 RK_S32 s32OsdHeight;
77 RK_S32 s32OsdCompressMode;
78 RK_S32 s32OsdPixFormat;
79 RECT_S stCropRect;
80 RK_S32 s32JobIdx;
81 RK_U32 u32SrcSize;
82 RK_S32 s32ProcessTime;
83 RK_S32 bPerformace;
84 } TEST_VGS_CTX_S;
85
86 typedef struct _rkMpiTestTaskCtx {
87 VGS_ADD_COVER_S enCoverInfo[VGS_MAX_TASK_NUM];
88 VGS_ADD_OSD_S enOsdInfo[VGS_MAX_TASK_NUM * 8];
89 VGS_MOSAIC_S enMosaicInfo[VGS_MAX_TASK_NUM];
90 VGS_DRAW_LINE_S enDrawLine[VGS_MAX_TASK_NUM];
91 VGS_CROP_INFO_S stCropInfo;
92 } TEST_TASK_CTX_S;
93
test_open_and_read_file(const char * path,void * pu8SrcData,RK_U32 u32SrcSize)94 RK_S32 test_open_and_read_file(const char *path, void *pu8SrcData, RK_U32 u32SrcSize) {
95 FILE *pFile = NULL;
96 RK_U32 u32ReadSize = 0;
97 pFile = fopen(path, "rb+");
98 if (pFile == RK_NULL) {
99 RK_LOGE("open path %s failed because %s.", path, strerror(errno));
100 return RK_ERR_VGS_NULL_PTR;
101 }
102 if (pFile) {
103 u32ReadSize = fread(pu8SrcData, 1, u32SrcSize, pFile);
104 fflush(pFile);
105 fclose(pFile);
106 }
107 RK_LOGD("unit_test_open_source u32ReadSize:%d", u32ReadSize);
108 return RK_SUCCESS;
109 }
110
unit_test_vgs_generate_source(const char * srcFilePath,MB_BLK * pstSrcBlk,RK_U32 u32SrcSize)111 RK_S32 unit_test_vgs_generate_source(const char *srcFilePath, MB_BLK *pstSrcBlk, RK_U32 u32SrcSize) {
112 RK_S32 s32Ret = RK_SUCCESS;
113 void *pSrcData = RK_NULL;
114 s32Ret = RK_MPI_SYS_MmzAlloc(pstSrcBlk, RK_NULL, RK_NULL, u32SrcSize);
115 if (s32Ret == RK_SUCCESS) {
116 pSrcData = RK_MPI_MB_Handle2VirAddr(*pstSrcBlk);
117 s32Ret = test_open_and_read_file(srcFilePath, pSrcData, u32SrcSize);
118 RK_MPI_SYS_MmzFlushCache(*pstSrcBlk, RK_FALSE);
119 }
120 return s32Ret;
121 }
122
unit_test_vgs_generate_scale_task(const VGS_TASK_ATTR_S * pstTask,const TEST_VGS_CTX_S * ctx,MB_BLK srcBlk)123 RK_S32 unit_test_vgs_generate_scale_task(
124 const VGS_TASK_ATTR_S *pstTask, const TEST_VGS_CTX_S *ctx, MB_BLK srcBlk) {
125 RK_S32 s32Ret = RK_SUCCESS;
126 VGS_TASK_ATTR_S *pTaskAttr = const_cast<VGS_TASK_ATTR_S *>(pstTask);
127 VIDEO_FRAME_S videoFrameIn = {0};
128 VIDEO_FRAME_S videoFrameOut = {0};
129 RK_U32 u32DstSize = 0;
130 MB_BLK dstBlk = RK_NULL;
131
132 videoFrameIn.u32Width = ctx->s32SrcWidth;
133 videoFrameIn.u32Height = ctx->s32SrcHeight;
134 videoFrameIn.u32VirWidth = ctx->s32SrcVirWidth;
135 videoFrameIn.u32VirHeight = ctx->s32SrcVirHeight;
136 videoFrameIn.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
137 videoFrameIn.u32TimeRef = 0;
138 videoFrameIn.u64PTS = 0;
139 videoFrameIn.pMbBlk = srcBlk;
140
141 PIC_BUF_ATTR_S stDstPicBufAttr;
142 MB_PIC_CAL_S stDstMbPicCalResult;
143 stDstPicBufAttr.u32Width = ctx->s32DstWidth;
144 stDstPicBufAttr.u32Height = ctx->s32DstHeight;
145 stDstPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
146 stDstPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32DstCompressMode;
147 s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stDstPicBufAttr, &stDstMbPicCalResult);
148 if (s32Ret != RK_SUCCESS) {
149 RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
150 return s32Ret;
151 }
152 u32DstSize = stDstMbPicCalResult.u32MBSize;
153 s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32DstSize);
154 if (s32Ret != RK_SUCCESS) {
155 return s32Ret;
156 }
157 videoFrameOut.u32Width = ctx->s32DstWidth;
158 videoFrameOut.u32Height = ctx->s32DstHeight;
159 videoFrameOut.u32VirWidth = stDstMbPicCalResult.u32VirWidth;
160 videoFrameOut.u32VirHeight = stDstMbPicCalResult.u32VirHeight;
161 videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
162 videoFrameOut.u32TimeRef = 0;
163 videoFrameOut.u64PTS = 0;
164 videoFrameOut.pMbBlk = dstBlk;
165
166 pTaskAttr->stImgIn.stVFrame = videoFrameIn;
167 pTaskAttr->stImgOut.stVFrame = videoFrameOut;
168 RK_LOGD("src w(%d) h(%d) dst w(%d) h(%d)",
169 pTaskAttr->stImgIn.stVFrame.u32Width,
170 pTaskAttr->stImgIn.stVFrame.u32Height,
171 pTaskAttr->stImgOut.stVFrame.u32Width,
172 pTaskAttr->stImgOut.stVFrame.u32Height);
173
174 return s32Ret;
175 }
176
unit_test_vgs_generate_rotation_task(const VGS_TASK_ATTR_S * pstTask,const TEST_VGS_CTX_S * ctx,MB_BLK srcBlk)177 RK_S32 unit_test_vgs_generate_rotation_task(
178 const VGS_TASK_ATTR_S *pstTask, const TEST_VGS_CTX_S *ctx, MB_BLK srcBlk) {
179 RK_S32 s32Ret = RK_SUCCESS;
180 VIDEO_FRAME_S videoFrameIn = {0};
181 VIDEO_FRAME_S videoFrameOut = {0};
182 VGS_TASK_ATTR_S *pTaskAttr = const_cast<VGS_TASK_ATTR_S *>(pstTask);
183 RK_U32 u32DstSize = 0;
184 MB_BLK dstBlk = RK_NULL;
185 RK_S32 s32SrcWidth = ctx->s32SrcWidth;
186 RK_S32 s32SrcHeight = ctx->s32SrcHeight;
187
188 videoFrameIn.u32Width = s32SrcWidth;
189 videoFrameIn.u32Height = s32SrcHeight;
190 videoFrameIn.u32VirWidth = ctx->s32SrcVirWidth;
191 videoFrameIn.u32VirHeight = ctx->s32SrcVirHeight;
192 videoFrameIn.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
193 videoFrameIn.u32TimeRef = 0;
194 videoFrameIn.u64PTS = 0;
195 videoFrameIn.pMbBlk = srcBlk;
196
197 PIC_BUF_ATTR_S stDstPicBufAttr;
198 MB_PIC_CAL_S stDstMbPicCalResult;
199
200 videoFrameOut.u32Width = s32SrcWidth;
201 videoFrameOut.u32Height = s32SrcHeight;
202 if ((ctx->s32Angle == ROTATION_90) || (ctx->s32Angle == ROTATION_270)) {
203 videoFrameOut.u32Width = s32SrcHeight;
204 videoFrameOut.u32Height = s32SrcWidth;
205 }
206 stDstPicBufAttr.u32Width = videoFrameOut.u32Width;
207 stDstPicBufAttr.u32Height = videoFrameOut.u32Height;
208 stDstPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
209 stDstPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32DstCompressMode;
210 s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stDstPicBufAttr, &stDstMbPicCalResult);
211 if (s32Ret != RK_SUCCESS) {
212 RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
213 return s32Ret;
214 }
215 u32DstSize = stDstMbPicCalResult.u32MBSize;
216 s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32DstSize);
217 if (s32Ret != RK_SUCCESS) {
218 return s32Ret;
219 }
220
221 videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
222 videoFrameOut.u32VirWidth = stDstMbPicCalResult.u32VirWidth;
223 videoFrameOut.u32VirHeight = stDstMbPicCalResult.u32VirHeight;
224 videoFrameOut.u32TimeRef = 0;
225 videoFrameOut.u64PTS = 0;
226 videoFrameOut.pMbBlk = dstBlk;
227
228 pTaskAttr->stImgIn.stVFrame = videoFrameIn;
229 pTaskAttr->stImgOut.stVFrame = videoFrameOut;
230 RK_LOGD("src w(%d) h(%d) dst w(%d) h(%d)",
231 pTaskAttr->stImgIn.stVFrame.u32Width,
232 pTaskAttr->stImgIn.stVFrame.u32Height,
233 pTaskAttr->stImgOut.stVFrame.u32Width,
234 pTaskAttr->stImgOut.stVFrame.u32Height);
235
236 return s32Ret;
237 }
238
unit_test_vgs_generate_crop_task(const VGS_TASK_ATTR_S * pstTask,VGS_CROP_INFO_S * pstCropInfo,const TEST_VGS_CTX_S * ctx,MB_BLK srcBlk)239 RK_S32 unit_test_vgs_generate_crop_task(
240 const VGS_TASK_ATTR_S *pstTask, VGS_CROP_INFO_S *pstCropInfo, const TEST_VGS_CTX_S *ctx, MB_BLK srcBlk) {
241 RK_S32 s32Ret = RK_SUCCESS;
242 VGS_TASK_ATTR_S *pTaskAttr = const_cast<VGS_TASK_ATTR_S *>(pstTask);
243 VIDEO_FRAME_S videoFrameIn = {0};
244 VIDEO_FRAME_S videoFrameOut = {0};
245 RK_U32 u32DstSize = 0;
246 MB_BLK dstBlk = RK_NULL;
247
248 videoFrameIn.u32Width = ctx->s32SrcWidth;
249 videoFrameIn.u32Height = ctx->s32SrcHeight;
250 videoFrameIn.u32VirWidth = ctx->s32SrcVirWidth;
251 videoFrameIn.u32VirHeight = ctx->s32SrcVirHeight;
252 videoFrameIn.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
253 videoFrameIn.u32TimeRef = 0;
254 videoFrameIn.u64PTS = 0;
255 videoFrameIn.pMbBlk = srcBlk;
256
257 PIC_BUF_ATTR_S stDstPicBufAttr;
258 MB_PIC_CAL_S stDstMbPicCalResult;
259
260 stDstPicBufAttr.u32Width = ctx->s32DstWidth;
261 stDstPicBufAttr.u32Height = ctx->s32DstHeight;
262 stDstPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
263 stDstPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32DstCompressMode;
264 s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stDstPicBufAttr, &stDstMbPicCalResult);
265 if (s32Ret != RK_SUCCESS) {
266 RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
267 return s32Ret;
268 }
269 u32DstSize = stDstMbPicCalResult.u32MBSize;
270 s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, u32DstSize);
271 if (s32Ret != RK_SUCCESS) {
272 return s32Ret;
273 }
274
275 videoFrameOut.u32Width = ctx->s32DstWidth;
276 videoFrameOut.u32Height = ctx->s32DstHeight;
277 videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
278 videoFrameOut.u32VirWidth = stDstMbPicCalResult.u32VirWidth;
279 videoFrameOut.u32VirHeight = stDstMbPicCalResult.u32VirHeight;
280 videoFrameOut.u32TimeRef = 0;
281 videoFrameOut.u64PTS = 0;
282 videoFrameOut.pMbBlk = dstBlk;
283
284 pTaskAttr->stImgIn.stVFrame = videoFrameIn;
285 pTaskAttr->stImgOut.stVFrame = videoFrameOut;
286 pstCropInfo->enCropCoordinate = VGS_CROP_RATIO_COOR;
287 pstCropInfo->stCropRect.s32X = ctx->stCropRect.s32X;
288 pstCropInfo->stCropRect.s32Y = ctx->stCropRect.s32Y;
289 pstCropInfo->stCropRect.u32Width = ctx->stCropRect.u32Width;
290 pstCropInfo->stCropRect.u32Height = ctx->stCropRect.u32Height;
291 RK_LOGD("src w(%d) h(%d) dst w(%d) h(%d)",
292 pTaskAttr->stImgIn.stVFrame.u32Width,
293 pTaskAttr->stImgIn.stVFrame.u32Height,
294 pTaskAttr->stImgOut.stVFrame.u32Width,
295 pTaskAttr->stImgOut.stVFrame.u32Height);
296
297 return s32Ret;
298 }
299
unit_test_set_vgs_cover_array_info(VGS_ADD_COVER_S * pstVgsAddCover,const TEST_VGS_CTX_S * ctx,RK_U32 u32ArraySize)300 RK_VOID unit_test_set_vgs_cover_array_info(
301 VGS_ADD_COVER_S *pstVgsAddCover, const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize) {
302 RK_U32 u32Color[VGS_MAX_TASK_NUM] = {0xff00ff00, 0x000000ff, 0x00ff0000, 0x00ff00ff, 0xff00ffff};
303 RK_U32 u32Ratio[VGS_MAX_TASK_NUM] = {2, 4, 6, 8, 10, 2, 4, 6};
304 RK_S32 s32SrcWidth = ctx->s32SrcWidth;
305 RK_S32 s32SrcHeight = ctx->s32SrcHeight;
306 for (RK_S32 i = 0; i < u32ArraySize; i++) {
307 if (u32Ratio[i]) {
308 pstVgsAddCover[i].enCoverType = COVER_RECT;
309 pstVgsAddCover[i].stDstRect.s32X = s32SrcWidth / u32Ratio[i];
310 pstVgsAddCover[i].stDstRect.s32Y = s32SrcHeight / u32Ratio[i];
311 pstVgsAddCover[i].stDstRect.u32Width = s32SrcWidth / u32Ratio[i];
312 pstVgsAddCover[i].stDstRect.u32Height = s32SrcHeight / u32Ratio[i];
313 pstVgsAddCover[i].u32Color = u32Color[i]; // green
314 }
315 }
316 }
317
unit_test_vgs_generate_cover_task_array(const VGS_TASK_ATTR_S * pstTask,VGS_ADD_COVER_S * pstVgsAddCover,const TEST_VGS_CTX_S * ctx,RK_U32 u32ArraySize,MB_BLK srcBlk)318 RK_S32 unit_test_vgs_generate_cover_task_array(
319 const VGS_TASK_ATTR_S *pstTask, VGS_ADD_COVER_S *pstVgsAddCover,
320 const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize, MB_BLK srcBlk) {
321 RK_S32 s32Ret = RK_SUCCESS;
322 VIDEO_FRAME_S videoFrameOut = {0};
323 VGS_TASK_ATTR_S *pTaskAttr = const_cast<VGS_TASK_ATTR_S *>(pstTask);
324 MB_BLK dstBlk = RK_NULL;
325
326 s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, ctx->u32SrcSize);
327 if (s32Ret != RK_SUCCESS) {
328 return s32Ret;
329 }
330 memcpy(RK_MPI_MB_Handle2VirAddr(dstBlk),
331 RK_MPI_MB_Handle2VirAddr(srcBlk), ctx->u32SrcSize);
332
333 videoFrameOut.u32Width = ctx->s32SrcWidth;
334 videoFrameOut.u32Height = ctx->s32SrcHeight;
335 videoFrameOut.u32VirWidth = ctx->s32SrcVirWidth;
336 videoFrameOut.u32VirHeight = ctx->s32SrcVirHeight;
337 videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
338 videoFrameOut.u32TimeRef = 0;
339 videoFrameOut.u64PTS = 0;
340 videoFrameOut.pMbBlk = dstBlk;
341
342 pTaskAttr->stImgIn.stVFrame = videoFrameOut;
343 pTaskAttr->stImgOut.stVFrame = videoFrameOut;
344 unit_test_set_vgs_cover_array_info(pstVgsAddCover, ctx, u32ArraySize);
345 return s32Ret;
346 }
347
unit_test_set_vgs_osd_array_info(VGS_ADD_OSD_S * pstOsd,const TEST_VGS_CTX_S * ctx,RK_U32 u32ArraySize)348 RK_S32 unit_test_set_vgs_osd_array_info(
349 VGS_ADD_OSD_S *pstOsd, const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize) {
350 RK_U32 u32Ratio[VGS_MAX_TASK_NUM] = {2, 4, 6, 8, 10, 2, 4, 6};
351 RK_U32 u32OsdWidth = ctx->s32OsdWidth;
352 RK_U32 u32OsdHeight = ctx->s32OsdHeight;
353 RK_U32 u32OsdPixFormat = RK_FMT_YUV420SP;
354 RK_U32 u32OsdCompressMode = COMPRESS_MODE_NONE;
355 RK_S32 s32Ret = RK_SUCCESS;
356 MB_BLK osdBlk = RK_NULL;
357 RK_S32 s32SrcWidth = ctx->s32SrcWidth;
358 RK_S32 s32SrcHeight = ctx->s32SrcHeight;
359 const char *osdFilePath = ctx->osdFilePath;
360 RK_U32 u32OsdSize = 0;
361 PIC_BUF_ATTR_S stPicBufAttr;
362 MB_PIC_CAL_S stMbPicCalResult;
363
364 stPicBufAttr.u32Width = u32OsdWidth;
365 stPicBufAttr.u32Height = u32OsdHeight;
366 stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)u32OsdPixFormat;
367 stPicBufAttr.enCompMode = (COMPRESS_MODE_E)u32OsdCompressMode;
368 s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
369 if (s32Ret != RK_SUCCESS) {
370 RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
371 return s32Ret;
372 }
373 u32OsdSize = stMbPicCalResult.u32MBSize;
374 for (RK_S32 i = 0; i < u32ArraySize; i++) {
375 s32Ret = unit_test_vgs_generate_source(osdFilePath, &osdBlk, u32OsdSize);
376
377 if (s32Ret != RK_SUCCESS) {
378 return s32Ret;
379 }
380 if (u32Ratio[i]) {
381 pstOsd[i].stRect.s32X = s32SrcWidth / u32Ratio[i];
382 pstOsd[i].stRect.s32Y = s32SrcHeight / u32Ratio[i];
383 pstOsd[i].stRect.u32Width = u32OsdWidth;
384 pstOsd[i].stRect.u32Height = u32OsdHeight;
385 pstOsd[i].enPixelFmt = RK_FMT_YUV420SP;
386 pstOsd[i].u32FgAlpha = 0xff; // no alpha
387 pstOsd[i].pMbBlk = osdBlk;
388 }
389 }
390 return s32Ret;
391 }
392
unit_test_vgs_generate_osd_task_array(const VGS_TASK_ATTR_S * pstTask,VGS_ADD_OSD_S * pstOsd,const TEST_VGS_CTX_S * ctx,RK_U32 u32ArraySize,MB_BLK srcBlk)393 RK_S32 unit_test_vgs_generate_osd_task_array(
394 const VGS_TASK_ATTR_S *pstTask, VGS_ADD_OSD_S *pstOsd,
395 const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize, MB_BLK srcBlk) {
396 RK_S32 s32Ret = RK_SUCCESS;
397 VGS_TASK_ATTR_S *pTaskAttr = const_cast<VGS_TASK_ATTR_S *>(pstTask);
398 VIDEO_FRAME_S videoFrameOut = {0};
399 MB_BLK dstBlk = RK_NULL;
400
401 s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, ctx->u32SrcSize);
402 if (s32Ret != RK_SUCCESS) {
403 return s32Ret;
404 }
405 memcpy(RK_MPI_MB_Handle2VirAddr(dstBlk),
406 RK_MPI_MB_Handle2VirAddr(srcBlk), ctx->u32SrcSize);
407
408 videoFrameOut.u32Width = ctx->s32SrcWidth;
409 videoFrameOut.u32Height = ctx->s32SrcHeight;
410 videoFrameOut.u32VirWidth = ctx->s32SrcVirWidth;
411 videoFrameOut.u32VirHeight = ctx->s32SrcVirHeight;
412 videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
413 videoFrameOut.u32TimeRef = 0;
414 videoFrameOut.u64PTS = 0;
415 videoFrameOut.pMbBlk = dstBlk;
416
417 pTaskAttr->stImgOut.stVFrame = videoFrameOut;
418 pTaskAttr->stImgIn.stVFrame = videoFrameOut;
419 unit_test_set_vgs_osd_array_info(pstOsd, ctx, u32ArraySize);
420 return s32Ret;
421 }
422
unit_test_set_vgs_drawline_array_info(VGS_DRAW_LINE_S * pstDrawLine,const TEST_VGS_CTX_S * ctx,RK_U32 u32ArraySize)423 RK_VOID unit_test_set_vgs_drawline_array_info(
424 VGS_DRAW_LINE_S *pstDrawLine, const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize) {
425 RK_U32 u32Color[VGS_MAX_TASK_NUM] = {0xff00ff00, 0x0000ff00, 0xff000000, 0x00ff00ff, 0xff00ff00};
426 RK_U32 u32Ratio[VGS_MAX_TASK_NUM] = {2, 4, 6, 8, 10, 2, 4, 6};
427 RK_U32 u32Thick[VGS_MAX_TASK_NUM] = {10, 5, 20, 15, 10, 2, 4, 6};
428 RK_S32 s32SrcWidth = ctx->s32SrcWidth;
429 RK_S32 s32SrcHeight = ctx->s32SrcHeight;
430 for (RK_S32 i = 0; i < u32ArraySize; i++) {
431 if (u32Ratio[i]) {
432 pstDrawLine[i].stStartPoint.s32X = s32SrcWidth / u32Ratio[i];
433 pstDrawLine[i].stStartPoint.s32Y = s32SrcHeight / u32Ratio[i];
434 pstDrawLine[i].stEndPoint.s32X = s32SrcWidth / u32Ratio[i] * 2;
435 pstDrawLine[i].stEndPoint.s32Y = s32SrcHeight / u32Ratio[i] * 2;
436 pstDrawLine[i].u32Color = u32Color[i]; // green
437 pstDrawLine[i].u32Thick = u32Thick[i];
438 }
439 }
440 }
441
unit_test_vgs_generate_drawline_task_array(const VGS_TASK_ATTR_S * pstTask,VGS_DRAW_LINE_S * pstDrawLine,const TEST_VGS_CTX_S * ctx,RK_U32 u32ArraySize,MB_BLK srcBlk)442 RK_S32 unit_test_vgs_generate_drawline_task_array(
443 const VGS_TASK_ATTR_S *pstTask, VGS_DRAW_LINE_S *pstDrawLine,
444 const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize, MB_BLK srcBlk) {
445 RK_S32 s32Ret = RK_SUCCESS;
446 VGS_TASK_ATTR_S *pTaskAttr = const_cast<VGS_TASK_ATTR_S *>(pstTask);
447 VIDEO_FRAME_S videoFrameOut = {0};
448 MB_BLK dstBlk = RK_NULL;
449
450 s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, ctx->u32SrcSize);
451 if (s32Ret != RK_SUCCESS) {
452 return s32Ret;
453 }
454 memcpy(RK_MPI_MB_Handle2VirAddr(dstBlk),
455 RK_MPI_MB_Handle2VirAddr(srcBlk), ctx->u32SrcSize);
456
457 videoFrameOut.u32Width = ctx->s32SrcWidth;
458 videoFrameOut.u32Height = ctx->s32SrcHeight;
459 videoFrameOut.u32VirWidth = ctx->s32SrcVirWidth;
460 videoFrameOut.u32VirHeight = ctx->s32SrcVirHeight;
461 videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
462 videoFrameOut.u32TimeRef = 0;
463 videoFrameOut.u64PTS = 0;
464 videoFrameOut.pMbBlk = dstBlk;
465
466 pTaskAttr->stImgOut.stVFrame = videoFrameOut;
467 pTaskAttr->stImgIn.stVFrame = videoFrameOut;
468 unit_test_set_vgs_drawline_array_info(pstDrawLine, ctx, u32ArraySize);
469 return s32Ret;
470 }
471
unit_test_set_vgs_mosaic_array_info(VGS_MOSAIC_S * pstVgsMosaic,const TEST_VGS_CTX_S * ctx,RK_U32 u32ArraySize)472 RK_VOID unit_test_set_vgs_mosaic_array_info(
473 VGS_MOSAIC_S *pstVgsMosaic, const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize) {
474 VGS_MOSAIC_BLK_SIZE_E u32BlkSize[VGS_MAX_TASK_NUM] = {RK_MOSAIC_BLK_SIZE_8,
475 RK_MOSAIC_BLK_SIZE_16, RK_MOSAIC_BLK_SIZE_32, RK_MOSAIC_BLK_SIZE_64};
476 RK_S32 xoffset = 240;
477 RK_S32 yoffset = 160;
478
479 for (RK_S32 i = 0; i < u32ArraySize; i++) {
480 pstVgsMosaic[i].enBlkSize = u32BlkSize[i];
481 pstVgsMosaic[i].stDstRect.s32X = i*xoffset;
482 pstVgsMosaic[i].stDstRect.s32Y = i*yoffset;
483 pstVgsMosaic[i].stDstRect.u32Width = xoffset;
484 pstVgsMosaic[i].stDstRect.u32Height = yoffset;
485 }
486 }
487
unit_test_vgs_generate_mosaic_task_array(const VGS_TASK_ATTR_S * pstTask,VGS_MOSAIC_S * astVgsMosaic,const TEST_VGS_CTX_S * ctx,RK_U32 u32ArraySize,MB_BLK srcBlk)488 RK_S32 unit_test_vgs_generate_mosaic_task_array(
489 const VGS_TASK_ATTR_S *pstTask, VGS_MOSAIC_S *astVgsMosaic,
490 const TEST_VGS_CTX_S *ctx, RK_U32 u32ArraySize, MB_BLK srcBlk) {
491 RK_S32 s32Ret = RK_SUCCESS;
492 VIDEO_FRAME_S videoFrameOut = {0};
493 VGS_TASK_ATTR_S *pTaskAttr = const_cast<VGS_TASK_ATTR_S *>(pstTask);
494 MB_BLK dstBlk = RK_NULL;
495
496 s32Ret = RK_MPI_SYS_MmzAlloc(&dstBlk, RK_NULL, RK_NULL, ctx->u32SrcSize);
497 if (s32Ret != RK_SUCCESS) {
498 return s32Ret;
499 }
500 memcpy(RK_MPI_MB_Handle2VirAddr(dstBlk),
501 RK_MPI_MB_Handle2VirAddr(srcBlk), ctx->u32SrcSize);
502
503 videoFrameOut.u32Width = ctx->s32SrcWidth;
504 videoFrameOut.u32Height = ctx->s32SrcHeight;
505 videoFrameOut.u32VirWidth = ctx->s32SrcVirWidth;
506 videoFrameOut.u32VirHeight = ctx->s32SrcVirHeight;
507 videoFrameOut.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
508 videoFrameOut.u32TimeRef = 0;
509 videoFrameOut.u64PTS = 0;
510 videoFrameOut.pMbBlk = dstBlk;
511
512 pTaskAttr->stImgIn.stVFrame = videoFrameOut;
513 pTaskAttr->stImgOut.stVFrame = videoFrameOut;
514 unit_test_set_vgs_mosaic_array_info(astVgsMosaic, ctx, u32ArraySize);
515 return s32Ret;
516 }
517
unit_test_vgs_output_one_task(const VGS_TASK_ATTR_S * pstTask,const TEST_VGS_CTX_S * ctx,RK_U32 jobId,RK_U32 taskId)518 RK_S32 unit_test_vgs_output_one_task(
519 const VGS_TASK_ATTR_S *pstTask, const TEST_VGS_CTX_S *ctx, RK_U32 jobId, RK_U32 taskId) {
520 RK_S32 s32Ret = RK_SUCCESS;
521 char yuv_out_path[1024] = {0};
522 VGS_TASK_ATTR_S *pTaskAttr = const_cast<VGS_TASK_ATTR_S *>(pstTask);
523 VIDEO_FRAME_S videoFrameOut = pTaskAttr->stImgOut.stVFrame;
524 MB_BLK bBlk = videoFrameOut.pMbBlk;
525 RK_VOID *pstFrame = RK_MPI_MB_Handle2VirAddr(bBlk);
526 const char *dstFilePath = ctx->dstFilePath;
527 PIC_BUF_ATTR_S stPicBufAttr;
528 MB_PIC_CAL_S stMbPicCalResult;
529
530 stPicBufAttr.u32Width = videoFrameOut.u32Width;
531 stPicBufAttr.u32Height = videoFrameOut.u32Height;
532 stPicBufAttr.enPixelFormat = videoFrameOut.enPixelFormat;
533 stPicBufAttr.enCompMode = videoFrameOut.enCompressMode;
534 s32Ret = RK_MPI_CAL_VGS_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
535 if (s32Ret != RK_SUCCESS) {
536 RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
537 return s32Ret;
538 }
539 RK_U32 u32OutputSize = stMbPicCalResult.u32MBSize;
540 if (dstFilePath) {
541 snprintf(yuv_out_path,
542 sizeof(yuv_out_path),
543 "%svgs_out_%dx%d_j_%d_t_%d.yuv",
544 dstFilePath,
545 videoFrameOut.u32VirWidth,
546 videoFrameOut.u32VirHeight, jobId, taskId);
547
548 FILE *file = fopen(yuv_out_path, "wb+");
549 if (file == RK_NULL) {
550 RK_LOGE("open path %s failed because %s.", yuv_out_path, strerror(errno));
551 return RK_ERR_SYS_NULL_PTR;
552 }
553 if (file) {
554 if (pstFrame) {
555 RK_LOGD("get frame data = %p, size = %d, bBlk:%p ", pstFrame, u32OutputSize, bBlk);
556 RK_MPI_SYS_MmzFlushCache(bBlk, RK_TRUE);
557 fwrite(pstFrame, 1, u32OutputSize, file);
558 fflush(file);
559 }
560 fclose(file);
561 file = NULL;
562 }
563 }
564
565 RK_MPI_MB_ReleaseMB(bBlk);
566 return RK_SUCCESS;
567 }
568
unit_test_vgs_out_all_task(VGS_HANDLE hHandle,VGS_TASK_ATTR_S * pstTask,const TEST_VGS_CTX_S * ctx,RK_S32 jobId,RK_U32 u32TestTime)569 RK_S32 unit_test_vgs_out_all_task(
570 VGS_HANDLE hHandle, VGS_TASK_ATTR_S *pstTask,
571 const TEST_VGS_CTX_S *ctx, RK_S32 jobId, RK_U32 u32TestTime) {
572 RK_S32 s32Ret = RK_SUCCESS;
573 for (RK_S32 i =0; i < u32TestTime; i++) {
574 unit_test_vgs_output_one_task(&pstTask[i], ctx, jobId, i);
575 }
576 return RK_SUCCESS;
577 }
578
unit_test_release_task_ctx(TEST_TASK_CTX_S * taskCtx)579 RK_S32 unit_test_release_task_ctx(TEST_TASK_CTX_S *taskCtx) {
580 RK_S32 s32Ret = RK_SUCCESS;
581 VGS_ADD_OSD_S *enOsdInfo = taskCtx->enOsdInfo;
582 for (RK_S32 i = 0; i < VGS_MAX_TASK_NUM; i++) {
583 if ((enOsdInfo[i]).pMbBlk) {
584 s32Ret = RK_MPI_MB_ReleaseMB((enOsdInfo[i]).pMbBlk);
585 }
586 }
587 return s32Ret;
588 }
589
unit_test_vgs_add_one_task(VGS_HANDLE hHandle,VGS_TASK_ATTR_S * pstTask,const TEST_VGS_CTX_S * ctx,TEST_TASK_CTX_S * taskCtx,MB_BLK srcBlk,RK_S32 taskId)590 RK_S32 unit_test_vgs_add_one_task(
591 VGS_HANDLE hHandle, VGS_TASK_ATTR_S *pstTask, const TEST_VGS_CTX_S *ctx,
592 TEST_TASK_CTX_S *taskCtx, MB_BLK srcBlk, RK_S32 taskId) {
593 RK_S32 s32Ret = RK_SUCCESS;
594 VGS_ADD_COVER_S *enCoverInfo = taskCtx->enCoverInfo;
595 VGS_ADD_OSD_S *enOsdInfo = taskCtx->enOsdInfo;
596 VGS_MOSAIC_S *enMosaicInfo = taskCtx->enMosaicInfo;
597 VGS_DRAW_LINE_S *enDrawLine = taskCtx->enDrawLine;
598 VGS_CROP_INFO_S *pstCropInfo = &(taskCtx->stCropInfo);
599 RK_S32 testTaskType = ctx->s32TaskType;
600 RK_S32 s32TaskNum = ctx->s32TaskNum;
601 RK_U32 u32ArraySize = ctx->u32TaskArraySize;
602 RK_S32 s32Angle = ctx->s32Angle;
603 switch (testTaskType) {
604 case VGS_TASK_TYPE_SCALE:
605 s32Ret = unit_test_vgs_generate_scale_task(pstTask, ctx, srcBlk);
606 if (s32Ret != RK_SUCCESS) {
607 return s32Ret;
608 }
609 s32Ret = RK_MPI_VGS_AddScaleTask(hHandle, pstTask, VGS_SCLCOEF_NORMAL);
610 break;
611 case VGS_TASK_TYPE_ROTATE:
612 s32Ret = unit_test_vgs_generate_rotation_task(pstTask, ctx, srcBlk);
613 if (s32Ret != RK_SUCCESS) {
614 return s32Ret;
615 }
616 s32Ret = RK_MPI_VGS_AddRotationTask(hHandle, pstTask, ROTATION_E(s32Angle));
617 break;
618 case VGS_TASK_TYPE_CROP:
619 s32Ret = unit_test_vgs_generate_crop_task(pstTask, pstCropInfo, ctx, srcBlk);
620 if (s32Ret != RK_SUCCESS) {
621 return s32Ret;
622 }
623 s32Ret = RK_MPI_VGS_AddCropTask(hHandle, pstTask, pstCropInfo);
624 break;
625 case VGS_TASK_TYPE_DRAW_LINE:
626 s32Ret = unit_test_vgs_generate_drawline_task_array(pstTask, enDrawLine, ctx, u32ArraySize, srcBlk);
627 if (s32Ret != RK_SUCCESS) {
628 return s32Ret;
629 }
630 if (u32ArraySize == 1) {
631 s32Ret = RK_MPI_VGS_AddDrawLineTask(hHandle, pstTask, enDrawLine);
632 } else {
633 s32Ret = RK_MPI_VGS_AddDrawLineTaskArray(hHandle, pstTask, enDrawLine, u32ArraySize);
634 }
635 break;
636 case VGS_TASK_TYPE_COVER:
637 s32Ret = unit_test_vgs_generate_cover_task_array(pstTask, enCoverInfo, ctx, u32ArraySize, srcBlk);
638 if (s32Ret != RK_SUCCESS) {
639 return s32Ret;
640 }
641 if (u32ArraySize == 1) {
642 s32Ret = RK_MPI_VGS_AddCoverTask(hHandle, pstTask, enCoverInfo);
643 } else {
644 s32Ret = RK_MPI_VGS_AddCoverTaskArray(hHandle, pstTask, enCoverInfo, u32ArraySize);
645 }
646 break;
647 case VGS_TASK_TYPE_OSD:
648 s32Ret = unit_test_vgs_generate_osd_task_array(
649 pstTask, &enOsdInfo[taskId*u32ArraySize], ctx, u32ArraySize, srcBlk);
650 if (s32Ret != RK_SUCCESS) {
651 return s32Ret;
652 }
653 if (u32ArraySize == 1) {
654 s32Ret = RK_MPI_VGS_AddOsdTask(hHandle, pstTask, enOsdInfo);
655 } else {
656 s32Ret = RK_MPI_VGS_AddOsdTaskArray(hHandle, pstTask, &enOsdInfo[taskId*u32ArraySize], u32ArraySize);
657 }
658 break;
659 case VGS_TASK_TYPE_MOSAIC:
660 s32Ret = unit_test_vgs_generate_mosaic_task_array(pstTask, enMosaicInfo, ctx, u32ArraySize, srcBlk);
661 if (s32Ret != RK_SUCCESS) {
662 return s32Ret;
663 }
664 if (u32ArraySize == 1) {
665 s32Ret = RK_MPI_VGS_AddMosaicTask(hHandle, pstTask, enMosaicInfo);
666 } else {
667 s32Ret = RK_MPI_VGS_AddMosaicTaskArray(hHandle, pstTask, enMosaicInfo, u32ArraySize);
668 }
669 break;
670 default:
671 break;
672 }
673 if (s32Ret != RK_SUCCESS) {
674 RK_MPI_VGS_CancelJob(hHandle);
675 return s32Ret;
676 }
677 if (taskId == (s32TaskNum -1)) {
678 s32Ret = RK_MPI_VGS_EndJob(hHandle);
679 }
680 if (s32Ret != RK_SUCCESS) {
681 RK_MPI_VGS_CancelJob(hHandle);
682 }
683 return s32Ret;
684 }
685
unit_test_vgs_add_all_task(VGS_HANDLE hHandle,VGS_TASK_ATTR_S * pstTask,const TEST_VGS_CTX_S * ctx,TEST_TASK_CTX_S * taskCtx,RK_U32 u32TestTime,MB_BLK srcBlk,RK_S32 * u32AllTestTime)686 RK_S32 unit_test_vgs_add_all_task(
687 VGS_HANDLE hHandle, VGS_TASK_ATTR_S *pstTask, const TEST_VGS_CTX_S *ctx, TEST_TASK_CTX_S *taskCtx,
688 RK_U32 u32TestTime, MB_BLK srcBlk, RK_S32 *u32AllTestTime) {
689 RK_S32 s32Ret = RK_SUCCESS;
690 VGS_ADD_COVER_S *enCoverInfo = taskCtx->enCoverInfo;
691 VGS_ADD_OSD_S *enOsdInfo = taskCtx->enOsdInfo;
692 VGS_MOSAIC_S *enMosaicInfo = taskCtx->enMosaicInfo;
693 VGS_DRAW_LINE_S *enDrawLine = taskCtx->enDrawLine;
694 RK_U32 u32TaskIndex = 0;
695 RK_U32 u32ArraySize = 4;
696 RK_U32 u32ScaleWidth = 0;
697 RK_U32 u32ScaleHeight = 0;
698 RK_U32 u32Angle = ctx->s32Angle;
699 for (RK_S32 i = 0; i < u32TestTime; i++) {
700 u32ScaleWidth = ctx->s32DstWidth;
701 u32ScaleHeight = ctx->s32DstHeight;
702 s32Ret = unit_test_vgs_generate_scale_task(&pstTask[u32TaskIndex], ctx, srcBlk);
703 if (s32Ret != RK_SUCCESS) {
704 return s32Ret;
705 }
706 s32Ret = RK_MPI_VGS_AddScaleTask(hHandle, &pstTask[u32TaskIndex], VGS_SCLCOEF_NORMAL);
707 if (s32Ret != RK_SUCCESS) {
708 RK_MPI_VGS_CancelJob(hHandle);
709 return s32Ret;
710 }
711 u32TaskIndex++;
712 }
713 for (RK_S32 i = 0; i < u32TestTime; i++) {
714 s32Ret = unit_test_vgs_generate_rotation_task(&pstTask[u32TaskIndex], ctx, srcBlk);
715 if (s32Ret != RK_SUCCESS) {
716 return s32Ret;
717 }
718 s32Ret = RK_MPI_VGS_AddRotationTask(hHandle, &pstTask[u32TaskIndex], (ROTATION_E)u32Angle);
719 if (s32Ret != RK_SUCCESS) {
720 RK_MPI_VGS_CancelJob(hHandle);
721 return s32Ret;
722 }
723 u32TaskIndex++;
724 }
725 for (RK_S32 i = 0; i < u32TestTime; i++) {
726 s32Ret = unit_test_vgs_generate_cover_task_array(
727 &pstTask[u32TaskIndex], enCoverInfo, ctx, u32ArraySize, srcBlk);
728 if (s32Ret != RK_SUCCESS) {
729 return s32Ret;
730 }
731 s32Ret = RK_MPI_VGS_AddCoverTaskArray(hHandle, &pstTask[u32TaskIndex], enCoverInfo, u32ArraySize);
732 if (s32Ret != RK_SUCCESS) {
733 RK_MPI_VGS_CancelJob(hHandle);
734 return s32Ret;
735 }
736 u32TaskIndex++;
737 }
738 for (RK_S32 i = 0; i < u32TestTime; i++) {
739 s32Ret = unit_test_vgs_generate_osd_task_array(
740 &pstTask[u32TaskIndex], &enOsdInfo[i*u32ArraySize], ctx, u32ArraySize, srcBlk);
741 if (s32Ret != RK_SUCCESS) {
742 return s32Ret;
743 }
744 RK_MPI_VGS_AddOsdTaskArray(hHandle, &pstTask[u32TaskIndex], &enOsdInfo[i*u32ArraySize], u32ArraySize);
745 if (s32Ret != RK_SUCCESS) {
746 RK_MPI_VGS_CancelJob(hHandle);
747 return s32Ret;
748 }
749 u32TaskIndex++;
750 }
751 for (RK_S32 i = 0; i < u32TestTime; i++) {
752 s32Ret = unit_test_vgs_generate_drawline_task_array(
753 &pstTask[u32TaskIndex], enDrawLine, ctx, u32ArraySize, srcBlk);
754 if (s32Ret != RK_SUCCESS) {
755 return s32Ret;
756 }
757 s32Ret = RK_MPI_VGS_AddDrawLineTaskArray(hHandle, &pstTask[u32TaskIndex], enDrawLine, u32ArraySize);
758 if (s32Ret != RK_SUCCESS) {
759 RK_MPI_VGS_CancelJob(hHandle);
760 return s32Ret;
761 }
762 u32TaskIndex++;
763 }
764
765 for (RK_S32 i = 0; i < u32TestTime; i++) {
766 s32Ret = unit_test_vgs_generate_mosaic_task_array(
767 &pstTask[u32TaskIndex], enMosaicInfo, ctx, u32ArraySize, srcBlk);
768 if (s32Ret != RK_SUCCESS) {
769 return s32Ret;
770 }
771 s32Ret = RK_MPI_VGS_AddMosaicTaskArray(hHandle, &pstTask[u32TaskIndex], enMosaicInfo, u32ArraySize);
772 if (s32Ret != RK_SUCCESS) {
773 RK_MPI_VGS_CancelJob(hHandle);
774 return s32Ret;
775 }
776 u32TaskIndex++;
777 }
778
779 s32Ret = RK_MPI_VGS_EndJob(hHandle);
780 if (s32Ret != RK_SUCCESS) {
781 RK_MPI_VGS_CancelJob(hHandle);
782 return s32Ret;
783 }
784
785 *u32AllTestTime = u32TaskIndex;
786 return s32Ret;
787 }
788
unit_test_vgs_get_size(TEST_VGS_CTX_S * ctx)789 RK_U32 unit_test_vgs_get_size(TEST_VGS_CTX_S *ctx) {
790 RK_S32 s32Ret = RK_SUCCESS;
791 PIC_BUF_ATTR_S stPicBufAttr;
792 MB_PIC_CAL_S stMbPicCalResult;
793
794 if (ctx->s32SrcVirWidth == 0) {
795 ctx->s32SrcVirWidth = ctx->s32SrcWidth;
796 }
797 if (ctx->s32SrcVirHeight == 0) {
798 ctx->s32SrcVirHeight = ctx->s32SrcHeight;
799 }
800
801 stPicBufAttr.u32Width = ctx->s32SrcVirWidth;
802 stPicBufAttr.u32Height = ctx->s32SrcVirHeight;
803 stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
804 stPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32SrcCompressMode;
805 s32Ret = RK_MPI_CAL_COMM_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
806 if (s32Ret != RK_SUCCESS) {
807 RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
808 return s32Ret;
809 }
810
811 return stMbPicCalResult.u32MBSize;
812 }
813
unit_test_vgs_one_job(TEST_VGS_CTX_S * ctx)814 RK_S32 unit_test_vgs_one_job(TEST_VGS_CTX_S *ctx) {
815 RK_S32 s32Ret = RK_SUCCESS;
816 MB_BLK srcBlk = NULL;
817 RK_S32 s32TaskNum = ctx->s32TaskNum;
818 RK_S32 s32JobId = ctx->s32JobIdx;
819 RK_S32 s32TaskMode = ctx->s32TaskMode;
820 const char *srcFilePath = ctx->srcFilePath;
821 RK_S32 s32SrcPixFormat = ctx->s32SrcPixFormat;
822 RK_S32 s32SrcCompressMode = ctx->s32SrcCompressMode;
823 RK_S32 u32OneTaskTestTime = s32TaskNum;
824 RK_S32 u32AllTaskTestTime = 0;
825 VGS_HANDLE hHandleAll[VGS_MAX_JOB_NUM] = {0};
826 VGS_TASK_ATTR_S stTask[VGS_MAX_TASK_NUM] = {0};
827 VGS_HANDLE hHandle = hHandleAll[s32JobId];
828 RK_U32 s32SrcWidth = ctx->s32SrcWidth;
829 RK_U32 s32SrcHeight = ctx->s32SrcHeight;
830 TEST_TASK_CTX_S taskCtx;
831
832 memset(&taskCtx, 0, sizeof(TEST_TASK_CTX_S));
833 ctx->u32SrcSize = unit_test_vgs_get_size(ctx);
834 s32Ret = unit_test_vgs_generate_source(srcFilePath, &srcBlk, ctx->u32SrcSize);
835 if (s32Ret != RK_SUCCESS) {
836 goto __FAILED;
837 }
838 s32Ret = RK_MPI_VGS_BeginJob(&hHandle);
839 if (s32Ret != RK_SUCCESS) {
840 goto __FAILED;
841 }
842 if (s32TaskMode == VGS_TASK_MODE_ONE) {
843 for (RK_S32 taskId = 0; taskId < s32TaskNum; taskId++) {
844 s32Ret = unit_test_vgs_add_one_task(hHandle, &stTask[taskId], ctx, &taskCtx, srcBlk, taskId);
845 if (s32Ret != RK_SUCCESS) {
846 goto __FAILED;
847 }
848 }
849 for (RK_S32 taskId = 0; taskId < s32TaskNum; taskId++) {
850 s32Ret = unit_test_vgs_output_one_task(&stTask[taskId], ctx, s32JobId, taskId);
851 if (s32Ret != RK_SUCCESS) {
852 goto __FAILED;
853 }
854 }
855 } else if (s32TaskMode == VGS_TASK_MODE_ALL) {
856 s32Ret = unit_test_vgs_add_all_task(
857 hHandle, stTask, ctx, &taskCtx, u32OneTaskTestTime, srcBlk, &u32AllTaskTestTime);
858 if (s32Ret != RK_SUCCESS) {
859 goto __FAILED;
860 }
861 s32Ret = unit_test_vgs_out_all_task(hHandle, stTask, ctx, s32JobId, u32AllTaskTestTime);
862 if (s32Ret != RK_SUCCESS) {
863 goto __FAILED;
864 }
865 }
866 unit_test_release_task_ctx(&taskCtx);
867 RK_MPI_SYS_Free(srcBlk);
868 RK_LOGD("single vgs test jobid %d running success.", s32JobId);
869 return s32Ret;
870 __FAILED:
871 unit_test_release_task_ctx(&taskCtx);
872 RK_MPI_SYS_Free(srcBlk);
873 RK_LOGE("single vgs test jobid %d running failed.", s32JobId);
874 return s32Ret;
875 }
876
unit_test_vgs_counts(void * arg)877 static void *unit_test_vgs_counts(void *arg) {
878 TEST_VGS_CTX_S *ctx = reinterpret_cast<TEST_VGS_CTX_S *>(arg);
879 RK_S32 s32LoopCout = ctx->s32LoopCount;
880 RK_S32 s32LoopNum = 0;
881 RK_S32 s32Ret = RK_SUCCESS;
882 for (RK_S32 i = 0; i < s32LoopCout; i++) {
883 s32Ret = unit_test_vgs_one_job(ctx);
884 if (s32Ret != RK_SUCCESS) {
885 s32LoopNum = i;
886 goto __FAILED;
887 }
888 }
889 return RK_NULL;
890 __FAILED:
891 RK_LOGE("single vgs test %d running failed.", s32LoopNum);
892 return RK_NULL;
893 }
894
unit_test_vgs_set_default_ctx(TEST_VGS_CTX_S * ctx,TEST_VGS_PROC_CTX_S * procCtx)895 RK_S32 unit_test_vgs_set_default_ctx(TEST_VGS_CTX_S *ctx, TEST_VGS_PROC_CTX_S *procCtx) {
896 procCtx->stImgIn.stVFrame.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32SrcPixFormat;
897 procCtx->stImgIn.stVFrame.u32Width = ctx->s32SrcWidth;
898 procCtx->stImgIn.stVFrame.u32Height = ctx->s32SrcHeight;
899 procCtx->stImgIn.stVFrame.enCompressMode = (COMPRESS_MODE_E)ctx->s32SrcCompressMode;
900 procCtx->stImgOut.stVFrame.enPixelFormat = (PIXEL_FORMAT_E)ctx->s32DstPixFormat;
901 procCtx->stImgOut.stVFrame.u32Width = ctx->s32DstWidth;
902 procCtx->stImgOut.stVFrame.u32Height = ctx->s32DstHeight;
903 procCtx->stImgOut.stVFrame.enCompressMode = (COMPRESS_MODE_E)ctx->s32DstCompressMode;
904 procCtx->s32ProcessTimes = ctx->s32ProcessTime;
905 procCtx->s32JobNum = ctx->s32JobNum;
906 procCtx->s32TaskNum = ctx->s32TaskNum;
907 procCtx->opType = VGS_OP_QUICK_RESIZE;
908 return RK_SUCCESS;
909 }
910
unit_test_vgs_all_job(TEST_VGS_CTX_S * ctx)911 RK_S32 unit_test_vgs_all_job(TEST_VGS_CTX_S *ctx) {
912 RK_S32 s32Ret = RK_SUCCESS;
913 RK_S32 s32JobId = ctx->s32JobIdx;
914 RK_S32 u32JobTestTime = ctx->s32JobNum;
915 const char *srcFilePath = ctx->srcFilePath;
916 RK_S32 u32OneTaskTestTime = 1;
917 RK_S32 u32AllTaskTestTime = 0;
918 void *pSrcData = RK_NULL;
919 MB_BLK srcBlk = RK_NULL;
920 VGS_HANDLE hHandleAll[VGS_MAX_JOB_NUM];
921 VGS_TASK_ATTR_S stTask[VGS_MAX_TASK_NUM];
922 TEST_TASK_CTX_S taskCtx;
923
924 memset(&taskCtx, 0, sizeof(TEST_TASK_CTX_S));
925 ctx->u32SrcSize = unit_test_vgs_get_size(ctx);
926 s32Ret = unit_test_vgs_generate_source(srcFilePath, &srcBlk, ctx->u32SrcSize);
927 if (s32Ret == RK_SUCCESS) {
928 for (RK_S32 i = 0; i < u32JobTestTime; i++) {
929 VGS_HANDLE hHandle = hHandleAll[i];
930 s32Ret = RK_MPI_VGS_BeginJob(&hHandle);
931 if (s32Ret == RK_SUCCESS) {
932 s32Ret = unit_test_vgs_add_all_task(
933 hHandle, stTask, ctx, &taskCtx, u32OneTaskTestTime, srcBlk, &u32AllTaskTestTime);
934 if (s32Ret == RK_SUCCESS) {
935 s32Ret = unit_test_vgs_out_all_task(hHandle, stTask, ctx, s32JobId, u32AllTaskTestTime);
936 }
937 }
938 }
939 }
940 unit_test_release_task_ctx(&taskCtx);
941 RK_MPI_SYS_Free(srcBlk);
942 return s32Ret;
943 }
944
unit_test_mpi_vgs(TEST_VGS_CTX_S * ctx)945 RK_S32 unit_test_mpi_vgs(TEST_VGS_CTX_S *ctx) {
946 RK_S32 s32Ret = RK_SUCCESS;
947 pthread_t tids[VGS_MAX_JOB_NUM];
948 TEST_VGS_CTX_S tmpCtx[VGS_MAX_JOB_NUM];
949
950 for (RK_S32 jobIndex = 0; jobIndex < ctx->s32JobNum; jobIndex++) {
951 memcpy(&(tmpCtx[jobIndex]), ctx, sizeof(TEST_VGS_CTX_S));
952 pthread_create(&tids[jobIndex], 0, unit_test_vgs_counts, reinterpret_cast<void *>(&tmpCtx[jobIndex]));
953 ctx->s32JobIdx++;
954 }
955
956 for (RK_S32 jobIndex = 0; jobIndex < ctx->s32JobNum; jobIndex++) {
957 pthread_join(tids[jobIndex], RK_NULL);
958 }
959
960 return s32Ret;
961 }
962
963 static const char *const usages[] = {
964 "./rk_mpi_vgs_test [-i SRC_PATH] [-o DST_PATH] [--src_width SRC_WIDTH]"
965 "[--src_height SRC_HEIGHT] [--dst_width DST_WIDTH] [--dst_height DST_HEIGHT]",
966 NULL,
967 };
968
mpi_vgs_test_show_options(const TEST_VGS_CTX_S * ctx)969 static void mpi_vgs_test_show_options(const TEST_VGS_CTX_S *ctx) {
970 RK_PRINT("cmd parse result:\n");
971 RK_PRINT("input file name : %s\n", ctx->srcFilePath);
972 RK_PRINT("output file name : %s\n", ctx->dstFilePath);
973 RK_PRINT("osd file name : %s\n", ctx->osdFilePath);
974 RK_PRINT("loop count : %d\n", ctx->s32LoopCount);
975 RK_PRINT("job number : %d\n", ctx->s32JobNum);
976 RK_PRINT("task number : %d\n", ctx->s32TaskNum);
977 RK_PRINT("task type : %d\n", ctx->s32TaskType);
978 RK_PRINT("task mode : %d\n", ctx->s32TaskMode);
979 RK_PRINT("task array size : %d\n", ctx->u32TaskArraySize);
980 RK_PRINT("rotate task angle : %d\n", ctx->s32Angle);
981 RK_PRINT("input width : %d\n", ctx->s32SrcWidth);
982 RK_PRINT("input height : %d\n", ctx->s32SrcHeight);
983 RK_PRINT("input vir width : %d\n", ctx->s32SrcVirWidth);
984 RK_PRINT("input vir height : %d\n", ctx->s32SrcVirHeight);
985 RK_PRINT("input compress mode : %d\n", ctx->s32SrcCompressMode);
986 RK_PRINT("input pixel format : %d\n", ctx->s32SrcPixFormat);
987 RK_PRINT("output width : %d\n", ctx->s32DstWidth);
988 RK_PRINT("output height : %d\n", ctx->s32DstHeight);
989 RK_PRINT("output compress mode : %d\n", ctx->s32DstCompressMode);
990 RK_PRINT("output pixel format : %d\n", ctx->s32DstPixFormat);
991 RK_PRINT("osd width : %d\n", ctx->s32OsdWidth);
992 RK_PRINT("osd height : %d\n", ctx->s32OsdHeight);
993 RK_PRINT("osd compress mode : %d\n", ctx->s32OsdCompressMode);
994 RK_PRINT("osd pixel format : %d\n", ctx->s32OsdPixFormat);
995 RK_PRINT("crop x : %d\n", ctx->stCropRect.s32X);
996 RK_PRINT("crop y : %d\n", ctx->stCropRect.s32Y);
997 RK_PRINT("crop w : %d\n", ctx->stCropRect.u32Width);
998 RK_PRINT("crop h : %d\n", ctx->stCropRect.u32Height);
999 }
main(int argc,const char ** argv)1000 int main(int argc, const char **argv) {
1001 TEST_VGS_CTX_S ctx;
1002 memset(&ctx, 0, sizeof(TEST_VGS_CTX_S));
1003 RK_S32 s32Ret = RK_SUCCESS;
1004 // set default params.
1005 ctx.dstFilePath = RK_NULL;
1006 ctx.s32LoopCount = 1;
1007 ctx.s32JobNum = 1;
1008 ctx.s32TaskNum = 1;
1009 ctx.s32TaskType = VGS_TASK_TYPE_COVER;
1010 ctx.u32TaskArraySize = 1;
1011 ctx.s32SrcCompressMode = 0;
1012 ctx.s32SrcPixFormat = RK_FMT_YUV420SP;
1013 ctx.s32DstCompressMode = 0;
1014 ctx.s32DstPixFormat = RK_FMT_YUV420SP;
1015 ctx.bPerformace = RK_FALSE;
1016 ctx.s32ProcessTime = 500;
1017
1018 struct argparse_option options[] = {
1019 OPT_HELP(),
1020 OPT_GROUP("basic options:"),
1021 OPT_STRING('i', "input", &(ctx.srcFilePath),
1022 "input file name. e.g.(/userdata/1080p.nv12). <required>", NULL, 0, 0),
1023 OPT_STRING('o', "output", &(ctx.dstFilePath),
1024 "output file path. e.g.(/userdata/vgs/). default(NULL).", NULL, 0, 0),
1025 OPT_INTEGER('n', "loop_count", &(ctx.s32LoopCount),
1026 "loop running count. default(1)", NULL, 0, 0),
1027 OPT_INTEGER('j', "job_number", &(ctx.s32JobNum),
1028 "the job number of vgs. default(1).", NULL, 0, 0),
1029 OPT_INTEGER('t', "task_number", &(ctx.s32TaskNum),
1030 "the task number of one job. default(1).", NULL, 0, 0),
1031 OPT_STRING('\0', "osd_file", &(ctx.osdFilePath),
1032 "osd file path. e.g.(/userdata/vgs/). default(NULL).", NULL, 0, 0),
1033 OPT_INTEGER('\0', "task_type", &(ctx.s32TaskType),
1034 "vgs task type. range(1,6). 1.scale. 2.rotate. 3.draw_line. 4.cover. 5.osd. 6.mosaic.", NULL, 0, 0),
1035 OPT_INTEGER('\0', "task_mode", &(ctx.s32TaskMode),
1036 "task mode. 1: only one task type in one job. 2: all task type in one job. default(1)", NULL, 0, 0),
1037 OPT_INTEGER('\0', "task_array_size", &(ctx.u32TaskArraySize),
1038 "array task size range(1,100). default(1)", NULL, 0, 0),
1039 OPT_INTEGER('\0', "angle", &(ctx.s32Angle),
1040 "rotate task angle. 0:0. 1:90. 2:180. 3:270. default(1)", NULL, 0, 0),
1041 OPT_INTEGER('\0', "src_width", &(ctx.s32SrcWidth),
1042 "src width. e.g.(1920). <required>", NULL, 0, 0),
1043 OPT_INTEGER('\0', "src_height", &(ctx.s32SrcHeight),
1044 "src height. e.g.(1080). <required>", NULL, 0, 0),
1045 OPT_INTEGER('\0', "src_vir_width", &(ctx.s32SrcVirWidth),
1046 "src vir width. e.g.(1920).", NULL, 0, 0),
1047 OPT_INTEGER('\0', "src_vir_height", &(ctx.s32SrcVirHeight),
1048 "src vir height. e.g.(1080).", NULL, 0, 0),
1049 OPT_INTEGER('\0', "src_compress", &(ctx.s32SrcCompressMode),
1050 "src compress mode. default(0).", NULL, 0, 0),
1051 OPT_INTEGER('\0', "src_format", &(ctx.s32SrcPixFormat),
1052 "src pixel format. default(0. 0 is NV12).", NULL, 0, 0),
1053 OPT_INTEGER('\0', "dst_width", &(ctx.s32DstWidth),
1054 "dst width. e.g.(1920). <required>", NULL, 0, 0),
1055 OPT_INTEGER('\0', "dst_height", &(ctx.s32DstHeight),
1056 "dst height. e.g.(1080). <required>", NULL, 0, 0),
1057 OPT_INTEGER('\0', "dst_compress", &(ctx.s32DstCompressMode),
1058 "dst compress mode. default(0).", NULL, 0, 0),
1059 OPT_INTEGER('\0', "dst_format", &(ctx.s32DstPixFormat),
1060 "dst pixel format. default(0. 0 is NV12).", NULL, 0, 0),
1061 OPT_INTEGER('\0', "osd_width", &(ctx.s32OsdWidth),
1062 "osd width. e.g.(1920). <required on OSD>", NULL, 0, 0),
1063 OPT_INTEGER('\0', "osd_height", &(ctx.s32OsdHeight),
1064 "osd height. e.g.(1080). <required on OSD>", NULL, 0, 0),
1065 OPT_INTEGER('\0', "osd_compress", &(ctx.s32OsdCompressMode),
1066 "osd compress mode. default(0).", NULL, 0, 0),
1067 OPT_INTEGER('\0', "osd_format", &(ctx.s32OsdPixFormat),
1068 "osd pixel format. default(0. 0 is NV12).", NULL, 0, 0),
1069 OPT_INTEGER('\0', "crop_x", &(ctx.stCropRect.s32X),
1070 "crop ratio rect x. default(0).", NULL, 0, 0),
1071 OPT_INTEGER('\0', "crop_y", &(ctx.stCropRect.s32Y),
1072 "crop ratio rect y. default(0).", NULL, 0, 0),
1073 OPT_INTEGER('\0', "crop_w", &(ctx.stCropRect.u32Width),
1074 "crop ratio rect width. default(0).", NULL, 0, 0),
1075 OPT_INTEGER('\0', "crop_h", &(ctx.stCropRect.u32Height),
1076 "crop ratio rect height. default(0).", NULL, 0, 0),
1077 OPT_INTEGER('\0', "performace", &(ctx.bPerformace),
1078 "performace. default(0).", NULL, 0, 0),
1079 OPT_INTEGER('\0', "proc_time", &(ctx.s32ProcessTime),
1080 "s32ProcessTime. default(500).", NULL, 0, 0),
1081 OPT_END(),
1082 };
1083
1084 struct argparse argparse;
1085 argparse_init(&argparse, options, usages, 0);
1086 argparse_describe(&argparse, "\nselect a test case to run.",
1087 "\nuse --help for details.");
1088
1089 argc = argparse_parse(&argparse, argc, argv);
1090 mpi_vgs_test_show_options(&ctx);
1091
1092 if (ctx.s32SrcWidth <= 0
1093 || ctx.s32SrcHeight <= 0
1094 || ctx.s32DstWidth <= 0
1095 || ctx.s32DstHeight <= 0) {
1096 argparse_usage(&argparse);
1097 goto __FAILED;
1098 }
1099 s32Ret = RK_MPI_SYS_Init();
1100 if (s32Ret != RK_SUCCESS) {
1101 goto __FAILED;
1102 }
1103 if (ctx.bPerformace) {
1104 TEST_VGS_PROC_CTX_S vgsTestCtx;
1105 unit_test_vgs_set_default_ctx(&ctx, &vgsTestCtx);
1106 s32Ret = TEST_VGS_MultiTest(&vgsTestCtx);
1107 } else {
1108 s32Ret = unit_test_mpi_vgs(&ctx);
1109 }
1110
1111 s32Ret = RK_MPI_SYS_Exit();
1112 if (s32Ret != RK_SUCCESS) {
1113 goto __FAILED;
1114 }
1115 RK_LOGD("test done !\n");
1116 __FAILED:
1117 return 0;
1118 }
1119