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: 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 #include <random>
18
19 #ifdef __cplusplus
20 #if __cplusplus
21 extern "C" {
22 #endif
23 #endif /* End of #ifdef __cplusplus */
24
25 #include <string.h>
26 #include <stdlib.h>
27 #include <unistd.h>
28 #include <string>
29 #include <pthread.h>
30 #include <unistd.h>
31 #include <sys/stat.h>
32 #include <sys/types.h>
33
34 #include "rk_debug.h"
35
36 #include "test_common.h"
37 #include "test_comm_avs.h"
38 #include "test_comm_sys.h"
39 #include "test_comm_imgproc.h"
40 #include "test_comm_utils.h"
41
42 #include "rk_mpi_avs.h"
43 #include "rk_mpi_cal.h"
44 #include "rk_mpi_mb.h"
45 #include "rk_mpi_mmz.h"
46 #include "rk_mpi_sys.h"
47
TEST_AVS_Start(AVS_GRP AvsGrp,RK_U32 s32ChnNum,AVS_GRP_ATTR_S * pstAvsGrpAttr,AVS_CHN_ATTR_S * pstAvsChnAttr)48 RK_S32 TEST_AVS_Start(
49 AVS_GRP AvsGrp,
50 RK_U32 s32ChnNum,
51 AVS_GRP_ATTR_S *pstAvsGrpAttr,
52 AVS_CHN_ATTR_S *pstAvsChnAttr) {
53 AVS_CHN AvsChn = 0;
54 RK_S32 s32Ret = RK_SUCCESS;
55
56 s32Ret = RK_MPI_AVS_CreateGrp(AvsGrp, pstAvsGrpAttr);
57 if (s32Ret != RK_SUCCESS) {
58 RK_LOGE("avs [%d, %d] RK_MPI_AVS_CreateGrp failed: %#x!",
59 AvsGrp, 0, s32Ret);
60 return s32Ret;
61 }
62 RK_LOGV("avs [%d, %d] RK_MPI_AVS_CreateGrp already.", AvsGrp, 0);
63
64 for (AvsChn = 0; AvsChn < s32ChnNum; AvsChn++) {
65 s32Ret = RK_MPI_AVS_SetChnAttr(AvsGrp, AvsChn, &pstAvsChnAttr[AvsChn]);
66 if (s32Ret != RK_SUCCESS) {
67 RK_LOGE("avs [%d, %d]RK_MPI_AVS_SetChnAttr failed: %#x!",
68 AvsGrp, AvsChn, s32Ret);
69 return s32Ret;
70 }
71 RK_LOGV("avs [%d, %d] RK_MPI_AVS_SetChnAttr already.", AvsGrp, AvsChn);
72
73 s32Ret = RK_MPI_AVS_EnableChn(AvsGrp, AvsChn);
74 if (s32Ret != RK_SUCCESS) {
75 RK_LOGE("RK_MPI_AVS_EnableChn failed: %#x!", AvsChn, s32Ret);
76 return s32Ret;
77 }
78 RK_LOGV("avs [%d, %d] RK_MPI_AVS_EnableChn already.", AvsGrp, AvsChn);
79 }
80
81 s32Ret = RK_MPI_AVS_StartGrp(AvsGrp);
82 if (s32Ret != RK_SUCCESS) {
83 RK_LOGE("RK_MPI_AVS_StartGrp failed: %#x!", AvsGrp, s32Ret);
84 return s32Ret;
85 }
86 RK_LOGV("avs [%d, %d] RK_MPI_AVS_StartGrp already.", AvsGrp, 0);
87
88
89 s32Ret = RK_MPI_AVS_ResetGrp(AvsGrp);
90 if (s32Ret != RK_SUCCESS) {
91 RK_LOGE("RK_MPI_AVS_ResetGrp failed: %#x!", AvsGrp, s32Ret);
92 return s32Ret;
93 }
94 RK_LOGV("avs [%d, %d] RK_MPI_AVS_ResetGrp already.", AvsGrp, 0);
95
96 return s32Ret;
97 }
98
TEST_AVS_Stop(AVS_GRP AvsGrp,RK_U32 s32ChnNum)99 RK_S32 TEST_AVS_Stop(AVS_GRP AvsGrp, RK_U32 s32ChnNum) {
100 RK_S32 s32Ret = RK_SUCCESS;
101 AVS_CHN AvsChn = 0;
102 AVS_GRP_ATTR_S tmpGrpAttr;
103 MB_BLK tmpLutBlk;
104
105 for (AvsChn = 0; AvsChn < s32ChnNum; AvsChn++) {
106 s32Ret = RK_MPI_AVS_DisableChn(AvsGrp, AvsChn);
107 if (s32Ret != RK_SUCCESS) {
108 RK_LOGE("avs [%d, %d] RK_MPI_AVS_DisableChn failed: %#x!!",
109 AvsGrp, AvsChn, s32Ret);
110
111 goto __FAILED;
112 }
113 RK_LOGV("avs [%d, %d] RK_MPI_AVS_DisableChn already.", AvsGrp, AvsChn);
114 }
115
116 s32Ret = RK_MPI_AVS_GetGrpAttr(AvsGrp, &tmpGrpAttr);
117 if (s32Ret != RK_SUCCESS) {
118 RK_LOGE("avs [%d, %d] RK_MPI_AVS_GetGrpAttr failed: %#x!!",
119 AvsGrp, 0, s32Ret);
120 goto __FAILED;
121 }
122 RK_LOGV("avs [%d, %d] RK_MPI_AVS_GetGrpAttr already.", AvsGrp, 0);
123
124 for (RK_S32 AvsPipe = 0; AvsPipe < tmpGrpAttr.u32PipeNum; AvsPipe++) {
125 if (AVS_MODE_BLEND == tmpGrpAttr.enMode &&
126 AVS_PARAM_SOURCE_LUT == tmpGrpAttr.stInAttr.enParamSource &&
127 tmpGrpAttr.stInAttr.stLUT.pVirAddr[AvsPipe]) {
128 tmpLutBlk = RK_MPI_MB_VirAddr2Handle(tmpGrpAttr.stInAttr.stLUT.pVirAddr[AvsPipe]);
129 if (tmpLutBlk) {
130 s32Ret = RK_MPI_MB_ReleaseMB(tmpLutBlk);
131 if (s32Ret != RK_SUCCESS) {
132 RK_LOGE("avs [%d, %d] release Lut Blk %p virAddr %p failed: %#x!!",
133 AvsGrp, AvsPipe, tmpLutBlk,
134 tmpGrpAttr.stInAttr.stLUT.pVirAddr[AvsPipe], s32Ret);
135 }
136 RK_LOGV("avs [%d, %d] release Lut Blk %p virAddr %p already.",
137 AvsGrp, AvsPipe, tmpLutBlk,
138 tmpGrpAttr.stInAttr.stLUT.pVirAddr[AvsPipe]);
139 tmpGrpAttr.stInAttr.stLUT.pVirAddr[AvsPipe] = RK_NULL;
140 tmpLutBlk = RK_NULL;
141 }
142 }
143 }
144
145 s32Ret = RK_MPI_AVS_StopGrp(AvsGrp);
146 if (s32Ret != RK_SUCCESS) {
147 RK_LOGE("avs [%d, %d] RK_MPI_AVS_StopGrp failed: %#x!!",
148 AvsGrp, 0, s32Ret);
149 goto __FAILED;
150 }
151 RK_LOGV("avs [%d, %d] RK_MPI_AVS_StopGrp already.", AvsGrp, 0);
152
153 s32Ret = RK_MPI_AVS_DestroyGrp(AvsGrp);
154 if (s32Ret != RK_SUCCESS) {
155 RK_LOGE("avs [%d, %d] RK_MPI_AVS_DestroyGrp failed: %#x!!",
156 AvsGrp, 0, s32Ret);
157 goto __FAILED;
158 }
159 RK_LOGV("avs [%d, %d] RK_MPI_AVS_DestroyGrp already.", AvsGrp, 0);
160
161 __FAILED:
162
163 return s32Ret;
164 }
165
TEST_AVS_ModCreateFramePool(TEST_AVS_CTX_S * pstCtx)166 RK_S32 TEST_AVS_ModCreateFramePool(TEST_AVS_CTX_S *pstCtx) {
167 RK_S32 s32Ret = RK_SUCCESS;
168 MB_POOL_CONFIG_S stMbPoolCfg;
169 PIC_BUF_ATTR_S stPicBufAttr;
170 MB_PIC_CAL_S stMbPicCalResult;
171
172 stPicBufAttr.u32Width = pstCtx->u32SrcWidth;
173 stPicBufAttr.u32Height = pstCtx->u32SrcHeight;
174 stPicBufAttr.enCompMode = pstCtx->enSrcCompressMode;
175 stPicBufAttr.enPixelFormat = pstCtx->enSrcPixFormat;
176
177 s32Ret = RK_MPI_CAL_COMM_GetPicBufferSize(&stPicBufAttr, &stMbPicCalResult);
178 if (s32Ret != RK_SUCCESS) {
179 RK_LOGE("get picture buffer size failed: %#x", s32Ret);
180 return s32Ret;
181 }
182
183 for (RK_S32 AvsPipe = 0; AvsPipe < AVS_PIPE_NUM; AvsPipe++) {
184 memset(&stMbPoolCfg, 0, sizeof(MB_POOL_CONFIG_S));
185 stMbPoolCfg.u64MBSize = stMbPicCalResult.u32MBSize;
186 stMbPoolCfg.u32MBCnt = 2;
187 stMbPoolCfg.enAllocType = MB_ALLOC_TYPE_DMA;
188 stMbPoolCfg.bPreAlloc = RK_TRUE;
189 pstCtx->srcVFramePools[AvsPipe] = RK_MPI_MB_CreatePool(&stMbPoolCfg);
190 }
191
192 return s32Ret;
193 }
194
TEST_AVS_ModDestroyFramePool(TEST_AVS_CTX_S * pstCtx)195 RK_S32 TEST_AVS_ModDestroyFramePool(TEST_AVS_CTX_S *pstCtx) {
196 RK_S32 s32Ret = RK_SUCCESS;
197 for (RK_S32 AvsPipe = 0; AvsPipe < AVS_PIPE_NUM; AvsPipe++) {
198 if (MB_INVALID_POOLID != pstCtx->srcVFramePools[AvsPipe]) {
199 RK_MPI_MB_DestroyPool(pstCtx->srcVFramePools[AvsPipe]);
200 }
201 }
202
203 return s32Ret;
204 }
205
TEST_AVS_ModGetFrameFromPool(TEST_AVS_CTX_S * pstCtx,VIDEO_FRAME_INFO_S ** pstVideoFrames)206 RK_S32 TEST_AVS_ModGetFrameFromPool(TEST_AVS_CTX_S *pstCtx,
207 VIDEO_FRAME_INFO_S **pstVideoFrames) {
208 RK_S32 s32Ret = RK_SUCCESS;
209 MB_BLK blk = RK_NULL;
210 RK_U32 u32BufferSize = 0;
211 static RK_S32 s32LoopCnt = 0;
212 RK_CHAR cWritePath[MAX_FILE_PATH_LEN] = {0};
213
214 PIC_BUF_ATTR_S pstBufAttr;
215 MB_PIC_CAL_S stMbPicCalResult;
216
217 pstBufAttr.u32Width = pstCtx->u32SrcWidth;
218 pstBufAttr.u32Height = pstCtx->u32SrcHeight;
219 pstBufAttr.enCompMode = pstCtx->enSrcCompressMode;
220 pstBufAttr.enPixelFormat = pstCtx->enSrcPixFormat;
221
222 s32Ret = RK_MPI_CAL_COMM_GetPicBufferSize(&pstBufAttr, &stMbPicCalResult);
223 if (s32Ret != RK_SUCCESS) {
224 RK_LOGE("get picture buffer size failed: %#x", s32Ret);
225 return s32Ret;
226 }
227
228 u32BufferSize = stMbPicCalResult.u32MBSize;
229
230 for (RK_S32 AvsPipe = 0; AvsPipe < pstCtx->s32PipeNum; AvsPipe++) {
231 if (MB_INVALID_POOLID == pstCtx->srcVFramePools[AvsPipe]) {
232 RK_LOGE("avs [%d, %d] srcVFramePool unexist %d!",
233 pstCtx->s32GrpIndex, AvsPipe, pstCtx->srcVFramePools[AvsPipe]);
234 continue;
235 }
236 blk = RK_MPI_MB_GetMB(pstCtx->srcVFramePools[AvsPipe], u32BufferSize, RK_TRUE);
237 if (!blk) {
238 continue;
239 }
240
241 pstVideoFrames[AvsPipe]->stVFrame.pMbBlk = blk;
242 pstVideoFrames[AvsPipe]->stVFrame.u32Width = pstBufAttr.u32Width;
243 pstVideoFrames[AvsPipe]->stVFrame.u32Height = pstBufAttr.u32Height;
244 pstVideoFrames[AvsPipe]->stVFrame.u32VirWidth = stMbPicCalResult.u32VirWidth;
245 pstVideoFrames[AvsPipe]->stVFrame.u32VirHeight = stMbPicCalResult.u32VirHeight;
246 pstVideoFrames[AvsPipe]->stVFrame.enPixelFormat = pstBufAttr.enPixelFormat;
247 pstVideoFrames[AvsPipe]->stVFrame.enCompressMode = pstBufAttr.enCompMode;
248
249 if (RK_NULL != pstCtx->srcFilePath) {
250 if (COMPRESS_MODE_NONE == pstBufAttr.enCompMode) {
251 snprintf(cWritePath, sizeof(cWritePath),
252 "%simage_data/camera%d_%dx%d_nv12.yuv",
253 pstCtx->srcFilePath, AvsPipe,
254 pstBufAttr.u32Width, pstBufAttr.u32Height);
255 } else if (COMPRESS_AFBC_16x16 == pstBufAttr.enCompMode) {
256 snprintf(cWritePath, sizeof(cWritePath),
257 "%safbc_image_data/camera%d_%dx%d_nv12_afbc.yuv",
258 pstCtx->srcFilePath, AvsPipe,
259 pstBufAttr.u32Width, pstBufAttr.u32Height);
260 }
261
262 s32Ret = TEST_COMM_FileReadOneFrame(cWritePath, pstVideoFrames[AvsPipe]);
263 if (s32Ret != RK_SUCCESS) {
264 RK_LOGE("avs [%d, %d] pipe frame %p fread file: %s failed: %#x!",
265 pstCtx->s32GrpIndex, AvsPipe,
266 pstVideoFrames[AvsPipe], cWritePath, s32Ret);
267 }
268 RK_LOGV("avs [%d, %d] pipe frame %p fread file: %s already.",
269 pstCtx->s32GrpIndex, AvsPipe, pstVideoFrames[AvsPipe], cWritePath);
270 } else {
271 if (COMPRESS_MODE_NONE == pstBufAttr.enCompMode) {
272 s32Ret = TEST_COMM_FillImage(
273 (RK_U8 *)RK_MPI_MB_Handle2VirAddr(pstVideoFrames[AvsPipe]->stVFrame.pMbBlk),
274 pstBufAttr.u32Width,
275 pstBufAttr.u32Height,
276 RK_MPI_CAL_COMM_GetHorStride(pstVideoFrames[AvsPipe]->stVFrame.u32Width,
277 pstVideoFrames[AvsPipe]->stVFrame.enPixelFormat),
278 pstVideoFrames[AvsPipe]->stVFrame.u32VirHeight,
279 pstVideoFrames[AvsPipe]->stVFrame.enPixelFormat,
280 s32LoopCnt + AvsPipe);
281 if (s32Ret != RK_SUCCESS) {
282 RK_LOGE("fill COMPRESS_MODE_NONE data into pipe %d buf %p failed: %#x!",
283 AvsPipe, pstVideoFrames[AvsPipe], s32Ret);
284
285 }
286 s32LoopCnt++;
287 } else if (COMPRESS_AFBC_16x16 == pstBufAttr.enCompMode) {
288 RK_LOGE("unsupport fill COMPRESS_AFBC_16x16 data into buf generated by CPU!");
289 }
290 }
291 RK_MPI_SYS_MmzFlushCache(pstVideoFrames[AvsPipe]->stVFrame.pMbBlk, RK_FALSE);
292 }
293
294 return s32Ret;
295 }
296
TEST_AVS_ModReleaseFrameToPool(TEST_AVS_CTX_S * pstCtx,VIDEO_FRAME_INFO_S ** pstVideoFrames)297 RK_S32 TEST_AVS_ModReleaseFrameToPool(TEST_AVS_CTX_S *pstCtx,
298 VIDEO_FRAME_INFO_S **pstVideoFrames) {
299 RK_S32 s32Ret = RK_SUCCESS;
300 for (RK_S32 AvsPipe = 0; AvsPipe < AVS_PIPE_NUM; AvsPipe++) {
301 if (pstVideoFrames[AvsPipe] && pstVideoFrames[AvsPipe]->stVFrame.pMbBlk) {
302 s32Ret = RK_MPI_MB_ReleaseMB(pstVideoFrames[AvsPipe]->stVFrame.pMbBlk);
303 pstVideoFrames[AvsPipe]->stVFrame.pMbBlk = RK_NULL;
304 }
305 }
306
307 return s32Ret;
308 }
309
310
TEST_AVS_ModCreateFrame(TEST_AVS_CTX_S * pstCtx,VIDEO_FRAME_INFO_S ** pstVideoFrames)311 RK_S32 TEST_AVS_ModCreateFrame(TEST_AVS_CTX_S *pstCtx,
312 VIDEO_FRAME_INFO_S **pstVideoFrames) {
313 RK_S32 s32Ret = RK_SUCCESS;
314 AVS_PIPE AvsPipe = 0;
315 static RK_S32 s32LoopCnt = 0;
316 RK_CHAR cWritePath[MAX_FILE_PATH_LEN] = {0};
317 PIC_BUF_ATTR_S pstBufAttr;
318
319 pstBufAttr.u32Width = pstCtx->u32SrcWidth;
320 pstBufAttr.u32Height = pstCtx->u32SrcHeight;
321 pstBufAttr.enCompMode = pstCtx->enSrcCompressMode;
322 pstBufAttr.enPixelFormat = pstCtx->enSrcPixFormat;
323
324 for (; AvsPipe < pstCtx->s32PipeNum; AvsPipe++) {
325 s32Ret = TEST_SYS_CreateVideoFrame(&pstBufAttr, pstVideoFrames[AvsPipe]);
326 if (s32Ret != RK_SUCCESS) {
327 goto __FAILED;
328 }
329 RK_LOGV("avs [%d, %d] create pipe frame %p already.",
330 pstCtx->s32GrpIndex, AvsPipe, pstVideoFrames[AvsPipe]);
331
332 if (RK_NULL != pstCtx->srcFilePath) {
333 if (COMPRESS_MODE_NONE == pstBufAttr.enCompMode) {
334 snprintf(cWritePath, sizeof(cWritePath),
335 "%simage_data/camera%d_%dx%d_nv12.yuv",
336 pstCtx->srcFilePath, AvsPipe,
337 pstBufAttr.u32Width, pstBufAttr.u32Height);
338 } else if (COMPRESS_AFBC_16x16 == pstBufAttr.enCompMode) {
339 snprintf(cWritePath, sizeof(cWritePath),
340 "%safbc_image_data/camera%d_%dx%d_nv12_afbc.yuv",
341 pstCtx->srcFilePath, AvsPipe,
342 pstBufAttr.u32Width, pstBufAttr.u32Height);
343 }
344 RK_LOGV("avs [%d, %d] pipe frame %p fread file: %s.",
345 pstCtx->s32GrpIndex, AvsPipe, pstVideoFrames[AvsPipe], cWritePath);
346
347 s32Ret = TEST_COMM_FileReadOneFrame(cWritePath, pstVideoFrames[AvsPipe]);
348 if (s32Ret != RK_SUCCESS) {
349 goto __FAILED;
350 }
351 } else {
352 if (COMPRESS_MODE_NONE == pstBufAttr.enCompMode) {
353 s32Ret = TEST_COMM_FillImage(
354 (RK_U8 *)RK_MPI_MB_Handle2VirAddr(pstVideoFrames[AvsPipe]->stVFrame.pMbBlk),
355 pstBufAttr.u32Width,
356 pstBufAttr.u32Height,
357 RK_MPI_CAL_COMM_GetHorStride(pstVideoFrames[AvsPipe]->stVFrame.u32Width,
358 pstVideoFrames[AvsPipe]->stVFrame.enPixelFormat),
359 pstVideoFrames[AvsPipe]->stVFrame.u32VirHeight,
360 pstVideoFrames[AvsPipe]->stVFrame.enPixelFormat,
361 s32LoopCnt + AvsPipe);
362 if (s32Ret != RK_SUCCESS) {
363 RK_LOGE("fill COMPRESS_MODE_NONE data into pipe %d buf %p failed: %#x!",
364 AvsPipe, pstVideoFrames[AvsPipe], s32Ret);
365
366 goto __FAILED;
367 }
368 s32LoopCnt++;
369 } else if (COMPRESS_AFBC_16x16 == pstBufAttr.enCompMode) {
370 RK_LOGE("unsupport fill COMPRESS_AFBC_16x16 data into buf generated by CPU!");
371 }
372 }
373 RK_MPI_SYS_MmzFlushCache(pstVideoFrames[AvsPipe]->stVFrame.pMbBlk, RK_FALSE);
374 }
375
376 return s32Ret;
377
378 __FAILED:
379 for (; AvsPipe >= 0; AvsPipe--) {
380 RK_MPI_MB_ReleaseMB(pstVideoFrames[AvsPipe]->stVFrame.pMbBlk);
381 }
382
383 return s32Ret;
384 }
385
TEST_AVS_ModSendFrame(AVS_GRP AvsGrp,RK_U32 s32PipeNum,VIDEO_FRAME_INFO_S ** pstVideoFrames)386 RK_S32 TEST_AVS_ModSendFrame(AVS_GRP AvsGrp,
387 RK_U32 s32PipeNum,
388 VIDEO_FRAME_INFO_S **pstVideoFrames) {
389 RK_S32 s32Ret = RK_SUCCESS;
390 AVS_PIPE AvsPipe = 0;
391
392 for (; AvsPipe < s32PipeNum; AvsPipe++) {
393 s32Ret = RK_MPI_AVS_SendPipeFrame(AvsGrp, AvsPipe, pstVideoFrames[AvsPipe], -1);
394 if (s32Ret != RK_SUCCESS) {
395 RK_LOGE("avs [%d, %d] RK_MPI_AVS_SendPipeFrame %p failed: %#x!",
396 AvsGrp, AvsPipe, pstVideoFrames[AvsPipe]->stVFrame.pMbBlk, s32Ret);
397 }
398 }
399
400 return s32Ret;
401 }
402
TEST_AVS_ModGetChnFrame(AVS_GRP AvsGrp,RK_U32 s32ChnNum,VIDEO_FRAME_INFO_S ** pstVideoFrames)403 RK_S32 TEST_AVS_ModGetChnFrame(AVS_GRP AvsGrp,
404 RK_U32 s32ChnNum,
405 VIDEO_FRAME_INFO_S **pstVideoFrames) {
406 RK_S32 s32Ret = RK_SUCCESS;
407 AVS_CHN AvsChn = 0;
408
409 for (; AvsChn < s32ChnNum; AvsChn++) {
410 s32Ret = RK_MPI_AVS_GetChnFrame(AvsGrp, AvsChn,
411 pstVideoFrames[AvsChn], 40);
412 if (s32Ret != RK_SUCCESS) {
413 RK_LOGE("avs [%d, %d] RK_MPI_AVS_GetChnFrame failed: %#x!",
414 AvsGrp, AvsChn, s32Ret);
415 }
416 }
417
418 return s32Ret;
419 }
420
TEST_AVS_ModSaveChnFrame(AVS_GRP AvsGrp,RK_U32 s32ChnNum,const RK_CHAR * dstFilePath,VIDEO_FRAME_INFO_S ** pstVideoFrames)421 RK_S32 TEST_AVS_ModSaveChnFrame(AVS_GRP AvsGrp,
422 RK_U32 s32ChnNum,
423 const RK_CHAR *dstFilePath,
424 VIDEO_FRAME_INFO_S **pstVideoFrames) {
425 RK_S32 s32Ret = RK_SUCCESS;
426 AVS_CHN AvsChn = 0;
427
428 for (; AvsChn < s32ChnNum; AvsChn++) {
429 if (!pstVideoFrames[AvsChn]) {
430 continue;
431 }
432
433 RK_CHAR pWritePath[MAX_FILE_PATH_LEN] = {RK_NULL};
434 snprintf(pWritePath, sizeof(pWritePath), "%schn_out_%dx%d_%d_%d_%s.bin",
435 dstFilePath, pstVideoFrames[AvsChn]->stVFrame.u32Width,
436 pstVideoFrames[AvsChn]->stVFrame.u32Height, AvsGrp, AvsChn,
437 pstVideoFrames[AvsChn]->stVFrame.enCompressMode ? "afbc": "none");
438
439 s32Ret = TEST_COMM_FileWriteOneFrame(pWritePath, pstVideoFrames[AvsChn]);
440 if (s32Ret != RK_SUCCESS) {
441 RK_LOGE("avs [%d, %d] save chn frame %p to file %s failed: %#x!",
442 AvsGrp, AvsChn, pstVideoFrames[AvsChn],
443 pWritePath, s32Ret);
444 }
445 }
446
447 return s32Ret;
448 }
449
TEST_AVS_ModReleaseChnFrame(AVS_GRP AvsGrp,RK_U32 s32ChnNum,VIDEO_FRAME_INFO_S ** pstVideoFrames)450 RK_S32 TEST_AVS_ModReleaseChnFrame(AVS_GRP AvsGrp,
451 RK_U32 s32ChnNum,
452 VIDEO_FRAME_INFO_S **pstVideoFrames) {
453 RK_S32 s32Ret = RK_SUCCESS;
454 AVS_CHN AvsChn = 0;
455
456 for (; AvsChn < s32ChnNum; AvsChn++) {
457 s32Ret = RK_MPI_AVS_ReleaseChnFrame(AvsGrp, AvsChn,
458 pstVideoFrames[AvsChn]);
459 if (s32Ret != RK_SUCCESS) {
460 RK_LOGE("avs [%d, %d] RK_MPI_AVS_ReleaseChnFrame failed: %#x!",
461 AvsGrp, AvsChn, s32Ret);
462 }
463 }
464
465 return s32Ret;
466 }
467
TEST_AVS_UnitTest(TEST_AVS_CTX_S * pstCtx)468 RK_S32 TEST_AVS_UnitTest(TEST_AVS_CTX_S *pstCtx) {
469 RK_S32 s32Ret = RK_SUCCESS;
470
471 VIDEO_FRAME_INFO_S **pstPipeFrames;
472 VIDEO_FRAME_INFO_S **pstChnFrames;
473
474 pstPipeFrames = reinterpret_cast<VIDEO_FRAME_INFO_S **>(
475 malloc(sizeof(VIDEO_FRAME_INFO_S *) * AVS_PIPE_NUM));
476 pstChnFrames = reinterpret_cast<VIDEO_FRAME_INFO_S **>(
477 malloc(sizeof(VIDEO_FRAME_INFO_S *) * AVS_MAX_CHN_NUM));
478 for (RK_S32 i = 0; i < AVS_PIPE_NUM; i++) {
479 pstPipeFrames[i] = reinterpret_cast<VIDEO_FRAME_INFO_S *>(malloc(sizeof(VIDEO_FRAME_INFO_S)));
480 memset(pstPipeFrames[i], 0, sizeof(VIDEO_FRAME_INFO_S));
481 }
482 for (RK_S32 i = 0; i < AVS_MAX_CHN_NUM; i++) {
483 pstChnFrames[i] = reinterpret_cast<VIDEO_FRAME_INFO_S *>(malloc(sizeof(VIDEO_FRAME_INFO_S)));
484 memset(pstChnFrames[i], 0, sizeof(VIDEO_FRAME_INFO_S));
485 }
486
487 s32Ret = TEST_AVS_ModCreateFrame(pstCtx, pstPipeFrames);
488 if (s32Ret != RK_SUCCESS) {
489 goto __FREE_PIPE_FRAME;
490 }
491
492 s32Ret = TEST_AVS_ModInit(pstCtx);
493 if (s32Ret != RK_SUCCESS) {
494 goto __FREE_PIPE_FRAME;
495 }
496
497 for (RK_S32 i = 0; i < pstCtx->s32LoopCount; i++) {
498 s32Ret = TEST_AVS_ModSendFrame(pstCtx->s32GrpIndex, pstCtx->s32PipeNum, pstPipeFrames);
499 if (s32Ret != RK_SUCCESS) {
500 continue;
501 }
502
503 s32Ret = TEST_AVS_ModGetChnFrame(pstCtx->s32GrpIndex, pstCtx->s32ChnNum, pstChnFrames);
504 if (s32Ret != RK_SUCCESS) {
505 continue;
506 }
507
508 if (pstCtx->dstFilePath != RK_NULL) {
509 s32Ret = TEST_AVS_ModSaveChnFrame(pstCtx->s32GrpIndex, pstCtx->s32ChnNum,
510 pstCtx->dstFilePath, pstChnFrames);
511 if (s32Ret != RK_SUCCESS) {
512 goto __FAILED;
513 }
514 }
515
516 s32Ret = TEST_AVS_ModReleaseChnFrame(pstCtx->s32GrpIndex, pstCtx->s32ChnNum, pstChnFrames);
517 if (s32Ret != RK_SUCCESS) {
518 goto __FAILED;
519 }
520 usleep(40 * 1000);
521 }
522
523 __FAILED:
524 s32Ret = TEST_AVS_ModDeInit(pstCtx);
525
526 __FREE_PIPE_FRAME:
527 for (RK_S32 i = 0; i < AVS_PIPE_NUM; i++) {
528 if (i < pstCtx->s32PipeNum) {
529 if (pstPipeFrames[i] &&
530 pstPipeFrames[i]->stVFrame.pMbBlk) {
531 RK_MPI_MB_ReleaseMB(pstPipeFrames[i]->stVFrame.pMbBlk);
532 }
533 }
534 RK_SAFE_FREE(pstPipeFrames[i]);
535 }
536
537 for (RK_S32 i = 0; i < AVS_MAX_CHN_NUM; i++)
538 RK_SAFE_FREE(pstChnFrames[i]);
539
540 RK_SAFE_FREE(pstPipeFrames);
541 RK_SAFE_FREE(pstChnFrames);
542
543 return s32Ret;
544 }
545
TEST_AVS_InitAttr(TEST_AVS_CTX_S * pstCtx,AVS_GRP_ATTR_S * pstAvsGrpAttr,AVS_CHN_ATTR_S * pstAvsChnAttrs)546 RK_S32 TEST_AVS_InitAttr(TEST_AVS_CTX_S *pstCtx,
547 AVS_GRP_ATTR_S *pstAvsGrpAttr,
548 AVS_CHN_ATTR_S *pstAvsChnAttrs) {
549 RK_S32 s32Ret = RK_SUCCESS;
550
551 if (AVS_MODE_BLEND == pstCtx->enAvsWorkMode) {
552 if (AVS_PARAM_SOURCE_LUT == pstCtx->enParamSource) {
553 s32Ret = TEST_AVS_InitAttr_Blend_Lut(pstCtx, pstAvsGrpAttr, pstAvsChnAttrs);
554 } else if (AVS_PARAM_SOURCE_CALIB == pstCtx->enParamSource) {
555 s32Ret = TEST_AVS_InitAttr_Blend_Calib(pstCtx, pstAvsGrpAttr, pstAvsChnAttrs);
556 }
557 } else if (pstCtx->enAvsWorkMode > AVS_MODE_BLEND && pstCtx->enAvsWorkMode < AVS_MODE_BUTT) {
558 s32Ret = TEST_AVS_InitAttr_NoBlend(pstCtx, pstAvsGrpAttr, pstAvsChnAttrs);
559 }
560
561 if (RK_TRUE == pstCtx->bGrpExSize) {
562 pstAvsGrpAttr->stOutAttr.stSize.u32Width = pstCtx->u32GrpWidth;
563 pstAvsGrpAttr->stOutAttr.stSize.u32Height = pstCtx->u32GrpHeight;
564 }
565
566 pstAvsGrpAttr->stInAttr.stSize.u32Width = pstCtx->u32SrcWidth;
567 pstAvsGrpAttr->stInAttr.stSize.u32Height = pstCtx->u32SrcHeight;
568
569 return s32Ret;
570 }
571
TEST_AVS_InitAttr_Blend_Lut(TEST_AVS_CTX_S * pstCtx,AVS_GRP_ATTR_S * pstAvsGrpAttr,AVS_CHN_ATTR_S * pstAvsChnAttrs)572 RK_S32 TEST_AVS_InitAttr_Blend_Lut(TEST_AVS_CTX_S *pstCtx,
573 AVS_GRP_ATTR_S *pstAvsGrpAttr,
574 AVS_CHN_ATTR_S *pstAvsChnAttrs) {
575 RK_S32 s32Ret = RK_SUCCESS;
576 RK_VOID **pLUTVirAddr = RK_NULL;
577
578 if (!pstCtx->lutFilePath) {
579 return RK_ERR_NULL_PTR;
580 }
581
582 memset(pstAvsGrpAttr, 0, sizeof(AVS_GRP_ATTR_S));
583 memset(pstAvsChnAttrs, 0, sizeof(AVS_CHN_ATTR_S) * AVS_MAX_CHN_NUM);
584
585 s32Ret = TEST_AVS_MallocLutBuf(pstCtx, &pLUTVirAddr);
586 if (RK_SUCCESS != s32Ret) {
587 return s32Ret;
588 }
589
590 pstAvsGrpAttr->enMode = pstCtx->enAvsWorkMode;
591 pstAvsGrpAttr->u32PipeNum = pstCtx->s32PipeNum;
592 pstAvsGrpAttr->bSyncPipe = pstCtx->bFrameSync;
593
594 pstAvsGrpAttr->stInAttr.enParamSource = pstCtx->enParamSource;
595 pstAvsGrpAttr->stInAttr.stLUT.enAccuracy = pstCtx->enLutAccuracy;
596 pstAvsGrpAttr->stInAttr.stLUT.enFuseWidth = pstCtx->enLutFuseWidth;
597 pstAvsGrpAttr->stInAttr.stLUT.stLutStep.enStepX = pstCtx->stLutStep.enStepX;
598 pstAvsGrpAttr->stInAttr.stLUT.stLutStep.enStepY = pstCtx->stLutStep.enStepY;
599 for (RK_S32 i = 0; i < pstCtx->s32PipeNum; i++) {
600 pstAvsGrpAttr->stInAttr.stLUT.pVirAddr[i] = pLUTVirAddr[i];
601 }
602
603 pstAvsGrpAttr->stOutAttr.enPrjMode = pstCtx->enAvsProjMode;
604 pstAvsGrpAttr->stOutAttr.stCenter.s32X = pstCtx->stCenter.s32X;
605 pstAvsGrpAttr->stOutAttr.stCenter.s32Y = pstCtx->stCenter.s32Y;
606 pstAvsGrpAttr->stOutAttr.stFOV.u32FOVX = pstCtx->stFov.u32FOVX;
607 pstAvsGrpAttr->stOutAttr.stFOV.u32FOVY = pstCtx->stFov.u32FOVY;
608 pstAvsGrpAttr->stOutAttr.stORIRotation.s32Roll = pstCtx->stOriRotation.s32Roll;
609 pstAvsGrpAttr->stOutAttr.stORIRotation.s32Pitch = pstCtx->stOriRotation.s32Pitch;
610 pstAvsGrpAttr->stOutAttr.stORIRotation.s32Yaw = pstCtx->stOriRotation.s32Yaw;
611 pstAvsGrpAttr->stOutAttr.stRotation.s32Roll = pstCtx->stRotation.s32Roll;
612 pstAvsGrpAttr->stOutAttr.stRotation.s32Pitch = pstCtx->stRotation.s32Pitch;
613 pstAvsGrpAttr->stOutAttr.stRotation.s32Yaw = pstCtx->stRotation.s32Yaw;
614 pstAvsGrpAttr->stFrameRate.s32SrcFrameRate = pstCtx->s32SrcGrpRate;
615 pstAvsGrpAttr->stFrameRate.s32DstFrameRate = pstCtx->s32DstGrpRate;
616
617 for (RK_S32 i = 0; i < AVS_MAX_CHN_NUM; i++) {
618 if (0 == i) {
619 pstAvsChnAttrs[i].u32Width = pstCtx->u32DstWidth;
620 pstAvsChnAttrs[i].u32Height = pstCtx->u32DstHeight;
621 pstAvsChnAttrs[i].enCompressMode = pstCtx->enDstCompressMode;
622 } else {
623 pstAvsChnAttrs[i].u32Width = RK_ALIGN(pstCtx->u32DstWidth / 2, 16);
624 pstAvsChnAttrs[i].u32Height = RK_ALIGN(pstCtx->u32DstHeight / 2, 2);
625 pstAvsChnAttrs[i].enCompressMode = COMPRESS_MODE_NONE;
626 }
627 pstAvsChnAttrs[i].enDynamicRange = DYNAMIC_RANGE_SDR8;
628 pstAvsChnAttrs[i].u32Depth = pstCtx->u32ChnDepth;
629 pstAvsChnAttrs[i].stFrameRate.s32SrcFrameRate = pstCtx->s32SrcChnRate;
630 pstAvsChnAttrs[i].stFrameRate.s32DstFrameRate = pstCtx->s32DstChnRate;
631 pstAvsChnAttrs[i].u32FrameBufCnt = pstCtx->u32FrameBufCnt;
632 }
633
634 return s32Ret;
635 }
636
TEST_AVS_InitAttr_Blend_Calib(TEST_AVS_CTX_S * pstCtx,AVS_GRP_ATTR_S * pstAvsGrpAttr,AVS_CHN_ATTR_S * pstAvsChnAttrs)637 RK_S32 TEST_AVS_InitAttr_Blend_Calib(TEST_AVS_CTX_S *pstCtx,
638 AVS_GRP_ATTR_S *pstAvsGrpAttr,
639 AVS_CHN_ATTR_S *pstAvsChnAttrs) {
640 RK_S32 s32Ret = RK_SUCCESS;
641
642 memset(pstAvsGrpAttr, 0, sizeof(AVS_GRP_ATTR_S));
643 memset(pstAvsChnAttrs, 0, sizeof(AVS_CHN_ATTR_S) * AVS_MAX_CHN_NUM);
644
645 pstAvsGrpAttr->enMode = pstCtx->enAvsWorkMode;
646 pstAvsGrpAttr->u32PipeNum = pstCtx->s32PipeNum;
647 pstAvsGrpAttr->bSyncPipe = pstCtx->bFrameSync;
648
649 pstAvsGrpAttr->stInAttr.enParamSource = pstCtx->enParamSource;
650 if (pstCtx->calibFileName) {
651 pstAvsGrpAttr->stInAttr.stCalib.pCalibFilePath = pstCtx->calibFileName;
652 }
653 if (pstCtx->meshFilePath) {
654 pstAvsGrpAttr->stInAttr.stCalib.pMeshAlphaPath = pstCtx->meshFilePath;
655 }
656
657 pstAvsGrpAttr->stOutAttr.enPrjMode = pstCtx->enAvsProjMode;
658 pstAvsGrpAttr->stOutAttr.stCenter.s32X = pstCtx->stCenter.s32X;
659 pstAvsGrpAttr->stOutAttr.stCenter.s32Y = pstCtx->stCenter.s32Y;
660 pstAvsGrpAttr->stOutAttr.stFOV.u32FOVX = pstCtx->stFov.u32FOVX;
661 pstAvsGrpAttr->stOutAttr.stFOV.u32FOVY = pstCtx->stFov.u32FOVY;
662 pstAvsGrpAttr->stOutAttr.stORIRotation.s32Roll = pstCtx->stOriRotation.s32Roll;
663 pstAvsGrpAttr->stOutAttr.stORIRotation.s32Pitch = pstCtx->stOriRotation.s32Pitch;
664 pstAvsGrpAttr->stOutAttr.stORIRotation.s32Yaw = pstCtx->stOriRotation.s32Yaw;
665 pstAvsGrpAttr->stOutAttr.stRotation.s32Roll = pstCtx->stRotation.s32Roll;
666 pstAvsGrpAttr->stOutAttr.stRotation.s32Pitch = pstCtx->stRotation.s32Pitch;
667 pstAvsGrpAttr->stOutAttr.stRotation.s32Yaw = pstCtx->stRotation.s32Yaw;
668 pstAvsGrpAttr->stOutAttr.fDistance = pstCtx->fDistance;
669 pstAvsGrpAttr->stFrameRate.s32SrcFrameRate = pstCtx->s32SrcGrpRate;
670 pstAvsGrpAttr->stFrameRate.s32DstFrameRate = pstCtx->s32DstGrpRate;
671
672 for (RK_S32 i = 0; i < pstCtx->s32ChnNum; i++) {
673 if (0 == i) {
674 pstAvsChnAttrs[i].u32Width = pstCtx->u32DstWidth;
675 pstAvsChnAttrs[i].u32Height = pstCtx->u32DstHeight;
676 pstAvsChnAttrs[i].enCompressMode = pstCtx->enDstCompressMode;
677 } else {
678 pstAvsChnAttrs[i].u32Width = RK_ALIGN(pstCtx->u32DstWidth / 2, 16);
679 pstAvsChnAttrs[i].u32Height = RK_ALIGN(pstCtx->u32DstHeight / 2, 2);
680 pstAvsChnAttrs[i].enCompressMode = COMPRESS_MODE_NONE;
681 }
682 pstAvsChnAttrs[i].enCompressMode = pstCtx->enDstCompressMode;
683 pstAvsChnAttrs[i].enDynamicRange = DYNAMIC_RANGE_SDR8;
684 pstAvsChnAttrs[i].u32Depth = pstCtx->u32ChnDepth;
685 pstAvsChnAttrs[i].stFrameRate.s32SrcFrameRate = pstCtx->s32SrcChnRate;
686 pstAvsChnAttrs[i].stFrameRate.s32DstFrameRate = pstCtx->s32DstChnRate;
687 pstAvsChnAttrs[i].u32FrameBufCnt = pstCtx->u32FrameBufCnt;
688 }
689
690 return s32Ret;
691 }
692
TEST_AVS_InitAttr_NoBlend(TEST_AVS_CTX_S * pstCtx,AVS_GRP_ATTR_S * pstAvsGrpAttr,AVS_CHN_ATTR_S * pstAvsChnAttrs)693 RK_S32 TEST_AVS_InitAttr_NoBlend(TEST_AVS_CTX_S *pstCtx,
694 AVS_GRP_ATTR_S *pstAvsGrpAttr,
695 AVS_CHN_ATTR_S *pstAvsChnAttrs) {
696 RK_S32 s32Ret = RK_SUCCESS;
697
698 memset(pstAvsGrpAttr, 0, sizeof(AVS_GRP_ATTR_S));
699 memset(pstAvsChnAttrs, 0, sizeof(AVS_CHN_ATTR_S) * AVS_MAX_CHN_NUM);
700
701 pstAvsGrpAttr->enMode = pstCtx->enAvsWorkMode;
702 pstAvsGrpAttr->u32PipeNum = pstCtx->s32PipeNum;
703 pstAvsGrpAttr->bSyncPipe = pstCtx->bFrameSync;
704
705 pstAvsGrpAttr->stFrameRate.s32SrcFrameRate = pstCtx->s32SrcGrpRate;
706 pstAvsGrpAttr->stFrameRate.s32DstFrameRate = pstCtx->s32DstGrpRate;
707
708 for (RK_S32 i = 0; i < pstCtx->s32ChnNum; i++) {
709 if (0 == i) {
710 pstAvsChnAttrs[i].u32Width = pstCtx->u32DstWidth;
711 pstAvsChnAttrs[i].u32Height = pstCtx->u32DstHeight;
712 pstAvsChnAttrs[i].enCompressMode = pstCtx->enDstCompressMode;
713 } else {
714 pstAvsChnAttrs[i].u32Width = RK_ALIGN(pstCtx->u32DstWidth / 2, 16);
715 pstAvsChnAttrs[i].u32Height = RK_ALIGN(pstCtx->u32DstHeight / 2, 2);
716 pstAvsChnAttrs[i].enCompressMode = COMPRESS_MODE_NONE;
717 }
718 pstAvsChnAttrs[i].enDynamicRange = DYNAMIC_RANGE_SDR8;
719 pstAvsChnAttrs[i].u32Depth = pstCtx->u32ChnDepth;
720 pstAvsChnAttrs[i].stFrameRate.s32SrcFrameRate = pstCtx->s32SrcChnRate;
721 pstAvsChnAttrs[i].stFrameRate.s32DstFrameRate = pstCtx->s32DstChnRate;
722 pstAvsChnAttrs[i].u32FrameBufCnt = pstCtx->u32FrameBufCnt;
723 }
724
725 return s32Ret;
726 }
727
TEST_AVS_ModInit(TEST_AVS_CTX_S * pstCtx)728 RK_S32 TEST_AVS_ModInit(TEST_AVS_CTX_S *pstCtx) {
729 RK_S32 s32Ret = RK_SUCCESS;
730 MB_BLK srcBlk = MB_INVALID_HANDLE;
731 AVS_GRP_ATTR_S stAvsGrpAttr;
732 AVS_CHN_ATTR_S stAvsChnAttr[AVS_MAX_CHN_NUM];
733
734 s32Ret = TEST_AVS_InitAttr(pstCtx, &stAvsGrpAttr, stAvsChnAttr);
735 if (s32Ret != RK_SUCCESS) {
736 RK_LOGE("avs [%d, %d] TEST_AVS_InitAttr failed: %#x!",
737 pstCtx->s32GrpIndex, 0, s32Ret);
738 return s32Ret;
739 }
740
741 if (pstCtx->bGetFinalLut) {
742 s32Ret = TEST_AVS_GetFinalLut(pstCtx->s32GrpIndex, &stAvsGrpAttr);
743 if (s32Ret != RK_SUCCESS) {
744 RK_LOGE("avs [%d, %d] TEST_AVS_GetFinalLut failed: %#x!",
745 pstCtx->s32GrpIndex, 0, s32Ret);
746 goto __FAILED;
747 }
748 }
749
750 s32Ret = TEST_AVS_Start(pstCtx->s32GrpIndex, pstCtx->s32ChnNum,
751 &stAvsGrpAttr, stAvsChnAttr);
752 if (s32Ret != RK_SUCCESS) {
753 RK_LOGE("avs [%d, %d] TEST_AVS_Start failed: %#x!",
754 pstCtx->s32GrpIndex, 0, s32Ret);
755 goto __FAILED;
756 }
757
758 return RK_SUCCESS;
759
760 __FAILED:
761 return s32Ret;
762 }
763
TEST_AVS_ModDeInit(TEST_AVS_CTX_S * pstCtx)764 RK_S32 TEST_AVS_ModDeInit(TEST_AVS_CTX_S *pstCtx) {
765 RK_S32 s32Ret = RK_SUCCESS;
766
767 s32Ret = TEST_AVS_Stop(pstCtx->s32GrpIndex, pstCtx->s32ChnNum);
768
769 return s32Ret;
770 }
771
TEST_AVS_GetFileLen(const RK_CHAR * File)772 RK_U32 TEST_AVS_GetFileLen(const RK_CHAR* File) {
773 FILE* FILE;
774 RK_U32 u32FileLen;
775 RK_S32 s32Ret;
776
777 FILE = fopen(File, "rb");
778 if (NULL != FILE) {
779 s32Ret = fseek(FILE, 0L, SEEK_END);
780 if (0 != s32Ret) {
781 RK_LOGE("fseek err!");
782 fclose(FILE);
783 return 0;
784 }
785
786 u32FileLen = ftell(FILE);
787
788 s32Ret = fseek(FILE, 0L, SEEK_SET);
789 if (0 != s32Ret) {
790 RK_LOGE("fseek err!");
791 fclose(FILE);
792 return 0;
793 }
794
795 fclose(FILE);
796 } else {
797 RK_LOGE("open file %s fail!", File);
798 u32FileLen = 0;
799 }
800
801 return u32FileLen;
802 }
803
TEST_AVS_LoadFile(const RK_CHAR * File,RK_VOID * Addr,RK_U32 u32Size)804 RK_S32 TEST_AVS_LoadFile(const RK_CHAR* File, RK_VOID* Addr, RK_U32 u32Size) {
805 FILE* FILE;
806 RK_U32 u32ReadBytes;
807
808 FILE = fopen(File, "rb");
809 if (FILE != NULL) {
810 u32ReadBytes = fread(Addr, u32Size, 1, FILE);
811 fclose(FILE);
812 } else {
813 RK_LOGE("open file of %s failed!", File);
814 return RK_FAILURE;
815 }
816
817 return RK_SUCCESS;
818 }
819
TEST_AVS_MallocLutBuf(TEST_AVS_CTX_S * pstCtx,RK_VOID *** lutBufsVirAddr)820 RK_S32 TEST_AVS_MallocLutBuf(TEST_AVS_CTX_S *pstCtx, RK_VOID ***lutBufsVirAddr) {
821 RK_S32 s32Ret = RK_SUCCESS;
822 RK_U32 u32LUTSize = 0;
823 RK_CHAR pLUTPath[AVS_PIPE_NUM][MAX_FILE_PATH_LEN] = {RK_NULL};
824 MB_BLK pLUTBlk[AVS_PIPE_NUM] = {RK_NULL};
825 RK_VOID **pLUTVirAddr = reinterpret_cast<RK_VOID **>(
826 malloc(sizeof(RK_VOID*) * AVS_PIPE_NUM));
827
828 for (RK_S32 i = 0; i < pstCtx->s32PipeNum; i++) {
829 snprintf(pLUTPath[i], sizeof(pLUTPath[i]), "%s%s%d%s",
830 pstCtx->lutFilePath, "rk_ps_lut_", i, ".bin");
831
832 u32LUTSize = TEST_AVS_GetFileLen(pLUTPath[i]);
833 if (0 == u32LUTSize) {
834 RK_LOGE("avs [%d, %d] open lut file %s failed!",
835 pstCtx->s32GrpIndex, i, pLUTPath[i]);
836 s32Ret = RK_FAILURE;
837
838 goto __FREE_LUT;
839 }
840
841 u32LUTSize = RK_ALIGN_256(u32LUTSize);
842
843 s32Ret = RK_MPI_SYS_MmzAllocEx(&pLUTBlk[i], NULL, NULL,
844 u32LUTSize,
845 MB_REMAP_MODE_CACHED);
846 if (RK_SUCCESS != s32Ret) {
847 RK_LOGE("avs [%d, %d] alloc LUT buf failed with %#x!",
848 pstCtx->s32GrpIndex, i, s32Ret);
849 goto __FREE_LUT;
850 }
851 pLUTVirAddr[i] = RK_MPI_MMZ_Handle2VirAddr(pLUTBlk[i]);
852
853 RK_LOGV("avs [%d, %d] pipe lut buf size %d viraddr %p fread lut file: %s.",
854 pstCtx->s32GrpIndex, i, u32LUTSize, pLUTVirAddr[i], pLUTPath[i]);
855 s32Ret = TEST_AVS_LoadFile(pLUTPath[i], pLUTVirAddr[i], u32LUTSize);
856 if (RK_SUCCESS != s32Ret) {
857 goto __FREE_LUT;
858 }
859 }
860
861 *lutBufsVirAddr = pLUTVirAddr;
862
863 return s32Ret;
864
865 __FREE_LUT:
866
867 for (RK_S32 i = 0; i < AVS_PIPE_NUM; i++) {
868 RK_SAFE_FREE(pLUTVirAddr[i]);
869 }
870 RK_SAFE_FREE(pLUTVirAddr);
871
872 return s32Ret;
873 }
874
TEST_AVS_FreeLutBuf(AVS_GRP_ATTR_S * pstAvsGrpAttr)875 RK_S32 TEST_AVS_FreeLutBuf(AVS_GRP_ATTR_S *pstAvsGrpAttr) {
876 RK_S32 s32Ret = RK_SUCCESS;
877 MB_BLK pLUTBlk = RK_NULL;
878
879 for (RK_S32 i = 0; i < AVS_PIPE_NUM; i++) {
880 pLUTBlk = RK_MPI_MMZ_VirAddr2Handle(pstAvsGrpAttr->stInAttr.stLUT.pVirAddr[i]);
881 if (RK_NULL != pLUTBlk) {
882 s32Ret = RK_MPI_SYS_MmzFree(pLUTBlk);
883 if (RK_SUCCESS != s32Ret) {
884 RK_LOGE("pipe %d Lut buf RK_MPI_SYS_MmzFree failed: %#x!", i, s32Ret);
885 }
886 pLUTBlk = RK_NULL;
887 }
888 }
889
890 return s32Ret;
891 }
892
TEST_AVS_ComChnSetScale(TEST_AVS_CTX_S * pstCtx)893 RK_S32 TEST_AVS_ComChnSetScale(TEST_AVS_CTX_S *pstCtx) {
894 RK_S32 s32Ret = RK_SUCCESS;
895 AVS_CHN_ATTR_S tmpChnAttr;
896
897 for (RK_S32 AvsChn = 0; AvsChn < pstCtx->s32ChnNum; AvsChn++) {
898 s32Ret = RK_MPI_AVS_GetChnAttr(pstCtx->s32GrpIndex, AvsChn, &tmpChnAttr);
899 if (s32Ret != RK_SUCCESS) {
900 RK_LOGE("avs [%d, %d] RK_MPI_AVS_GetChnAttr failed: %#x!",
901 pstCtx->s32GrpIndex, AvsChn, s32Ret);
902 return s32Ret;
903 }
904
905 tmpChnAttr.u32Width = pstCtx->u32DstWidth;
906 tmpChnAttr.u32Height = pstCtx->u32DstHeight;
907 RK_LOGV("set new chn attr u32Width: %d, u32Height: %d.",
908 tmpChnAttr.u32Width, tmpChnAttr.u32Height);
909
910 s32Ret = RK_MPI_AVS_SetChnAttr(pstCtx->s32GrpIndex, AvsChn, &tmpChnAttr);
911 if (s32Ret != RK_SUCCESS) {
912 RK_LOGE("avs [%d, %d] RK_MPI_AVS_SetChnAttr failed: %#x!",
913 pstCtx->s32GrpIndex, AvsChn, s32Ret);
914 return s32Ret;
915 }
916 }
917
918 return s32Ret;
919 }
920
TEST_AVS_ComGrpChnSetScale(TEST_AVS_CTX_S * pstCtx)921 RK_S32 TEST_AVS_ComGrpChnSetScale(TEST_AVS_CTX_S *pstCtx) {
922 RK_S32 s32Ret = RK_SUCCESS;
923 AVS_GRP_ATTR_S tmpGrpAttr;
924 AVS_CHN_ATTR_S tmpChnAttr;
925
926 s32Ret = RK_MPI_AVS_GetGrpAttr(pstCtx->s32GrpIndex, &tmpGrpAttr);
927 if (s32Ret != RK_SUCCESS) {
928 RK_LOGE("avs [%d] RK_MPI_AVS_GetGrpAttr failed: %#x!",
929 pstCtx->s32GrpIndex, s32Ret);
930 return s32Ret;
931 }
932
933 tmpGrpAttr.stOutAttr.stCenter.s32X = pstCtx->stCenter.s32X;
934 tmpGrpAttr.stOutAttr.stCenter.s32Y = pstCtx->stCenter.s32Y;
935 RK_LOGV("set new grp attr centerX: %d, centerY: %d.",
936 tmpGrpAttr.stOutAttr.stCenter.s32X, tmpGrpAttr.stOutAttr.stCenter.s32Y);
937
938 s32Ret = RK_MPI_AVS_SetGrpAttr(pstCtx->s32GrpIndex, &tmpGrpAttr);
939 if (s32Ret != RK_SUCCESS) {
940 RK_LOGE("avs [%d] RK_MPI_AVS_SetGrpAttr failed: %#x!",
941 pstCtx->s32GrpIndex, s32Ret);
942 return s32Ret;
943 }
944
945 for (RK_S32 AvsChn = 0; AvsChn < pstCtx->s32ChnNum; AvsChn++) {
946 s32Ret = RK_MPI_AVS_GetChnAttr(pstCtx->s32GrpIndex, AvsChn, &tmpChnAttr);
947 if (s32Ret != RK_SUCCESS) {
948 RK_LOGE("avs [%d, %d] RK_MPI_AVS_GetChnAttr failed: %#x!",
949 pstCtx->s32GrpIndex, AvsChn, s32Ret);
950 return s32Ret;
951 }
952
953 tmpChnAttr.u32Width = pstCtx->u32DstWidth;
954 tmpChnAttr.u32Height = pstCtx->u32DstHeight;
955 RK_LOGV("set new chn attr u32Width: %d, u32Height: %d.",
956 tmpChnAttr.u32Width, tmpChnAttr.u32Height);
957
958 s32Ret = RK_MPI_AVS_SetChnAttr(pstCtx->s32GrpIndex, AvsChn, &tmpChnAttr);
959 if (s32Ret != RK_SUCCESS) {
960 RK_LOGE("avs [%d, %d] RK_MPI_AVS_SetChnAttr failed: %#x!",
961 pstCtx->s32GrpIndex, AvsChn, s32Ret);
962 return s32Ret;
963 }
964 }
965
966 return s32Ret;
967 }
968
TEST_AVS_GetFinalLut(AVS_GRP AvsGrp,AVS_GRP_ATTR_S * pstAvsGrpAttr)969 RK_S32 TEST_AVS_GetFinalLut(AVS_GRP AvsGrp, AVS_GRP_ATTR_S *pstAvsGrpAttr) {
970 RK_S32 s32Ret = RK_SUCCESS;
971
972 s32Ret = RK_MPI_AVS_CreateGrp(AvsGrp, pstAvsGrpAttr);
973 if (s32Ret != RK_SUCCESS) {
974 RK_LOGE("avs [%d, %d] RK_MPI_AVS_CreateGrp failed: %#x!",
975 AvsGrp, 0, s32Ret);
976 return s32Ret;
977 }
978 RK_LOGV("avs [%d, %d] RK_MPI_AVS_CreateGrp already.", AvsGrp, 0);
979
980 RK_U16 *u16LdchData[AVS_PIPE_NUM] = {RK_NULL};
981 AVS_FINAL_LUT_S pstFinalLut;
982
983 MB_EXT_CONFIG_S stMbExtConfig;
984 for (RK_S32 i = 0; i < pstAvsGrpAttr->u32PipeNum; i++) {
985 u16LdchData[i] = (RK_U16 *)(malloc(61896));
986
987 memset(&stMbExtConfig, 0, sizeof(MB_EXT_CONFIG_S));
988 stMbExtConfig.pOpaque = u16LdchData[i];
989 stMbExtConfig.pu8VirAddr = (RK_U8 *)u16LdchData[i];
990 stMbExtConfig.u64Size = 61896;
991
992 s32Ret = RK_MPI_SYS_CreateMB(&(pstFinalLut.pLdchBlk[i]), &stMbExtConfig);
993 if (RK_SUCCESS != s32Ret) {
994 RK_LOGE("avs [%d, %d] create ldch blk failed with %#x!",
995 AvsGrp, i, s32Ret);
996 }
997 }
998
999 s32Ret = RK_MPI_AVS_GetFinalLut(AvsGrp, &pstFinalLut);
1000 if (s32Ret != RK_SUCCESS) {
1001 RK_LOGE("avs [%d, %d] RK_MPI_AVS_GetFinalLut failed: %#x!",
1002 AvsGrp, 0, s32Ret);
1003 goto __FAILED;
1004 }
1005 RK_LOGV("avs [%d, %d] RK_MPI_AVS_GetFinalLut already.", AvsGrp, 0);
1006
1007 __FAILED:
1008 for (RK_S32 i = 0; i < pstAvsGrpAttr->u32PipeNum; i++) {
1009 RK_MPI_SYS_Free(pstFinalLut.pLdchBlk[i]);
1010 if (u16LdchData[i]) {
1011 free(u16LdchData[i]);
1012 }
1013 }
1014
1015 s32Ret = RK_MPI_AVS_DestroyGrp(AvsGrp);
1016 if (s32Ret != RK_SUCCESS) {
1017 RK_LOGE("avs [%d, %d] RK_MPI_AVS_DestroyGrp failed: %#x!!",
1018 AvsGrp, 0, s32Ret);
1019 }
1020 RK_LOGV("avs [%d, %d] RK_MPI_AVS_DestroyGrp already.", AvsGrp, 0);
1021
1022 return s32Ret;
1023 }
1024
1025
1026 #ifdef __cplusplus
1027 #if __cplusplus
1028 }
1029 #endif
1030 #endif /* End of #ifdef __cplusplus */
1031
1032