1 /* Copyright 2020 Rockchip Electronics Co. LTD
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 *
15 * author: rimon.xu@rock-chips.com
16 * date: 2020-11-06
17 */
18
19 #include <stdio.h>
20 #include <errno.h>
21 #include <unistd.h>
22 #include <string.h>
23 #include "rk_debug.h"
24 #include "rk_mpi_mb.h"
25 #include "rk_comm_tde.h"
26 #include "rk_comm_video.h"
27 #include "rk_mpi_tde.h"
28 #include "rk_mpi_sys.h"
29 #include "rk_mpi_cal.h"
30 #include "test_comm_argparse.h"
31 #include "test_comm_utils.h"
32 #include "test_comm_tde.h"
33
34 typedef struct _rkTDEOpMap {
35 RK_S32 op;
36 const char* strOp;
37 } TDE_OP_MAP_S;
38
39 const static TDE_OP_MAP_S gstTdeOpMaps[] = {
40 { TDE_OP_QUICK_COPY, "quick_copy" },
41 { TDE_OP_QUICK_RESIZE, "quick_resize" },
42 { TDE_OP_QUICK_FILL, "quick_fill" },
43 { TDE_OP_ROTATION, "rotation" },
44 { TDE_OP_MIRROR, "mirror" },
45 { TDE_OP_COLOR_KEY, "color_key" }
46 };
47
48 typedef struct _rkMpiTdeCtx {
49 const char *srcFilePath;
50 const char *dstFilePath;
51 const char *backgroundFile;
52 RK_S32 s32LoopCount;
53 RK_S32 s32JobNum;
54 RK_S32 s32TaskNum;
55 RK_S32 s32Rotation;
56 RK_S32 s32Operation;
57 TDE_SURFACE_S stSrcSurface;
58 TDE_SURFACE_S stDstSurface;
59 RECT_S stSrcRect;
60 RECT_S stDstRect;
61 RK_U32 u32SrcVirWidth;
62 RK_U32 u32SrcVirHeight;
63 RK_S32 s32SrcCompressMode;
64 RK_S32 s32DstCompressMode;
65 RK_S32 s32Color;
66 RK_S32 s32ColorKey;
67 RK_S32 s32Mirror;
68 RK_S32 s32ProcessTime;
69 RK_BOOL bPerformace;
70 } TEST_TDE_CTX_S;
71
test_tde_str_op(RK_S32 op)72 static const char *test_tde_str_op(RK_S32 op) {
73 RK_S32 s32ElemLen = sizeof(gstTdeOpMaps) / sizeof(gstTdeOpMaps[0]);
74 for (size_t i = 0; i < s32ElemLen; i++) {
75 if (op == gstTdeOpMaps[i].op) {
76 return gstTdeOpMaps[i].strOp;
77 }
78 }
79 return RK_NULL;
80 }
81
test_tde_save_result(TEST_TDE_CTX_S * ctx,TDE_SURFACE_S * pstDst,RK_S32 u32TaskId)82 RK_S32 test_tde_save_result(TEST_TDE_CTX_S *ctx, TDE_SURFACE_S *pstDst, RK_S32 u32TaskId) {
83 char yuv_out_path[1024] = {0};
84 RK_S32 s32Ret = RK_SUCCESS;
85 PIC_BUF_ATTR_S stPicBufAttr;
86 MB_PIC_CAL_S stMbPicCalResult;
87 MB_BLK dstBlk = pstDst->pMbBlk;
88 RK_VOID *pstFrame = RK_MPI_MB_Handle2VirAddr(dstBlk);
89 stPicBufAttr.u32Width = ctx->stDstSurface.u32Width;
90 stPicBufAttr.u32Height = ctx->stDstSurface.u32Height;
91 stPicBufAttr.enPixelFormat = ctx->stDstSurface.enColorFmt;
92 stPicBufAttr.enCompMode = COMPRESS_MODE_E(ctx->s32DstCompressMode);;
93
94 s32Ret = RK_MPI_CAL_TDE_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
95 if (s32Ret != RK_SUCCESS) {
96 RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
97 return s32Ret;
98 }
99
100 snprintf(yuv_out_path, sizeof(yuv_out_path), "%s%s_%dx%d_%d.bin",
101 ctx->dstFilePath, test_tde_str_op(ctx->s32Operation),
102 stPicBufAttr.u32Width, stPicBufAttr.u32Height, u32TaskId);
103
104 FILE *file = fopen(yuv_out_path, "wb+");
105 if (file == RK_NULL) {
106 RK_LOGE("open path %s failed because %s.", yuv_out_path, strerror(errno));
107 return RK_FAILURE;
108 }
109
110 if (pstFrame) {
111 RK_LOGI("get frame:%p, size:%d, bBlk:%p", pstFrame, stMbPicCalResult.u32MBSize, dstBlk);
112 RK_MPI_SYS_MmzFlushCache(dstBlk, RK_TRUE);
113 fwrite(pstFrame, 1, stMbPicCalResult.u32MBSize, file);
114 fflush(file);
115 }
116 fclose(file);
117 file = NULL;
118
119 return RK_SUCCESS;
120 }
121
unit_test_tde_get_size(TEST_TDE_CTX_S * ctx,RK_U32 * u32SrcSize)122 RK_S32 unit_test_tde_get_size(TEST_TDE_CTX_S *ctx, RK_U32 *u32SrcSize) {
123 RK_S32 s32Ret = RK_SUCCESS;
124 PIC_BUF_ATTR_S stPicBufAttr;
125 MB_PIC_CAL_S stMbPicCalResult;
126
127 stPicBufAttr.u32Width = ctx->stSrcSurface.u32Width;
128 stPicBufAttr.u32Height = ctx->stSrcSurface.u32Height;
129 stPicBufAttr.enPixelFormat = (PIXEL_FORMAT_E)ctx->stSrcSurface.enColorFmt;
130 stPicBufAttr.enCompMode = (COMPRESS_MODE_E)ctx->s32SrcCompressMode;
131 s32Ret = RK_MPI_CAL_TDE_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
132 if (s32Ret != RK_SUCCESS) {
133 RK_LOGE("get picture buffer size failed. err 0x%x", s32Ret);
134 return s32Ret;
135 }
136 *u32SrcSize = stMbPicCalResult.u32MBSize;
137 return s32Ret;
138 }
139
test_tde_read_file(const char * path,void * pu8SrcData,RK_U32 u32ImgSize)140 RK_S32 test_tde_read_file(const char *path, void *pu8SrcData, RK_U32 u32ImgSize) {
141 FILE *pFile = RK_NULL;
142 RK_S32 s32Ret = RK_SUCCESS;
143 RK_U32 u32ReadSize = 0;
144
145 pFile = fopen(path, "rb+");
146 if (pFile == RK_NULL) {
147 RK_LOGE("open path %s failed because %s.", path, strerror(errno));
148 return RK_FAILURE;
149 }
150 if (pFile) {
151 u32ReadSize = fread(pu8SrcData, 1, u32ImgSize, pFile);
152 fflush(pFile);
153 fclose(pFile);
154 }
155 return s32Ret;
156 }
157
test_tde_fill_src(TEST_TDE_CTX_S * ctx,TDE_SURFACE_S * pstSrcSurface,TDE_RECT_S * pstSrcRect)158 RK_S32 test_tde_fill_src(
159 TEST_TDE_CTX_S *ctx, TDE_SURFACE_S *pstSrcSurface, TDE_RECT_S *pstSrcRect) {
160 pstSrcSurface->u32Width = ctx->stSrcSurface.u32Width;
161 pstSrcSurface->u32Height = ctx->stSrcSurface.u32Height;
162 pstSrcSurface->enColorFmt = ctx->stSrcSurface.enColorFmt;
163 pstSrcSurface->enComprocessMode = ctx->stSrcSurface.enComprocessMode;
164 pstSrcRect->s32Xpos = ctx->stSrcRect.s32X;
165 pstSrcRect->s32Ypos = ctx->stSrcRect.s32Y;
166 pstSrcRect->u32Width = ctx->stSrcRect.u32Width;
167 pstSrcRect->u32Height = ctx->stSrcRect.u32Height;
168 return RK_SUCCESS;
169 }
170
test_tde_fill_dst(TEST_TDE_CTX_S * ctx,TDE_SURFACE_S * pstDstSurface,TDE_RECT_S * pstDstRect)171 RK_S32 test_tde_fill_dst(
172 TEST_TDE_CTX_S *ctx, TDE_SURFACE_S *pstDstSurface, TDE_RECT_S *pstDstRect) {
173 pstDstSurface->u32Width = ctx->stDstSurface.u32Width;
174 pstDstSurface->u32Height = ctx->stDstSurface.u32Height;
175 pstDstSurface->enColorFmt = ctx->stDstSurface.enColorFmt;
176 pstDstSurface->enComprocessMode = ctx->stDstSurface.enComprocessMode;
177 pstDstRect->s32Xpos = ctx->stDstRect.s32X;
178 pstDstRect->s32Ypos = ctx->stDstRect.s32Y;
179 pstDstRect->u32Width = ctx->stDstRect.u32Width;
180 pstDstRect->u32Height = ctx->stDstRect.u32Height;
181 return RK_SUCCESS;
182 }
183
test_tde_quick_copy_resize_rotate_task(TEST_TDE_CTX_S * ctx,TDE_SURFACE_S * pstSrc,TDE_RECT_S * pstSrcRect,TDE_SURFACE_S * pstDst,TDE_RECT_S * pstDstRect)184 RK_S32 test_tde_quick_copy_resize_rotate_task(TEST_TDE_CTX_S *ctx,
185 TDE_SURFACE_S *pstSrc, TDE_RECT_S *pstSrcRect,
186 TDE_SURFACE_S *pstDst, TDE_RECT_S *pstDstRect) {
187 test_tde_fill_src(ctx, pstSrc, pstSrcRect);
188 test_tde_fill_dst(ctx, pstDst, pstDstRect);
189 return RK_SUCCESS;
190 }
191
test_tde_quick_fill_task(TEST_TDE_CTX_S * ctx,TDE_SURFACE_S * pstSrc,TDE_SURFACE_S * pstDst,TDE_RECT_S * pstDstRect)192 RK_S32 test_tde_quick_fill_task(TEST_TDE_CTX_S *ctx,
193 TDE_SURFACE_S *pstSrc, TDE_SURFACE_S *pstDst,
194 TDE_RECT_S *pstDstRect) {
195 test_tde_fill_dst(ctx, pstDst, pstDstRect);
196 memcpy(RK_MPI_MB_Handle2VirAddr(pstDst->pMbBlk),
197 RK_MPI_MB_Handle2VirAddr(pstSrc->pMbBlk),
198 RK_MPI_MB_GetSize(pstSrc->pMbBlk));
199 return RK_SUCCESS;
200 }
201
test_tde_bit_blit_task(TEST_TDE_CTX_S * ctx,TDE_SURFACE_S * pstSrc,TDE_RECT_S * pstSrcRect,TDE_SURFACE_S * pstDst,TDE_RECT_S * pstDstRect,TDE_OPT_S * stOpt,RK_S32 s32Operation)202 RK_S32 test_tde_bit_blit_task(TEST_TDE_CTX_S *ctx,
203 TDE_SURFACE_S *pstSrc, TDE_RECT_S *pstSrcRect,
204 TDE_SURFACE_S *pstDst, TDE_RECT_S *pstDstRect,
205 TDE_OPT_S *stOpt, RK_S32 s32Operation) {
206 if (s32Operation == TDE_OP_MIRROR) {
207 // test case : mirror and clip
208 stOpt->enMirror = (MIRROR_E)ctx->s32Mirror;
209 stOpt->stClipRect.s32Xpos = ctx->stSrcRect.s32X;
210 stOpt->stClipRect.s32Ypos = ctx->stSrcRect.s32Y;
211 stOpt->stClipRect.u32Width = ctx->stSrcRect.u32Width;
212 stOpt->stClipRect.u32Height = ctx->stSrcRect.u32Height;
213
214 test_tde_fill_src(ctx, pstSrc, pstSrcRect);
215 test_tde_fill_dst(ctx, pstDst, pstDstRect);
216 } else if (s32Operation == TDE_OP_COLOR_KEY) {
217 // test case : colorkey
218 test_tde_fill_src(ctx, pstSrc, pstSrcRect);
219 test_tde_fill_dst(ctx, pstDst, pstDstRect);
220 stOpt->unColorKeyValue = ctx->s32ColorKey;
221 stOpt->enColorKeyMode = TDE_COLORKEY_MODE_FOREGROUND;
222 }
223 return RK_SUCCESS;
224 }
225
test_tde_add_task(TEST_TDE_CTX_S * ctx,TDE_HANDLE hHandle,TDE_SURFACE_S * pstSrc,TDE_RECT_S * pstSrcRect,TDE_SURFACE_S * pstDst,TDE_RECT_S * pstDstRect)226 RK_S32 test_tde_add_task(TEST_TDE_CTX_S *ctx, TDE_HANDLE hHandle,
227 TDE_SURFACE_S *pstSrc, TDE_RECT_S *pstSrcRect,
228 TDE_SURFACE_S *pstDst, TDE_RECT_S *pstDstRect) {
229 RK_S32 s32Ret = RK_SUCCESS;
230 ROTATION_E enRotateAngle = (ROTATION_E)ctx->s32Rotation;
231 RK_U32 u32FillData = ctx->s32Color;
232 RK_S32 s32Operation = ctx->s32Operation;
233 RK_S32 s32SrcCompressMode = ctx->s32SrcCompressMode;
234 TDE_OPT_S stOpt;
235 memset(&stOpt, 0, sizeof(TDE_OPT_S));
236
237 switch (s32Operation) {
238 case TDE_OP_QUICK_COPY: {
239 s32Ret = test_tde_quick_copy_resize_rotate_task(ctx,
240 pstSrc, pstSrcRect, pstDst, pstDstRect);
241 s32Ret = RK_TDE_QuickCopy(hHandle,
242 pstSrc, pstSrcRect, pstDst, pstDstRect);
243 } break;
244 case TDE_OP_QUICK_RESIZE: {
245 s32Ret = test_tde_quick_copy_resize_rotate_task(ctx,
246 pstSrc, pstSrcRect, pstDst, pstDstRect);
247 s32Ret = RK_TDE_QuickResize(hHandle,
248 pstSrc, pstSrcRect, pstDst, pstDstRect);
249 } break;
250 case TDE_OP_QUICK_FILL: {
251 s32Ret = test_tde_quick_fill_task(ctx,
252 pstSrc, pstDst, pstDstRect);
253 s32Ret = RK_TDE_QuickFill(hHandle,
254 pstDst, pstDstRect, u32FillData);
255 } break;
256 case TDE_OP_ROTATION: {
257 s32Ret = test_tde_quick_copy_resize_rotate_task(ctx,
258 pstSrc, pstSrcRect, pstDst, pstDstRect);
259 s32Ret = RK_TDE_Rotate(hHandle,
260 pstSrc, pstSrcRect, pstDst, pstDstRect,
261 enRotateAngle);
262 } break;
263 case TDE_OP_COLOR_KEY:
264 case TDE_OP_MIRROR: {
265 s32Ret = test_tde_bit_blit_task(ctx,
266 pstSrc, pstSrcRect, pstDst, pstDstRect,
267 &stOpt, s32Operation);
268 s32Ret = RK_TDE_Bitblit(hHandle,
269 pstDst, pstDstRect, pstSrc, pstSrcRect,
270 pstDst, pstDstRect, &stOpt);
271 } break;
272 default: {
273 RK_LOGE("unknown operation type %d", ctx->s32Operation);
274 break;
275 }
276 }
277 if (s32Ret != RK_SUCCESS) {
278 RK_TDE_CancelJob(hHandle);
279 return RK_FAILURE;
280 }
281 return s32Ret;
282 }
283
test_tde_load_src_file(TEST_TDE_CTX_S * ctx,MB_BLK * pstSrcBlk)284 RK_S32 test_tde_load_src_file(TEST_TDE_CTX_S *ctx, MB_BLK *pstSrcBlk) {
285 RK_S32 s32Ret = RK_SUCCESS;
286 RK_U32 u32SrcSize = 0;
287 FILE *file = RK_NULL;
288 void *pSrcData = RK_NULL;
289 MB_BLK srcBlk;
290
291 s32Ret = unit_test_tde_get_size(ctx, &u32SrcSize);
292 if (s32Ret != RK_SUCCESS) {
293 return s32Ret;
294 }
295
296 s32Ret = RK_MPI_SYS_MmzAlloc(pstSrcBlk, RK_NULL, RK_NULL, u32SrcSize);
297 if (s32Ret != RK_SUCCESS) {
298 return s32Ret;
299 }
300
301 srcBlk = *pstSrcBlk;
302
303 pSrcData = RK_MPI_MB_Handle2VirAddr(srcBlk);
304 s32Ret = test_tde_read_file(ctx->srcFilePath, pSrcData, u32SrcSize);
305 if (s32Ret != RK_SUCCESS) {
306 return s32Ret;
307 }
308 RK_MPI_SYS_MmzFlushCache(srcBlk, RK_FALSE);
309
310 RK_U32 u32SrcVirWidth = ctx->u32SrcVirWidth;
311 PIXEL_FORMAT_E srcFmt = ctx->stSrcSurface.enColorFmt;
312 RK_U32 u32HorStride = RK_MPI_CAL_COMM_GetHorStride(u32SrcVirWidth, srcFmt);
313 RK_U32 u32VerStride = ctx->u32SrcVirHeight;
314 RK_S32 s32SrcCompressMode = ctx->s32SrcCompressMode;
315 if (s32SrcCompressMode != COMPRESS_AFBC_16x16) {
316 s32Ret = RK_MPI_MB_SetBufferStride(srcBlk, u32HorStride, u32VerStride);
317 }
318 return s32Ret;
319 }
320
test_tde_create_dstBlk(TEST_TDE_CTX_S * ctx,MB_BLK * pstDstBlk)321 RK_S32 test_tde_create_dstBlk(TEST_TDE_CTX_S *ctx, MB_BLK *pstDstBlk) {
322 RK_S32 s32Ret = RK_SUCCESS;
323 PIC_BUF_ATTR_S stPicBufAttr;
324 MB_PIC_CAL_S stMbPicCalResult;
325
326 stPicBufAttr.u32Width = ctx->stDstSurface.u32Width;
327 stPicBufAttr.u32Height = ctx->stDstSurface.u32Height;
328 stPicBufAttr.enPixelFormat = ctx->stDstSurface.enColorFmt;
329 stPicBufAttr.enCompMode = COMPRESS_MODE_E(ctx->s32DstCompressMode);
330 s32Ret = RK_MPI_CAL_TDE_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
331 if (s32Ret != RK_SUCCESS) {
332 return s32Ret;
333 }
334 s32Ret = RK_MPI_SYS_MmzAlloc(pstDstBlk, RK_NULL, RK_NULL, stMbPicCalResult.u32MBSize);
335
336 if (ctx->backgroundFile) {
337 void *pDstData = RK_MPI_MB_Handle2VirAddr(*pstDstBlk);
338 test_tde_read_file(ctx->backgroundFile, pDstData, stMbPicCalResult.u32MBSize);
339 RK_MPI_SYS_MmzFlushCache(*pstDstBlk, RK_FALSE);
340 }
341
342 return s32Ret;
343 }
344
test_tde_job(TEST_TDE_CTX_S * ctx)345 RK_S32 test_tde_job(TEST_TDE_CTX_S *ctx) {
346 RK_S32 s32Ret = RK_SUCCESS;
347 MB_BLK srcBlk = RK_NULL;
348 MB_BLK dstBlk = RK_NULL;
349 RK_U32 u32TaskIndex = 0;
350 TDE_HANDLE hHandle[TDE_MAX_JOB_NUM];
351 TDE_SURFACE_S pstSrc[TDE_MAX_TASK_NUM];
352 TDE_RECT_S pstSrcRect[TDE_MAX_TASK_NUM];
353 TDE_SURFACE_S pstDst[TDE_MAX_TASK_NUM];
354 TDE_RECT_S pstDstRect[TDE_MAX_TASK_NUM];
355
356 s32Ret = test_tde_load_src_file(ctx, &srcBlk);
357 if (s32Ret != RK_SUCCESS) {
358 goto __FAILED;
359 }
360
361 s32Ret = test_tde_create_dstBlk(ctx, &dstBlk);
362 if (s32Ret != RK_SUCCESS) {
363 goto __FAILED;
364 }
365
366 for (RK_S32 u32JobIdx = 0; u32JobIdx < ctx->s32JobNum; u32JobIdx++) {
367 hHandle[u32JobIdx] = RK_TDE_BeginJob();
368 if (RK_ERR_TDE_INVALID_HANDLE == hHandle[u32JobIdx]) {
369 RK_LOGE("start job fail");
370 goto __FAILED;
371 }
372 for (u32TaskIndex = 0; u32TaskIndex < ctx->s32TaskNum; u32TaskIndex++) {
373 pstSrc[u32TaskIndex].pMbBlk = srcBlk;
374 pstDst[u32TaskIndex].pMbBlk = dstBlk;
375 s32Ret = test_tde_add_task(ctx, hHandle[u32JobIdx],
376 &pstSrc[u32TaskIndex], &pstSrcRect[u32TaskIndex],
377 &pstDst[u32TaskIndex], &pstDstRect[u32TaskIndex]);
378 if (s32Ret != RK_SUCCESS) {
379 goto __FAILED;
380 }
381 }
382 s32Ret = RK_TDE_EndJob(hHandle[u32JobIdx], RK_FALSE, RK_TRUE, 10);
383 if (s32Ret != RK_SUCCESS) {
384 RK_TDE_CancelJob(hHandle[u32JobIdx]);
385 goto __FAILED;
386 }
387 RK_TDE_WaitForDone(hHandle[u32JobIdx]);
388 }
389
390 for (RK_S32 u32TaskIdx = 0; u32TaskIdx < ctx->s32TaskNum; u32TaskIdx++) {
391 s32Ret = test_tde_save_result(ctx, &(pstDst[u32TaskIdx]), u32TaskIdx);
392 if (s32Ret != RK_SUCCESS) {
393 goto __FAILED;
394 }
395 }
396
397 __FAILED:
398 if (dstBlk) {
399 RK_MPI_SYS_Free(dstBlk);
400 }
401
402 if (srcBlk) {
403 RK_MPI_SYS_Free(srcBlk);
404 }
405 return s32Ret;
406 }
407
unit_test_mpi_tde(TEST_TDE_CTX_S * ctx)408 RK_S32 unit_test_mpi_tde(TEST_TDE_CTX_S *ctx) {
409 RK_S32 s32Ret = RK_SUCCESS;
410
411 s32Ret = RK_TDE_Open();
412 if (s32Ret != RK_SUCCESS) {
413 return RK_FAILURE;
414 }
415 for (RK_S32 i = 0; i < ctx->s32LoopCount; i++) {
416 s32Ret = test_tde_job(ctx);
417 if (s32Ret != RK_SUCCESS) {
418 return s32Ret;
419 }
420 RK_LOGI("Running mpi tde test loop count %d.", i + 1);
421 }
422 RK_TDE_Close();
423 return s32Ret;
424 }
425
test_tde_set_default_parameter(TEST_TDE_CTX_S * ctx)426 RK_S32 test_tde_set_default_parameter(TEST_TDE_CTX_S *ctx) {
427 if (ctx->stSrcRect.u32Width == 0) {
428 ctx->stSrcRect.u32Width = ctx->stSrcSurface.u32Width;
429 }
430 if (ctx->stSrcRect.u32Height == 0) {
431 ctx->stSrcRect.u32Height = ctx->stSrcSurface.u32Height;
432 }
433 if (ctx->stDstRect.u32Width == 0) {
434 ctx->stDstRect.u32Width = ctx->stDstSurface.u32Width;
435 }
436 if (ctx->stDstRect.u32Height == 0) {
437 ctx->stDstRect.u32Height = ctx->stDstSurface.u32Height;
438 }
439 if (ctx->u32SrcVirWidth == 0) {
440 ctx->u32SrcVirWidth = ctx->stSrcSurface.u32Width;
441 }
442 if (ctx->u32SrcVirHeight == 0) {
443 ctx->u32SrcVirHeight = ctx->stSrcSurface.u32Height;
444 }
445 return RK_SUCCESS;
446 }
447
test_tde_set_proc_parameter(TEST_TDE_CTX_S * ctx,TEST_TDE_PROC_CTX_S * tdeTestCtx)448 RK_S32 test_tde_set_proc_parameter(TEST_TDE_CTX_S *ctx, TEST_TDE_PROC_CTX_S *tdeTestCtx) {
449 memset(tdeTestCtx, 0, sizeof(TEST_TDE_PROC_CTX_S));
450 tdeTestCtx->pstSrc.u32Width = ctx->stSrcSurface.u32Width;
451 tdeTestCtx->pstSrc.u32Height = ctx->stSrcSurface.u32Height;
452 tdeTestCtx->pstSrc.enColorFmt = ctx->stSrcSurface.enColorFmt;
453 tdeTestCtx->pstSrcRect.s32Xpos = ctx->stSrcRect.s32X;
454 tdeTestCtx->pstSrcRect.s32Ypos = ctx->stSrcRect.s32Y;
455 tdeTestCtx->pstSrcRect.u32Width = ctx->stSrcRect.u32Width;
456 tdeTestCtx->pstSrcRect.u32Height = ctx->stSrcRect.u32Height;
457 tdeTestCtx->pstDst.u32Width = ctx->stDstSurface.u32Width;
458 tdeTestCtx->pstDst.u32Height = ctx->stDstSurface.u32Height;
459 tdeTestCtx->pstDst.enColorFmt = ctx->stDstSurface.enColorFmt;
460 tdeTestCtx->pstDstRect.s32Xpos = ctx->stDstRect.s32X;
461 tdeTestCtx->pstDstRect.s32Ypos = ctx->stDstRect.s32Y;
462 tdeTestCtx->pstDstRect.u32Width = ctx->stDstRect.u32Width;
463 tdeTestCtx->pstDstRect.u32Height = ctx->stDstRect.u32Height;
464 tdeTestCtx->opType = ctx->s32Operation;
465 tdeTestCtx->s32ProcessTimes = ctx->s32ProcessTime;
466 tdeTestCtx->s32JobNum = ctx->s32JobNum;
467 tdeTestCtx->s32TaskNum = ctx->s32TaskNum;
468 return RK_SUCCESS;
469 }
470
471
472 static const char *const usages[] = {
473 "./rk_mpi_tde_test [-i SRC_PATH] [-w SRC_WIDTH] [-h SRC_HEIGHT] [-W DST_WIDTH] [-H DST_HEIGHT]...",
474 NULL,
475 };
476
mpi_tde_test_show_options(const TEST_TDE_CTX_S * ctx)477 static void mpi_tde_test_show_options(const TEST_TDE_CTX_S *ctx) {
478 RK_PRINT("cmd parse result: \n");
479 RK_PRINT("input file name : %s\n", ctx->srcFilePath);
480 RK_PRINT("output file name : %s\n", ctx->dstFilePath);
481 RK_PRINT("loop count : %d\n", ctx->s32LoopCount);
482 RK_PRINT("job number : %d\n", ctx->s32JobNum);
483 RK_PRINT("task number : %d\n", ctx->s32TaskNum);
484 RK_PRINT("input width : %d\n", ctx->stSrcSurface.u32Width);
485 RK_PRINT("input height : %d\n", ctx->stSrcSurface.u32Height);
486 RK_PRINT("input vir width : %d\n", ctx->u32SrcVirWidth);
487 RK_PRINT("input vir height : %d\n", ctx->u32SrcVirHeight);
488 RK_PRINT("src compress mode : %d\n", ctx->s32SrcCompressMode);
489 RK_PRINT("dst compress mode : %d\n", ctx->s32DstCompressMode);
490 RK_PRINT("input pixel format : %d\n", ctx->stSrcSurface.enColorFmt);
491 RK_PRINT("output width : %d\n", ctx->stDstSurface.u32Width);
492 RK_PRINT("output height : %d\n", ctx->stDstSurface.u32Height);
493 RK_PRINT("output pixel format : %d\n", ctx->stDstSurface.enColorFmt);
494 RK_PRINT("operation type : %d\n", ctx->s32Operation);
495 }
496
main(int argc,const char ** argv)497 int main(int argc, const char **argv) {
498 TEST_TDE_CTX_S ctx;
499 RK_S32 s32Ret = RK_SUCCESS;
500
501 memset(&ctx, 0, sizeof(TEST_TDE_CTX_S));
502
503 // set default params.
504 ctx.dstFilePath = RK_NULL;
505 ctx.s32LoopCount = 1;
506 ctx.s32JobNum = 1;
507 ctx.s32TaskNum = 1;
508 ctx.s32Operation = 0;
509 ctx.stSrcSurface.enColorFmt = RK_FMT_YUV420SP;
510 ctx.stSrcSurface.enComprocessMode = COMPRESS_MODE_NONE;
511 ctx.stDstSurface.enColorFmt = RK_FMT_YUV420SP;
512 ctx.stDstSurface.enComprocessMode = COMPRESS_MODE_NONE;
513 ctx.bPerformace = RK_FALSE;
514 ctx.s32ProcessTime = 800;
515
516 struct argparse_option options[] = {
517 OPT_HELP(),
518 OPT_GROUP("basic options:"),
519 OPT_STRING('i', "input", &(ctx.srcFilePath),
520 "input file name. e.g.(/userdata/1080p.nv12). <required>", NULL, 0, 0),
521 OPT_INTEGER('w', "src_width", &(ctx.stSrcSurface.u32Width),
522 "src width. e.g.(1920). <required>", NULL, 0, 0),
523 OPT_INTEGER('h', "src_height", &(ctx.stSrcSurface.u32Height),
524 "src height. e.g.(1080). <required>", NULL, 0, 0),
525 OPT_INTEGER('\0', "src_vir_width", &(ctx.u32SrcVirWidth),
526 "src vir width. e.g.(1920).", NULL, 0, 0),
527 OPT_INTEGER('\0', "src_vir_height", &(ctx.u32SrcVirHeight),
528 "src vir height. e.g.(1080).", NULL, 0, 0),
529 OPT_INTEGER('\0', "src_compress", &(ctx.s32SrcCompressMode),
530 "src compress mode. e.g.(1).", NULL, 0, 0),
531 OPT_INTEGER('W', "dst_width", &(ctx.stDstSurface.u32Width),
532 "dst width. e.g.(1920). <required>", NULL, 0, 0),
533 OPT_INTEGER('H', "dst_height", &(ctx.stDstSurface.u32Height),
534 "dst height. e.g.(1080). <required>", NULL, 0, 0),
535 OPT_INTEGER('\0', "dst_compress", &(ctx.s32DstCompressMode),
536 "dst compress mode. e.g.(1).", NULL, 0, 0),
537 OPT_STRING('o', "output", &(ctx.dstFilePath),
538 "output file path. e.g.(/userdata/tde/). default(NULL).", NULL, 0, 0),
539 OPT_STRING('\0', "background", &(ctx.backgroundFile),
540 "background file. e.g.(/userdata/tde/xxx.bin). default(NULL).", NULL, 0, 0),
541 OPT_INTEGER('n', "loop_count", &(ctx.s32LoopCount),
542 "loop running count. can be any count. default(1)", NULL, 0, 0),
543 OPT_INTEGER('j', "job_number", &(ctx.s32JobNum),
544 "the job number of vgs. default(1).", NULL, 0, 0),
545 OPT_INTEGER('t', "task_number", &(ctx.s32TaskNum),
546 "the task number of one job. default(1).", NULL, 0, 0),
547 OPT_INTEGER('f', "src_format", &(ctx.stSrcSurface.enColorFmt),
548 "src pixel format. default(0. 0 is NV12).", NULL, 0, 0),
549 OPT_INTEGER('F', "dst_format", &(ctx.stDstSurface.enColorFmt),
550 "dst pixel format. default(0. 0 is NV12).", NULL, 0, 0),
551 OPT_INTEGER('p', "operation", &(ctx.s32Operation),
552 "operation type. default(0).\n\t\t\t\t\t0: quick copy.\n\t\t\t\t\t1: quick resize."
553 "\n\t\t\t\t\t2: quick fill.\n\t\t\t\t\t3: rotation.\n\t\t\t\t\t4: mirror and flip."
554 "\n\t\t\t\t\t5: colorkey.", NULL, 0, 0),
555 OPT_INTEGER('\0', "src_rect_x", &(ctx.stSrcRect.s32X),
556 "src rect x. default(0).", NULL, 0, 0),
557 OPT_INTEGER('\0', "src_rect_y", &(ctx.stSrcRect.s32Y),
558 "src rect y. default(0).", NULL, 0, 0),
559 OPT_INTEGER('\0', "src_rect_w", &(ctx.stSrcRect.u32Width),
560 "src rect width. default(src_width).", NULL, 0, 0),
561 OPT_INTEGER('\0', "src_rect_h", &(ctx.stSrcRect.u32Height),
562 "src rect height. default(src_height).", NULL, 0, 0),
563 OPT_INTEGER('\0', "dst_rect_x", &(ctx.stDstRect.s32X),
564 "dst rect x. default(0).", NULL, 0, 0),
565 OPT_INTEGER('\0', "dst_rect_y", &(ctx.stDstRect.s32Y),
566 "dst rect y. default(0).", NULL, 0, 0),
567 OPT_INTEGER('\0', "dst_rect_w", &(ctx.stDstRect.u32Width),
568 "dst rect width. default(dst_width).", NULL, 0, 0),
569 OPT_INTEGER('\0', "dst_rect_h", &(ctx.stDstRect.u32Height),
570 "dst rect height. default(dst_height).", NULL, 0, 0),
571 OPT_INTEGER('\0', "performace", &(ctx.bPerformace),
572 "test performace mode. default(0).", NULL, 0, 0),
573 OPT_INTEGER('\0', "proc_time", &(ctx.s32ProcessTime),
574 "ProcessTime. default(800).", NULL, 0, 0),
575 OPT_INTEGER('\0', "colorkey", &(ctx.s32ColorKey),
576 "colorkey value. default(0).", NULL, 0, 0),
577 OPT_INTEGER('c', "fill color", &(ctx.s32Color),
578 "fill color. default(0).", NULL, 0, 0),
579 OPT_INTEGER('r', "rotation", &(ctx.s32Rotation),
580 "rotation angle. default(0). 0: 0. 1: 90. 2: 180. 3: 270", NULL, 0, 0),
581 OPT_INTEGER('m', "mirror", &(ctx.s32Mirror),
582 "mirror or flip. default(0). 0: none. 1: flip. 2: mirror. 3: both", NULL, 0, 0),
583 OPT_END(),
584 };
585
586 struct argparse argparse;
587 argparse_init(&argparse, options, usages, 0);
588 argparse_describe(&argparse, "\nselect a test case to run.",
589 "\nuse --help for details.");
590
591 argc = argparse_parse(&argparse, argc, argv);
592
593 test_tde_set_default_parameter(&ctx);
594 mpi_tde_test_show_options(&ctx);
595
596 if (ctx.stSrcSurface.u32Width <= 0
597 || ctx.stSrcSurface.u32Height <= 0
598 || ctx.stDstSurface.u32Width <= 0
599 || ctx.stDstSurface.u32Height <= 0) {
600 argparse_usage(&argparse);
601 goto __FAILED;
602 }
603
604 s32Ret = RK_MPI_SYS_Init();
605 if (s32Ret != RK_SUCCESS) {
606 goto __FAILED;
607 }
608
609 if (ctx.bPerformace) {
610 TEST_TDE_PROC_CTX_S tdeTestCtx;
611 test_tde_set_proc_parameter(&ctx, &tdeTestCtx);
612 s32Ret = TEST_TDE_MultiTest(&tdeTestCtx);
613 } else {
614 s32Ret = unit_test_mpi_tde(&ctx);
615 }
616
617 if (s32Ret != RK_SUCCESS) {
618 goto __FAILED;
619 }
620
621 s32Ret = RK_MPI_SYS_Exit();
622 if (s32Ret != RK_SUCCESS) {
623 goto __FAILED;
624 }
625
626 RK_LOGI("test running ok!");
627 return 0;
628 __FAILED:
629 RK_LOGI("test runnning failed!");
630 return -1;
631 }
632
633