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
24 #include "test_comm_sys.h"
25 #include "test_comm_utils.h"
26 #include "test_comm_imgproc.h"
27
28 #include "rk_common.h"
29 #include "rk_mpi_sys.h"
30 #include "rk_mpi_cal.h"
31 #include "rk_mpi_mb.h"
32 #include "rk_mpi_mmz.h"
33
TEST_SYS_CreateVideoFrame(const PIC_BUF_ATTR_S * pstBufAttr,VIDEO_FRAME_INFO_S * pstVideoFrame)34 RK_S32 TEST_SYS_CreateVideoFrame(const PIC_BUF_ATTR_S *pstBufAttr, VIDEO_FRAME_INFO_S *pstVideoFrame) {
35 MB_PIC_CAL_S stCalResult;
36
37 if (pstBufAttr == RK_NULL || pstVideoFrame == RK_NULL) {
38 return RK_FAILURE;
39 }
40
41 CHECK_RET(RK_MPI_CAL_VGS_GetPicBufferSize(pstBufAttr, &stCalResult),
42 "VGS get pic size");
43
44 CHECK_RET(RK_MPI_SYS_MmzAlloc_Cached(&(pstVideoFrame->stVFrame.pMbBlk),
45 RK_NULL, RK_NULL, stCalResult.u32MBSize),
46 "RK_MPI_SYS_MmzAlloc_Cached");
47
48 pstVideoFrame->stVFrame.u32Width = pstBufAttr->u32Width;
49 pstVideoFrame->stVFrame.u32Height = pstBufAttr->u32Height;
50 pstVideoFrame->stVFrame.u32VirWidth = stCalResult.u32VirWidth;
51 pstVideoFrame->stVFrame.u32VirHeight = stCalResult.u32VirHeight;
52 pstVideoFrame->stVFrame.enPixelFormat = pstBufAttr->enPixelFormat;
53 pstVideoFrame->stVFrame.enCompressMode = pstBufAttr->enCompMode;
54
55 return RK_SUCCESS;
56 }
57
TEST_SYS_AvsUnbindVenc(AVS_GRP AvsGrp,AVS_CHN AvsChn,VENC_CHN VencChn)58 RK_S32 TEST_SYS_AvsUnbindVenc(AVS_GRP AvsGrp, AVS_CHN AvsChn, VENC_CHN VencChn) {
59 RK_S32 s32Ret = RK_SUCCESS;
60 MPP_CHN_S stSrcChn;
61 MPP_CHN_S stDestChn;
62
63 stSrcChn.enModId = RK_ID_AVS;
64 stSrcChn.s32DevId = AvsGrp;
65 stSrcChn.s32ChnId = AvsChn;
66
67 stDestChn.enModId = RK_ID_VENC;
68 stDestChn.s32DevId = 0;
69 stDestChn.s32ChnId = VencChn;
70
71 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
72 if (s32Ret != RK_SUCCESS) {
73 RK_LOGE("failed with %#x!", s32Ret);
74 return RK_FAILURE;
75 }
76
77 return s32Ret;
78 }
79
80
TEST_SYS_AvsBindVpss(AVS_GRP AvsGrp,AVS_CHN AvsChn,VPSS_GRP VpssGrp)81 RK_S32 TEST_SYS_AvsBindVpss(AVS_GRP AvsGrp, AVS_CHN AvsChn, VPSS_GRP VpssGrp) {
82 RK_S32 s32Ret = RK_SUCCESS;
83 MPP_CHN_S stSrcChn;
84 MPP_CHN_S stDestChn;
85
86 stSrcChn.enModId = RK_ID_AVS;
87 stSrcChn.s32DevId = AvsGrp;
88 stSrcChn.s32ChnId = AvsChn;
89
90 stDestChn.enModId = RK_ID_VPSS;
91 stDestChn.s32DevId = VpssGrp;
92 stDestChn.s32ChnId = 0;
93
94 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
95 if (s32Ret != RK_SUCCESS) {
96 RK_LOGE("failed with %#x!", s32Ret);
97 return RK_FAILURE;
98 }
99
100 return s32Ret;
101 }
102
TEST_SYS_AvsUnbindVpss(AVS_GRP AvsGrp,AVS_CHN AvsChn,VPSS_GRP VpssGrp)103 RK_S32 TEST_SYS_AvsUnbindVpss(AVS_GRP AvsGrp, AVS_CHN AvsChn, VPSS_GRP VpssGrp) {
104 RK_S32 s32Ret = RK_SUCCESS;
105 MPP_CHN_S stSrcChn;
106 MPP_CHN_S stDestChn;
107
108 stSrcChn.enModId = RK_ID_AVS;
109 stSrcChn.s32DevId = AvsGrp;
110 stSrcChn.s32ChnId = AvsChn;
111
112 stDestChn.enModId = RK_ID_VPSS;
113 stDestChn.s32DevId = VpssGrp;
114 stDestChn.s32ChnId = 0;
115
116 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
117 if (s32Ret != RK_SUCCESS) {
118 RK_LOGE("failed with %#x!", s32Ret);
119 return RK_FAILURE;
120 }
121
122 return s32Ret;
123 }
124
TEST_SYS_AvsBindVo(AVS_GRP AvsGrp,AVS_CHN AvsChn,VO_DEV VoDev,VO_CHN VoChn)125 RK_S32 TEST_SYS_AvsBindVo(AVS_GRP AvsGrp, AVS_CHN AvsChn, VO_DEV VoDev, VO_CHN VoChn) {
126 RK_S32 s32Ret = RK_SUCCESS;
127 MPP_CHN_S stSrcChn;
128 MPP_CHN_S stDestChn;
129
130 stSrcChn.enModId = RK_ID_AVS;
131 stSrcChn.s32DevId = AvsGrp;
132 stSrcChn.s32ChnId = AvsChn;
133
134 stDestChn.enModId = RK_ID_VO;
135 stDestChn.s32DevId = VoDev;
136 stDestChn.s32ChnId = VoChn;
137
138 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
139 if (s32Ret != RK_SUCCESS) {
140 RK_LOGE("failed with %#x!", s32Ret);
141 return RK_FAILURE;
142 }
143
144 return s32Ret;
145 }
146
TEST_SYS_AvsUnbindVo(AVS_GRP AvsGrp,AVS_CHN AvsChn,VO_DEV VoDev,VO_CHN VoChn)147 RK_S32 TEST_SYS_AvsUnbindVo(AVS_GRP AvsGrp, AVS_CHN AvsChn, VO_DEV VoDev, VO_CHN VoChn) {
148 RK_S32 s32Ret = RK_SUCCESS;
149 MPP_CHN_S stSrcChn;
150 MPP_CHN_S stDestChn;
151
152 stSrcChn.enModId = RK_ID_AVS;
153 stSrcChn.s32DevId = AvsGrp;
154 stSrcChn.s32ChnId = AvsChn;
155
156 stDestChn.enModId = RK_ID_VO;
157 stDestChn.s32DevId = VoDev;
158 stDestChn.s32ChnId = VoChn;
159
160 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
161 if (s32Ret != RK_SUCCESS) {
162 RK_LOGE("failed with %#x!", s32Ret);
163 return RK_FAILURE;
164 }
165
166 return s32Ret;
167 }
168
TEST_SYS_ViBindAvs(VI_DEV ViDev,VI_CHN ViChn,AVS_GRP AvsGrp,AVS_PIPE AvsPipe)169 RK_S32 TEST_SYS_ViBindAvs(VI_DEV ViDev, VI_CHN ViChn, AVS_GRP AvsGrp, AVS_PIPE AvsPipe) {
170 RK_S32 s32Ret = RK_SUCCESS;
171 MPP_CHN_S stSrcChn;
172 MPP_CHN_S stDestChn;
173
174 stSrcChn.enModId = RK_ID_VI;
175 stSrcChn.s32DevId = ViDev;
176 stSrcChn.s32ChnId = ViChn;
177
178 stDestChn.enModId = RK_ID_AVS;
179 stDestChn.s32DevId = AvsGrp;
180 stDestChn.s32ChnId = AvsPipe;
181
182 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
183 if (s32Ret != RK_SUCCESS) {
184 RK_LOGE("failed with %#x!", s32Ret);
185 return RK_FAILURE;
186 }
187
188 return s32Ret;
189 }
190
TEST_SYS_ViUnbindAvs(VI_DEV ViDev,VI_CHN ViChn,AVS_GRP AvsGrp,AVS_PIPE AvsPipe)191 RK_S32 TEST_SYS_ViUnbindAvs(VI_DEV ViDev, VI_CHN ViChn, AVS_GRP AvsGrp, AVS_PIPE AvsPipe) {
192 RK_S32 s32Ret = RK_SUCCESS;
193 MPP_CHN_S stSrcChn;
194 MPP_CHN_S stDestChn;
195
196 stSrcChn.enModId = RK_ID_VI;
197 stSrcChn.s32DevId = ViDev;
198 stSrcChn.s32ChnId = ViChn;
199
200 stDestChn.enModId = RK_ID_AVS;
201 stDestChn.s32DevId = AvsGrp;
202 stDestChn.s32ChnId = AvsPipe;
203
204 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
205 if (s32Ret != RK_SUCCESS) {
206 RK_LOGE("failed with %#x!", s32Ret);
207 return RK_FAILURE;
208 }
209
210 return s32Ret;
211 }
212
TEST_SYS_VpssBindAvs(VPSS_GRP VpssGrp,VPSS_CHN VpssChn,AVS_GRP AvsGrp,AVS_PIPE AvsPipe)213 RK_S32 TEST_SYS_VpssBindAvs(VPSS_GRP VpssGrp, VPSS_CHN VpssChn, AVS_GRP AvsGrp, AVS_PIPE AvsPipe) {
214 RK_S32 s32Ret = RK_SUCCESS;
215 MPP_CHN_S stSrcChn;
216 MPP_CHN_S stDestChn;
217
218 stSrcChn.enModId = RK_ID_VPSS;
219 stSrcChn.s32DevId = VpssGrp;
220 stSrcChn.s32ChnId = VpssChn;
221
222 stDestChn.enModId = RK_ID_AVS;
223 stDestChn.s32DevId = AvsGrp;
224 stDestChn.s32ChnId = AvsPipe;
225
226 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
227 if (s32Ret != RK_SUCCESS) {
228 RK_LOGE("failed with %#x!", s32Ret);
229 return RK_FAILURE;
230 }
231
232 return s32Ret;
233 }
234
TEST_SYS_VpssUnbindAvs(VPSS_GRP VpssGrp,VPSS_CHN VpssChn,AVS_GRP AvsGrp,AVS_PIPE AvsPipe)235 RK_S32 TEST_SYS_VpssUnbindAvs(VPSS_GRP VpssGrp, VPSS_CHN VpssChn, AVS_GRP AvsGrp, AVS_PIPE AvsPipe) {
236 RK_S32 s32Ret = RK_SUCCESS;
237 MPP_CHN_S stSrcChn;
238 MPP_CHN_S stDestChn;
239
240 stSrcChn.enModId = RK_ID_VPSS;
241 stSrcChn.s32DevId = VpssGrp;
242 stSrcChn.s32ChnId = VpssChn;
243
244 stDestChn.enModId = RK_ID_AVS;
245 stDestChn.s32DevId = AvsGrp;
246 stDestChn.s32ChnId = AvsPipe;
247
248 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
249 if (s32Ret != RK_SUCCESS) {
250 RK_LOGE("failed with %#x!", s32Ret);
251 return RK_FAILURE;
252 }
253
254 return s32Ret;
255 }
256
TEST_SYS_VpssBindVo(VPSS_GRP VpssGrp,VPSS_CHN VpssChn,VO_DEV VoDev,VO_CHN VoChn)257 RK_S32 TEST_SYS_VpssBindVo(VPSS_GRP VpssGrp, VPSS_CHN VpssChn, VO_DEV VoDev, VO_CHN VoChn) {
258 RK_S32 s32Ret = RK_SUCCESS;
259 MPP_CHN_S stSrcChn;
260 MPP_CHN_S stDestChn;
261
262 stSrcChn.enModId = RK_ID_VPSS;
263 stSrcChn.s32DevId = VpssGrp;
264 stSrcChn.s32ChnId = VpssChn;
265
266 stDestChn.enModId = RK_ID_VO;
267 stDestChn.s32DevId = VoDev;
268 stDestChn.s32ChnId = VoChn;
269
270 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
271 if (s32Ret != RK_SUCCESS) {
272 RK_LOGE("failed with %#x!", s32Ret);
273 return RK_FAILURE;
274 }
275
276 return s32Ret;
277 }
278
TEST_SYS_VpssUnbindVo(VPSS_GRP VpssGrp,VPSS_CHN VpssChn,VO_DEV VoDev,VO_CHN VoChn)279 RK_S32 TEST_SYS_VpssUnbindVo(VPSS_GRP VpssGrp, VPSS_CHN VpssChn, VO_DEV VoDev, VO_CHN VoChn) {
280 RK_S32 s32Ret = RK_SUCCESS;
281 MPP_CHN_S stSrcChn;
282 MPP_CHN_S stDestChn;
283
284 stSrcChn.enModId = RK_ID_VPSS;
285 stSrcChn.s32DevId = VpssGrp;
286 stSrcChn.s32ChnId = VpssChn;
287
288 stDestChn.enModId = RK_ID_VO;
289 stDestChn.s32DevId = VoDev;
290 stDestChn.s32ChnId = VoChn;
291
292 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
293 if (s32Ret != RK_SUCCESS) {
294 RK_LOGE("failed with %#x!", s32Ret);
295 return RK_FAILURE;
296 }
297
298 return s32Ret;
299 }
300
TEST_SYS_VdecBindVpss(VDEC_CHN VdecChn,VPSS_GRP VpssGrp,VPSS_CHN VpssChn)301 RK_S32 TEST_SYS_VdecBindVpss(VDEC_CHN VdecChn, VPSS_GRP VpssGrp, VPSS_CHN VpssChn) {
302 RK_S32 s32Ret = RK_SUCCESS;
303 MPP_CHN_S stSrcChn;
304 MPP_CHN_S stDestChn;
305
306 stSrcChn.enModId = RK_ID_VDEC;
307 stSrcChn.s32DevId = 0;
308 stSrcChn.s32ChnId = VdecChn;
309
310 stDestChn.enModId = RK_ID_VPSS;
311 stDestChn.s32DevId = VpssGrp;
312 stDestChn.s32ChnId = VpssChn;
313
314 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
315 if (s32Ret != RK_SUCCESS) {
316 RK_LOGE("failed with %#x!", s32Ret);
317 return RK_FAILURE;
318 }
319
320 return s32Ret;
321 }
322
TEST_SYS_VdecUnbindVpss(VDEC_CHN VdecChn,VPSS_GRP VpssGrp,VPSS_CHN VpssChn)323 RK_S32 TEST_SYS_VdecUnbindVpss(VDEC_CHN VdecChn, VPSS_GRP VpssGrp, VPSS_CHN VpssChn) {
324 RK_S32 s32Ret = RK_SUCCESS;
325 MPP_CHN_S stSrcChn;
326 MPP_CHN_S stDestChn;
327
328 stSrcChn.enModId = RK_ID_VDEC;
329 stSrcChn.s32DevId = 0;
330 stSrcChn.s32ChnId = VdecChn;
331
332 stDestChn.enModId = RK_ID_VPSS;
333 stDestChn.s32DevId = VpssGrp;
334 stDestChn.s32ChnId = VpssChn;
335
336 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
337 if (s32Ret != RK_SUCCESS) {
338 RK_LOGE("failed with %#x!", s32Ret);
339 return RK_FAILURE;
340 }
341
342 return s32Ret;
343 }
344
TEST_SYS_VpssBindVenc(VPSS_GRP VpssGrp,VPSS_CHN VpssChn,VENC_CHN VencChn)345 RK_S32 TEST_SYS_VpssBindVenc(VPSS_GRP VpssGrp, VPSS_CHN VpssChn, VENC_CHN VencChn) {
346 RK_S32 s32Ret = RK_SUCCESS;
347 MPP_CHN_S stSrcChn;
348 MPP_CHN_S stDestChn;
349
350 stSrcChn.enModId = RK_ID_VPSS;
351 stSrcChn.s32DevId = VpssGrp;
352 stSrcChn.s32ChnId = VpssChn;
353
354 stDestChn.enModId = RK_ID_VENC;
355 stDestChn.s32DevId = 0;
356 stDestChn.s32ChnId = VencChn;
357
358 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
359 if (s32Ret != RK_SUCCESS) {
360 RK_LOGE("failed with %#x!", s32Ret);
361 return RK_FAILURE;
362 }
363
364 return s32Ret;
365 }
366
TEST_SYS_VpssUnbindVenc(VPSS_GRP VpssGrp,VPSS_CHN VpssChn,VENC_CHN VencChn)367 RK_S32 TEST_SYS_VpssUnbindVenc(VPSS_GRP VpssGrp, VPSS_CHN VpssChn, VENC_CHN VencChn) {
368 RK_S32 s32Ret = RK_SUCCESS;
369 MPP_CHN_S stSrcChn;
370 MPP_CHN_S stDestChn;
371
372 stSrcChn.enModId = RK_ID_VPSS;
373 stSrcChn.s32DevId = VpssGrp;
374 stSrcChn.s32ChnId = VpssChn;
375
376 stDestChn.enModId = RK_ID_VENC;
377 stDestChn.s32DevId = 0;
378 stDestChn.s32ChnId = VencChn;
379
380 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
381 if (s32Ret != RK_SUCCESS) {
382 RK_LOGE("failed with %#x!", s32Ret);
383 return RK_FAILURE;
384 }
385
386 return s32Ret;
387 }
388
TEST_SYS_VencBindVdec(VENC_CHN VencChn,VDEC_CHN VdecChn)389 RK_S32 TEST_SYS_VencBindVdec(VENC_CHN VencChn, VDEC_CHN VdecChn) {
390 RK_S32 s32Ret = RK_SUCCESS;
391 MPP_CHN_S stSrcChn;
392 MPP_CHN_S stDestChn;
393
394 stSrcChn.enModId = RK_ID_VENC;
395 stSrcChn.s32DevId = 0;
396 stSrcChn.s32ChnId = VencChn;
397
398 stDestChn.enModId = RK_ID_VDEC;
399 stDestChn.s32DevId = 0;
400 stDestChn.s32ChnId = VdecChn;
401
402 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
403 if (s32Ret != RK_SUCCESS) {
404 RK_LOGE("failed with %#x!", s32Ret);
405 return RK_FAILURE;
406 }
407
408 return s32Ret;
409 }
410
TEST_SYS_VencUnbindVdec(VENC_CHN VencChn,VDEC_CHN VdecChn)411 RK_S32 TEST_SYS_VencUnbindVdec(VENC_CHN VencChn, VDEC_CHN VdecChn) {
412 RK_S32 s32Ret = RK_SUCCESS;
413 MPP_CHN_S stSrcChn;
414 MPP_CHN_S stDestChn;
415
416 stSrcChn.enModId = RK_ID_VENC;
417 stSrcChn.s32DevId = 0;
418 stSrcChn.s32ChnId = VencChn;
419
420 stDestChn.enModId = RK_ID_VDEC;
421 stDestChn.s32DevId = 0;
422 stDestChn.s32ChnId = VdecChn;
423
424 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
425 if (s32Ret != RK_SUCCESS) {
426 RK_LOGE("failed with %#x!", s32Ret);
427 return RK_FAILURE;
428 }
429
430 return s32Ret;
431 }
432
TEST_SYS_VdecBindVo(VDEC_CHN VdecChn,VO_DEV VoDev,VO_CHN VoChn)433 RK_S32 TEST_SYS_VdecBindVo(VDEC_CHN VdecChn, VO_DEV VoDev, VO_CHN VoChn) {
434 RK_S32 s32Ret = RK_SUCCESS;
435 MPP_CHN_S stSrcChn;
436 MPP_CHN_S stDestChn;
437
438 stSrcChn.enModId = RK_ID_VDEC;
439 stSrcChn.s32DevId = 0;
440 stSrcChn.s32ChnId = VdecChn;
441
442 stDestChn.enModId = RK_ID_VO;
443 stDestChn.s32DevId = VoDev;
444 stDestChn.s32ChnId = VoChn;
445
446 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
447 if (s32Ret != RK_SUCCESS) {
448 RK_LOGE("failed with %#x!", s32Ret);
449 return RK_FAILURE;
450 }
451
452 return s32Ret;
453 }
454
TEST_SYS_VdecUnbindVo(VDEC_CHN VdecChn,VO_DEV VoDev,VO_CHN VoChn)455 RK_S32 TEST_SYS_VdecUnbindVo(VDEC_CHN VdecChn, VO_DEV VoDev, VO_CHN VoChn) {
456 RK_S32 s32Ret = RK_SUCCESS;
457 MPP_CHN_S stSrcChn;
458 MPP_CHN_S stDestChn;
459
460 stSrcChn.enModId = RK_ID_VDEC;
461 stSrcChn.s32DevId = 0;
462 stSrcChn.s32ChnId = VdecChn;
463
464 stDestChn.enModId = RK_ID_VO;
465 stDestChn.s32DevId = VoDev;
466 stDestChn.s32ChnId = VoChn;
467
468 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
469 if (s32Ret != RK_SUCCESS) {
470 RK_LOGE("failed with %#x!", s32Ret);
471 return RK_FAILURE;
472 }
473
474 return s32Ret;
475 }
476
TEST_SYS_FuzzyCompareFrameByFile(const char * pFileName,VIDEO_FRAME_INFO_S * pstVideoFrame,RK_DOUBLE dThreshold)477 RK_S32 TEST_SYS_FuzzyCompareFrameByFile(
478 const char *pFileName, VIDEO_FRAME_INFO_S *pstVideoFrame, RK_DOUBLE dThreshold) {
479 RK_S32 s32Ret = RK_SUCCESS;
480 RK_BOOL bDiff = RK_TRUE;
481 VIDEO_FRAME_INFO_S stCompareFrame;
482 PIC_BUF_ATTR_S stBufAttr;
483
484 memset(&stCompareFrame, 0, sizeof(VIDEO_FRAME_INFO_S));
485 memset(&stBufAttr, 0, sizeof(PIC_BUF_ATTR_S));
486
487 stBufAttr.u32Width = pstVideoFrame->stVFrame.u32VirWidth;
488 stBufAttr.u32Height = pstVideoFrame->stVFrame.u32VirHeight;
489 stBufAttr.enPixelFormat = pstVideoFrame->stVFrame.enPixelFormat;
490 stBufAttr.enCompMode = pstVideoFrame->stVFrame.enCompressMode;
491 s32Ret = TEST_SYS_CreateVideoFrame(&stBufAttr, &stCompareFrame);
492 if (s32Ret != RK_SUCCESS) {
493 return s32Ret;
494 }
495
496 s32Ret = TEST_COMM_FileReadOneFrame(pFileName, &stCompareFrame);
497 if (s32Ret != RK_SUCCESS) {
498 goto __FAILED;
499 }
500 RK_MPI_SYS_MmzFlushCache(stCompareFrame.stVFrame.pMbBlk, RK_FALSE);
501 RK_MPI_SYS_MmzFlushCache(pstVideoFrame->stVFrame.pMbBlk, RK_FALSE);
502 bDiff = TEST_COMM_CompareImageFuzzy(
503 (RK_U8 *)RK_MPI_MB_Handle2VirAddr(pstVideoFrame->stVFrame.pMbBlk),
504 (RK_U8 *)RK_MPI_MB_Handle2VirAddr(stCompareFrame.stVFrame.pMbBlk),
505 RK_MPI_CAL_COMM_GetHorStride(pstVideoFrame->stVFrame.u32VirWidth,
506 pstVideoFrame->stVFrame.enPixelFormat),
507 pstVideoFrame->stVFrame.u32Width,
508 pstVideoFrame->stVFrame.u32Height,
509 dThreshold);
510 if (bDiff) {
511 RK_LOGE("image compare has too large different.");
512 s32Ret = RK_FAILURE;
513 goto __FAILED;
514 }
515
516 __FAILED:
517 RK_MPI_MB_ReleaseMB(stCompareFrame.stVFrame.pMbBlk);
518 return s32Ret;
519 }
520
TEST_SYS_FuzzyCompareFrame(VIDEO_FRAME_INFO_S * pstVideoFrame,RK_DOUBLE dThreshold)521 RK_S32 TEST_SYS_FuzzyCompareFrame(VIDEO_FRAME_INFO_S *pstVideoFrame, RK_DOUBLE dThreshold) {
522 RK_S32 s32Ret = RK_SUCCESS;
523 RK_BOOL bDiff = RK_TRUE;
524 VIDEO_FRAME_INFO_S stCompareFrame;
525 PIC_BUF_ATTR_S stBufAttr;
526
527 memset(&stCompareFrame, 0, sizeof(VIDEO_FRAME_INFO_S));
528 memset(&stBufAttr, 0, sizeof(PIC_BUF_ATTR_S));
529
530 stBufAttr.u32Width = pstVideoFrame->stVFrame.u32VirWidth;
531 stBufAttr.u32Height = pstVideoFrame->stVFrame.u32VirHeight;
532 stBufAttr.enPixelFormat = pstVideoFrame->stVFrame.enPixelFormat;
533 stBufAttr.enCompMode = pstVideoFrame->stVFrame.enCompressMode;
534 s32Ret = TEST_SYS_CreateVideoFrame(&stBufAttr, &stCompareFrame);
535 if (s32Ret != RK_SUCCESS) {
536 return s32Ret;
537 }
538
539 s32Ret = TEST_COMM_FillImage((RK_U8 *)RK_MPI_MB_Handle2VirAddr(stCompareFrame.stVFrame.pMbBlk),
540 pstVideoFrame->stVFrame.u32Width, pstVideoFrame->stVFrame.u32Height,
541 RK_MPI_CAL_COMM_GetHorStride(pstVideoFrame->stVFrame.u32VirWidth,
542 pstVideoFrame->stVFrame.enPixelFormat),
543 pstVideoFrame->stVFrame.u32VirHeight,
544 pstVideoFrame->stVFrame.enPixelFormat, 1);
545 if (s32Ret != RK_SUCCESS) {
546 goto __FAILED;
547 }
548
549 RK_MPI_SYS_MmzFlushCache(stCompareFrame.stVFrame.pMbBlk, RK_FALSE);
550 RK_MPI_SYS_MmzFlushCache(pstVideoFrame->stVFrame.pMbBlk, RK_FALSE);
551 bDiff = TEST_COMM_CompareImageFuzzy(
552 (RK_U8 *)RK_MPI_MB_Handle2VirAddr(pstVideoFrame->stVFrame.pMbBlk),
553 (RK_U8 *)RK_MPI_MB_Handle2VirAddr(stCompareFrame.stVFrame.pMbBlk),
554 RK_MPI_CAL_COMM_GetHorStride(pstVideoFrame->stVFrame.u32VirWidth,
555 pstVideoFrame->stVFrame.enPixelFormat),
556 pstVideoFrame->stVFrame.u32Width,
557 pstVideoFrame->stVFrame.u32Height,
558 dThreshold);
559 if (bDiff) {
560 RK_LOGE("image compare has too large different.");
561 s32Ret = RK_FAILURE;
562 goto __FAILED;
563 }
564
565 __FAILED:
566 RK_MPI_MB_ReleaseMB(stCompareFrame.stVFrame.pMbBlk);
567 return s32Ret;
568 }
569
570 #ifdef __cplusplus
571 #if __cplusplus
572 }
573 #endif
574 #endif /* End of #ifdef __cplusplus */
575