1 /*
2 * Copyright 2018 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 #include <cstdio>
19 #include <cerrno>
20 #include <cstring>
21 #include <cstdlib>
22 #include <unistd.h>
23 #include <pthread.h>
24 #include <sys/stat.h>
25 #include <sys/poll.h>
26 #include <sys/types.h>
27 #include "rk_debug.h"
28 #include "rk_mpi_vdec.h"
29 #include "rk_mpi_sys.h"
30 #include "rk_mpi_mb.h"
31 #include "rk_mpi_cal.h"
32 #include "rk_mpi_vo.h"
33 #include "rk_mpi_vi.h"
34 #include "rk_mpi_vpss.h"
35 #include "rk_mpi_venc.h"
36 #include "test_comm_argparse.h"
37 #include "test_comm_utils.h"
38
39 #define MAX_STREAM_CNT 8
40 #define MAX_TIME_OUT_MS 20
41
42 #ifndef VDEC_INT64_MIN
43 #define VDEC_INT64_MIN (-0x7fffffffffffffffLL-1)
44 #endif
45
46 #ifndef VDEC_INT64_MAX
47 #define VDEC_INT64_MAX INT64_C(9223372036854775807)
48 #endif
49
50 #define VDEC_CH_CNT 2
51 #define VO_CH_CNT 4
52 #define HDMI_W 1920
53 #define HDMI_H 1080
54 #define MIPI_W 1080
55 #define MIPI_H 1920
56
57 typedef struct _rkMpiVDECCtx {
58 const char *srcFileUri;
59 RK_U32 u32SrcWidth;
60 RK_U32 u32SrcHeight;
61 RK_U32 u32SrcWidth1;
62 RK_U32 u32SrcHeight1;
63 RK_S32 s32LoopCount;
64 const char *aEntityName;
65 PIXEL_FORMAT_E enPixelFormat;
66 RK_U32 u32ReadSize;
67 RK_CODEC_ID_E enCodecId;
68 RK_BOOL threadExit;
69 RK_U32 u32ChnIndex;
70 RK_S32 s32ChnFd;
71 } TEST_ALL_CTX_S;
72
check_options(const TEST_ALL_CTX_S * ctx)73 static RK_S32 check_options(const TEST_ALL_CTX_S *ctx) {
74 if (ctx->srcFileUri == RK_NULL) {
75 goto __FAILED;
76 }
77
78 if (ctx->enCodecId <= RK_VIDEO_ID_Unused ||
79 ctx->u32SrcWidth <= 0 ||
80 ctx->u32SrcHeight <= 0) {
81 goto __FAILED;
82 }
83
84 return RK_SUCCESS;
85
86 __FAILED:
87 return RK_FAILURE;
88 }
89
mpi_create_vdec(TEST_ALL_CTX_S * ctx,RK_S32 s32Ch,VIDEO_MODE_E enMode)90 RK_S32 mpi_create_vdec(TEST_ALL_CTX_S *ctx, RK_S32 s32Ch, VIDEO_MODE_E enMode) {
91 RK_S32 s32Ret = RK_SUCCESS;
92 VDEC_CHN_ATTR_S stAttr;
93 VDEC_CHN_PARAM_S stVdecParam;
94 MB_POOL_CONFIG_S stMbPoolCfg;
95 VDEC_PIC_BUF_ATTR_S stVdecPicBufAttr;
96 MB_PIC_CAL_S stMbPicCalResult;
97 VDEC_MOD_PARAM_S stModParam;
98
99 memset(&stAttr, 0, sizeof(VDEC_CHN_ATTR_S));
100 memset(&stVdecParam, 0, sizeof(VDEC_CHN_PARAM_S));
101 memset(&stModParam, 0, sizeof(VDEC_MOD_PARAM_S));
102
103 stAttr.enMode = enMode;
104 stAttr.enType = ctx->enCodecId;
105 stAttr.u32PicWidth = ctx->u32SrcWidth;
106 stAttr.u32PicHeight = ctx->u32SrcHeight;
107 stAttr.u32FrameBufCnt = 8;
108 stAttr.u32StreamBufCnt = MAX_STREAM_CNT;
109
110 s32Ret = RK_MPI_VDEC_CreateChn(ctx->u32ChnIndex, &stAttr);
111 if (s32Ret != RK_SUCCESS) {
112 RK_LOGE("create %d vdec failed! ", ctx->u32ChnIndex);
113 return s32Ret;
114 }
115
116 if (ctx->enCodecId == RK_VIDEO_ID_MJPEG) {
117 stVdecParam.stVdecPictureParam.enPixelFormat = RK_FMT_YUV420SP;
118 } else {
119 stVdecParam.stVdecVideoParam.enCompressMode = COMPRESS_MODE_NONE;
120 }
121
122 // it is only effective to disable MV when decoding sequence output
123 stVdecParam.stVdecVideoParam.enOutputOrder = VIDEO_OUTPUT_ORDER_DISP;
124
125 s32Ret = RK_MPI_VDEC_SetChnParam(ctx->u32ChnIndex, &stVdecParam);
126 if (s32Ret != RK_SUCCESS) {
127 RK_LOGE("set chn %d param failed %x! ", ctx->u32ChnIndex, s32Ret);
128 return s32Ret;
129 }
130
131 ctx->s32ChnFd = RK_MPI_VDEC_GetFd(ctx->u32ChnIndex);
132 if (ctx->s32ChnFd <= 0) {
133 RK_LOGE("get fd chn %d failed %d", ctx->u32ChnIndex, ctx->s32ChnFd);
134 return s32Ret;
135 }
136
137 s32Ret = RK_MPI_VDEC_StartRecvStream(ctx->u32ChnIndex);
138 if (s32Ret != RK_SUCCESS) {
139 RK_LOGE("start recv chn %d failed %x! ", ctx->u32ChnIndex, s32Ret);
140 return s32Ret;
141 }
142
143 return RK_SUCCESS;
144 }
145
mpi_destory_vdec(TEST_ALL_CTX_S * ctx,RK_S32 s32Ch)146 RK_S32 mpi_destory_vdec(TEST_ALL_CTX_S *ctx, RK_S32 s32Ch) {
147 RK_MPI_VDEC_StopRecvStream(s32Ch);
148
149 if (ctx->s32ChnFd > 0) {
150 RK_MPI_VDEC_CloseFd(s32Ch);
151 }
152
153 RK_MPI_VDEC_DestroyChn(s32Ch);
154
155 return RK_SUCCESS;
156 }
157
mpi_create_stream_mode(TEST_ALL_CTX_S * ctx,RK_S32 s32Ch)158 RK_S32 mpi_create_stream_mode(TEST_ALL_CTX_S *ctx, RK_S32 s32Ch) {
159 VIDEO_MODE_E enMode;
160
161 if (ctx->enCodecId == RK_VIDEO_ID_MJPEG || ctx->enCodecId == RK_VIDEO_ID_JPEG) {
162 ctx->u32ReadSize = ctx->u32SrcWidth * ctx->u32SrcHeight;
163 enMode = VIDEO_MODE_FRAME;
164 } else {
165 enMode = VIDEO_MODE_STREAM;
166 }
167
168 return mpi_create_vdec(ctx, s32Ch, enMode);
169 }
170
mpi_vdec_free(void * opaque)171 static RK_S32 mpi_vdec_free(void *opaque) {
172 if (opaque)
173 free(opaque);
174 return 0;
175 }
176
mpi_send_stream(void * pArgs)177 static void* mpi_send_stream(void *pArgs) {
178 TEST_ALL_CTX_S *ctx = reinterpret_cast<TEST_ALL_CTX_S *>(pArgs);
179 RK_S32 s32Size = 0;
180 RK_S32 s32Ret = 0;
181 RK_U8 *data = RK_NULL;
182 FILE *fp = RK_NULL;
183 MB_BLK buffer = RK_NULL;
184 MB_EXT_CONFIG_S pstMbExtConfig;
185 VDEC_CHN_STATUS_S staus;
186 VDEC_CHN_ATTR_S stAttr;
187 VDEC_CHN_PARAM_S stVdecParam;
188 VDEC_STREAM_S stStream;
189 RK_S32 s32PacketCount = 0;
190 RK_S32 s32ReachEOS = 0;
191
192 memset(&stStream, 0, sizeof(VDEC_STREAM_S));
193
194 fp = fopen(ctx->srcFileUri, "r");
195 if (fp == RK_NULL) {
196 RK_LOGE("open file %s failed", ctx->srcFileUri);
197 return RK_NULL;
198 }
199
200 while (!ctx->threadExit) {
201 data = reinterpret_cast<RK_U8 *>(calloc(ctx->u32ReadSize, sizeof(RK_U8)));
202 memset(data, 0, ctx->u32ReadSize);
203 s32Size = fread(data, 1, ctx->u32ReadSize, fp);
204 if (s32Size <= 0) {
205 s32ReachEOS = 1;
206 }
207
208 memset(&pstMbExtConfig, 0, sizeof(MB_EXT_CONFIG_S));
209 pstMbExtConfig.pFreeCB = mpi_vdec_free;
210 pstMbExtConfig.pOpaque = data;
211 pstMbExtConfig.pu8VirAddr = data;
212 pstMbExtConfig.u64Size = s32Size;
213
214 RK_MPI_SYS_CreateMB(&buffer, &pstMbExtConfig);
215
216 stStream.u64PTS = 0;
217 stStream.pMbBlk = buffer;
218 stStream.u32Len = s32Size;
219 stStream.bEndOfStream = s32ReachEOS ? RK_TRUE : RK_FALSE;
220 stStream.bEndOfFrame = s32ReachEOS ? RK_TRUE : RK_FALSE;
221 stStream.bBypassMbBlk = RK_TRUE;
222 __RETRY:
223 s32Ret = RK_MPI_VDEC_SendStream(ctx->u32ChnIndex, &stStream, MAX_TIME_OUT_MS);
224 if (s32Ret < 0) {
225 if (ctx->threadExit) {
226 mpi_vdec_free(data);
227 RK_MPI_MB_ReleaseMB(stStream.pMbBlk);
228 break;
229 }
230 usleep(1000llu);
231 goto __RETRY;
232 } else {
233 s32PacketCount++;
234 RK_MPI_MB_ReleaseMB(stStream.pMbBlk);
235 //RK_LOGI("send chn %d packet %d", ctx->u32ChnIndex, s32PacketCount);
236 }
237 if (s32ReachEOS) {
238 RK_LOGI("chn %d input reach EOS", ctx->u32ChnIndex);
239 break;
240 }
241 }
242
243 if (fp)
244 fclose(fp);
245
246 RK_LOGI("%s out\n", __FUNCTION__);
247 return RK_NULL;
248 }
249
create_vo(TEST_ALL_CTX_S * ctx)250 static RK_S32 create_vo(TEST_ALL_CTX_S *ctx) {
251 /* Enable VO */
252 VO_PUB_ATTR_S VoPubAttr;
253 VO_VIDEO_LAYER_ATTR_S stLayerAttr;
254 RK_S32 s32Ret = RK_SUCCESS;
255 VO_CHN_ATTR_S stChnAttr;
256
257 memset(&VoPubAttr, 0, sizeof(VO_PUB_ATTR_S));
258 memset(&stLayerAttr, 0, sizeof(VO_VIDEO_LAYER_ATTR_S));
259
260 stLayerAttr.enPixFormat = RK_FMT_RGB888;
261 stLayerAttr.stDispRect.s32X = 0;
262 stLayerAttr.stDispRect.s32Y = 0;
263 stLayerAttr.u32DispFrmRt = 30;
264 stLayerAttr.stDispRect.u32Width = HDMI_W;
265 stLayerAttr.stDispRect.u32Height = HDMI_H;
266 stLayerAttr.stImageSize.u32Width = HDMI_W;
267 stLayerAttr.stImageSize.u32Height = HDMI_H;
268
269 s32Ret = RK_MPI_VO_GetPubAttr(0, &VoPubAttr);
270 if (s32Ret != RK_SUCCESS) {
271 return s32Ret;
272 }
273
274 VoPubAttr.enIntfType = VO_INTF_HDMI;
275 VoPubAttr.enIntfSync = VO_OUTPUT_DEFAULT;
276
277 s32Ret = RK_MPI_VO_SetPubAttr(0, &VoPubAttr);
278 if (s32Ret != RK_SUCCESS) {
279 return s32Ret;
280 }
281 s32Ret = RK_MPI_VO_Enable(0);
282 if (s32Ret != RK_SUCCESS) {
283 return s32Ret;
284 }
285
286 s32Ret = RK_MPI_VO_GetPubAttr(3, &VoPubAttr);
287 if (s32Ret != RK_SUCCESS) {
288 return s32Ret;
289 }
290
291 VoPubAttr.enIntfType = VO_INTF_MIPI;
292 VoPubAttr.enIntfSync = VO_OUTPUT_DEFAULT;
293
294 s32Ret = RK_MPI_VO_SetPubAttr(3, &VoPubAttr);
295 if (s32Ret != RK_SUCCESS) {
296 return s32Ret;
297 }
298 s32Ret = RK_MPI_VO_Enable(3);
299 if (s32Ret != RK_SUCCESS) {
300 return s32Ret;
301 }
302
303 s32Ret = RK_MPI_VO_BindLayer(0, 0, VO_LAYER_MODE_VIDEO);
304 if (s32Ret != RK_SUCCESS) {
305 RK_LOGE("RK_MPI_VO_BindLayer failed,s32Ret:%x\n", s32Ret);
306 return RK_FAILURE;
307 }
308
309 s32Ret = RK_MPI_VO_BindLayer(1, 3, VO_LAYER_MODE_GRAPHIC);
310 if (s32Ret != RK_SUCCESS) {
311 RK_LOGE("RK_MPI_VO_BindLayer failed,s32Ret:%x\n", s32Ret);
312 return RK_FAILURE;
313 }
314
315 s32Ret = RK_MPI_VO_SetLayerAttr(0, &stLayerAttr);
316 if (s32Ret != RK_SUCCESS) {
317 RK_LOGE("RK_MPI_VO_SetLayerAttr failed,s32Ret:%x\n", s32Ret);
318 return RK_FAILURE;
319 }
320
321 RK_MPI_VO_SetLayerPriority(0, 7);
322
323 stLayerAttr.stDispRect.u32Width = MIPI_W;
324 stLayerAttr.stDispRect.u32Height = MIPI_H;
325 stLayerAttr.stImageSize.u32Width = MIPI_W;
326 stLayerAttr.stImageSize.u32Height = MIPI_H;
327 s32Ret = RK_MPI_VO_SetLayerAttr(1, &stLayerAttr);
328 if (s32Ret != RK_SUCCESS) {
329 RK_LOGE("RK_MPI_VO_SetLayerAttr failed,s32Ret:%x\n", s32Ret);
330 return RK_FAILURE;
331 }
332
333 RK_MPI_VO_SetLayerPriority(1, 7);
334 RK_MPI_VO_SetLayerSpliceMode(1, VO_SPLICE_MODE_RGA);
335
336 s32Ret = RK_MPI_VO_EnableLayer(0);
337 if (s32Ret != RK_SUCCESS) {
338 RK_LOGE("RK_MPI_VO_EnableLayer failed,s32Ret:%x\n", s32Ret);
339 return RK_FAILURE;
340 }
341
342 s32Ret = RK_MPI_VO_EnableLayer(1);
343 if (s32Ret != RK_SUCCESS) {
344 RK_LOGE("RK_MPI_VO_EnableLayer failed,s32Ret:%x\n", s32Ret);
345 return RK_FAILURE;
346 }
347
348 for (int i = 0; i < VO_CH_CNT; i++) {
349 stChnAttr.stRect.u32Width = HDMI_W / (VO_CH_CNT / 2);
350 stChnAttr.stRect.u32Height = HDMI_H / (VO_CH_CNT / 2);
351 stChnAttr.stRect.s32X = (i % (VO_CH_CNT / 2)) * stChnAttr.stRect.u32Width;
352 stChnAttr.stRect.s32Y = (i / (VO_CH_CNT / 2)) * stChnAttr.stRect.u32Height;
353 stChnAttr.u32Priority = i;
354 stChnAttr.u32FgAlpha = 128;
355 stChnAttr.u32BgAlpha = 0;
356
357 s32Ret = RK_MPI_VO_SetChnAttr(0, i, &stChnAttr);
358 if (s32Ret != RK_SUCCESS) {
359 RK_LOGE("set chn Attr failed,s32Ret:%x\n", s32Ret);
360 return RK_FAILURE;
361 }
362
363 stChnAttr.stRect.u32Width = MIPI_W / (VO_CH_CNT / 2);
364 stChnAttr.stRect.u32Height = MIPI_H / (VO_CH_CNT / 2);
365 stChnAttr.stRect.s32X = (i % (VO_CH_CNT / 2)) * stChnAttr.stRect.u32Width;
366 stChnAttr.stRect.s32Y = (i / (VO_CH_CNT / 2)) * stChnAttr.stRect.u32Height;
367 s32Ret = RK_MPI_VO_SetChnAttr(1, i, &stChnAttr);
368 if (s32Ret != RK_SUCCESS) {
369 RK_LOGE("set chn Attr failed,s32Ret:%x\n", s32Ret);
370 return RK_FAILURE;
371 }
372 }
373
374 return s32Ret;
375 }
376
destory_vo(void)377 static RK_S32 destory_vo(void) {
378
379 RK_S32 s32Ret = RK_SUCCESS;
380
381 s32Ret = RK_MPI_VO_DisableLayer(0);
382 if (s32Ret != RK_SUCCESS) {
383 RK_LOGE("RK_MPI_VO_DisableLayer failed,s32Ret:%x\n", s32Ret);
384 return RK_FAILURE;
385 }
386 s32Ret = RK_MPI_VO_DisableLayer(1);
387 if (s32Ret != RK_SUCCESS) {
388 RK_LOGE("RK_MPI_VO_DisableLayer failed,s32Ret:%x\n", s32Ret);
389 return RK_FAILURE;
390 }
391
392 s32Ret = RK_MPI_VO_UnBindLayer(0, 0);
393 if (s32Ret != RK_SUCCESS) {
394 RK_LOGE("RK_MPI_VO_UnBindLayer failed,s32Ret:%x\n", s32Ret);
395 return RK_FAILURE;
396 }
397
398 s32Ret = RK_MPI_VO_UnBindLayer(1, 3);
399 if (s32Ret != RK_SUCCESS) {
400 RK_LOGE("RK_MPI_VO_UnBindLayer failed,s32Ret:%x\n", s32Ret);
401 return RK_FAILURE;
402 }
403
404 s32Ret = RK_MPI_VO_Disable(0);
405 if (s32Ret != RK_SUCCESS) {
406 return s32Ret;
407 }
408 s32Ret = RK_MPI_VO_Disable(3);
409 if (s32Ret != RK_SUCCESS) {
410 return s32Ret;
411 }
412 return s32Ret;
413 }
414
create_vi(TEST_ALL_CTX_S * ctx)415 static RK_S32 create_vi(TEST_ALL_CTX_S *ctx) {
416 RK_S32 s32Ret = RK_FAILURE;
417 VI_DEV_ATTR_S stDevAttr;
418 VI_DEV_BIND_PIPE_S stBindPipe;
419 VI_CHN_ATTR_S stChnAttr;
420 // 0. get dev config status
421 s32Ret = RK_MPI_VI_GetDevAttr(0, &stDevAttr);
422 if (s32Ret == RK_ERR_VI_NOT_CONFIG) {
423 // 0-1.config dev
424 s32Ret = RK_MPI_VI_SetDevAttr(0, &stDevAttr);
425 if (s32Ret != RK_SUCCESS) {
426 RK_LOGE("RK_MPI_VI_SetDevAttr %x", s32Ret);
427 goto __FAILED;
428 }
429 } else {
430 RK_LOGE("RK_MPI_VI_SetDevAttr already");
431 }
432 // 1.get dev enable status
433 s32Ret = RK_MPI_VI_GetDevIsEnable(0);
434 if (s32Ret != RK_SUCCESS) {
435 // 1-2.enable dev
436 s32Ret = RK_MPI_VI_EnableDev(0);
437 if (s32Ret != RK_SUCCESS) {
438 RK_LOGE("RK_MPI_VI_EnableDev %x", s32Ret);
439 goto __FAILED;
440 }
441 // 1-3.bind dev/pipe
442 stBindPipe.u32Num = 0;
443 stBindPipe.PipeId[0] = 0;
444 s32Ret = RK_MPI_VI_SetDevBindPipe(0, &stBindPipe);
445 if (s32Ret != RK_SUCCESS) {
446 RK_LOGE("RK_MPI_VI_SetDevBindPipe %x", s32Ret);
447 goto __FAILED;
448 }
449 } else {
450 RK_LOGE("RK_MPI_VI_EnableDev already");
451 }
452 // 2.config channel
453 memset(&stChnAttr, 0, sizeof(VI_CHN_ATTR_S));
454 stChnAttr.stIspOpt.u32BufCount = 6;
455 stChnAttr.stIspOpt.enMemoryType = VI_V4L2_MEMORY_TYPE_MMAP;
456 stChnAttr.stIspOpt.enCaptureType = VI_V4L2_CAPTURE_TYPE_VIDEO_CAPTURE;
457 stChnAttr.u32Depth = 0;
458 stChnAttr.enPixelFormat = ctx->enPixelFormat;
459 stChnAttr.stFrameRate.s32SrcFrameRate = -1;
460 stChnAttr.stFrameRate.s32DstFrameRate = -1;
461 stChnAttr.stSize.u32Width = ctx->u32SrcWidth1;
462 stChnAttr.stSize.u32Height = ctx->u32SrcHeight1;
463 stChnAttr.stSize.u32Width = ctx->u32SrcWidth1;
464 stChnAttr.stSize.u32Height = ctx->u32SrcHeight1;
465 stChnAttr.enCompressMode = COMPRESS_MODE_NONE;
466 strcpy(stChnAttr.stIspOpt.aEntityName, ctx->aEntityName);
467 s32Ret = RK_MPI_VI_SetChnAttr(0, 0, &stChnAttr);
468 if (s32Ret != RK_SUCCESS) {
469 RK_LOGE("RK_MPI_VI_SetChnAttr %x", s32Ret);
470 goto __FAILED;
471 }
472 // 3.enable channel
473 s32Ret = RK_MPI_VI_EnableChn(0, 0);
474 if (s32Ret != RK_SUCCESS) {
475 RK_LOGE("RK_MPI_VI_EnableChn %x", s32Ret);
476 goto __FAILED;
477 }
478 __FAILED:
479 return s32Ret;
480 }
481
destroy_vi()482 static RK_S32 destroy_vi() {
483 RK_S32 s32Ret = RK_FAILURE;
484 s32Ret = RK_MPI_VI_DisableChn(0, 0);
485 RK_LOGE("RK_MPI_VI_DisableChn pipe=%d ret:%x", 0, s32Ret);
486
487 s32Ret = RK_MPI_VI_DisableDev(0);
488 RK_LOGE("RK_MPI_VI_DisableDev device=%d ret:%x", 0, s32Ret);
489 return s32Ret;
490 }
491
create_venc(TEST_ALL_CTX_S * ctx)492 static RK_S32 create_venc(TEST_ALL_CTX_S *ctx) {
493 VENC_RECV_PIC_PARAM_S stRecvParam;
494 VENC_CHN_ATTR_S stAttr;
495 memset(&stAttr, 0, sizeof(VENC_CHN_ATTR_S));
496 stAttr.stVencAttr.enType = RK_VIDEO_ID_AVC;
497 stAttr.stVencAttr.enPixelFormat = RK_FMT_YUV420SP;
498 stAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264CBR;
499 stAttr.stRcAttr.stH264Cbr.u32Gop = 60;
500 stAttr.stVencAttr.u32PicWidth = ctx->u32SrcWidth;
501 stAttr.stVencAttr.u32PicHeight = ctx->u32SrcHeight;
502 stAttr.stVencAttr.u32VirWidth = ctx->u32SrcWidth;
503 stAttr.stVencAttr.u32VirHeight = ctx->u32SrcHeight;
504 stAttr.stVencAttr.u32StreamBufCnt = 5;
505 stAttr.stVencAttr.u32BufSize = ctx->u32SrcWidth * ctx->u32SrcHeight * 3 / 2;
506 stRecvParam.s32RecvPicNum = -1;
507 RK_MPI_VENC_CreateChn(0, &stAttr);
508 RK_MPI_VENC_StartRecvFrame(0, &stRecvParam);
509 return RK_SUCCESS;
510 }
511
destory_venc(void)512 static RK_S32 destory_venc(void) {
513 VENC_RECV_PIC_PARAM_S stRecvParam;
514 VENC_CHN_ATTR_S stAttr;
515 RK_S32 s32Ret = RK_SUCCESS;
516 s32Ret = RK_MPI_VENC_StopRecvFrame(0);
517 if (s32Ret != RK_SUCCESS) {
518 return s32Ret;
519 }
520 RK_LOGE("destroy enc chn:%d", 0);
521 s32Ret = RK_MPI_VENC_DestroyChn(0);
522 if (s32Ret != RK_SUCCESS) {
523 RK_LOGE("RK_MPI_VDEC_DestroyChn fail %x", s32Ret);
524 }
525 return RK_SUCCESS;
526 }
527
528
529
create_vpss(RK_S32 s32Grp,RK_S32 s32OutChnNum,TEST_ALL_CTX_S * ctx)530 static RK_S32 create_vpss(RK_S32 s32Grp, RK_S32 s32OutChnNum, TEST_ALL_CTX_S *ctx) {
531 RK_S32 s32Ret = RK_SUCCESS;
532 VPSS_CHN VpssChn[VPSS_MAX_CHN_NUM] = { VPSS_CHN0, VPSS_CHN1, VPSS_CHN2, VPSS_CHN3 };
533 VPSS_GRP_ATTR_S stGrpVpssAttr;
534 VPSS_CHN_ATTR_S stVpssChnAttr;
535 /* vpss */
536 memset(&stGrpVpssAttr, 0, sizeof(VPSS_GRP_ATTR_S));
537 stGrpVpssAttr.u32MaxW = 4096;
538 stGrpVpssAttr.u32MaxH = 4096;
539 stGrpVpssAttr.enPixelFormat = RK_FMT_YUV420SP;
540 stGrpVpssAttr.stFrameRate.s32SrcFrameRate = -1;
541 stGrpVpssAttr.stFrameRate.s32DstFrameRate = -1;
542 stGrpVpssAttr.enCompressMode = COMPRESS_MODE_NONE;
543
544 s32Ret = RK_MPI_VPSS_CreateGrp(s32Grp, &stGrpVpssAttr);
545 if (s32Ret != RK_SUCCESS) {
546 return s32Ret;
547 }
548
549 for (RK_S32 i = 0; i < s32OutChnNum; i++) {
550 memset(&stVpssChnAttr, 0, sizeof(VPSS_CHN_ATTR_S));
551 stVpssChnAttr.enChnMode = VPSS_CHN_MODE_AUTO;
552 stVpssChnAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
553 stVpssChnAttr.enPixelFormat = RK_FMT_YUV420SP;
554 stVpssChnAttr.stFrameRate.s32SrcFrameRate = -1;
555 stVpssChnAttr.stFrameRate.s32DstFrameRate = -1;
556 stVpssChnAttr.u32Width = ctx->u32SrcWidth / (i + 1);
557 stVpssChnAttr.u32Height = ctx->u32SrcHeight / (i + 1);
558 stVpssChnAttr.enCompressMode = COMPRESS_MODE_NONE;
559 s32Ret = RK_MPI_VPSS_SetChnAttr(s32Grp, VpssChn[i], &stVpssChnAttr);
560 if (s32Ret != RK_SUCCESS) {
561 return s32Ret;
562 }
563 s32Ret = RK_MPI_VPSS_EnableChn(s32Grp, VpssChn[i]);
564 if (s32Ret != RK_SUCCESS) {
565 return s32Ret;
566 }
567 }
568
569 s32Ret = RK_MPI_VPSS_SetVProcDev(s32Grp, VIDEO_PROC_DEV_RGA);
570 if (s32Ret != RK_SUCCESS) {
571 return s32Ret;
572 }
573
574 s32Ret = RK_MPI_VPSS_StartGrp(s32Grp);
575 if (s32Ret != RK_SUCCESS) {
576 return s32Ret;
577 }
578
579 return RK_SUCCESS;
580 }
581
destory_vpss(RK_S32 s32Grp,RK_S32 s32OutChnNum)582 static RK_S32 destory_vpss(RK_S32 s32Grp, RK_S32 s32OutChnNum) {
583 RK_S32 s32Ret = RK_SUCCESS;
584 VPSS_CHN VpssChn[VPSS_MAX_CHN_NUM] = { VPSS_CHN0, VPSS_CHN1, VPSS_CHN2, VPSS_CHN3 };
585
586 s32Ret = RK_MPI_VPSS_StopGrp(s32Grp);
587 if (s32Ret != RK_SUCCESS) {
588 return s32Ret;
589 }
590
591 for (RK_S32 i = 0; i < s32OutChnNum; i++) {
592 s32Ret = RK_MPI_VPSS_DisableChn(s32Grp, VpssChn[i]);
593 if (s32Ret != RK_SUCCESS) {
594 return s32Ret;
595 }
596 }
597
598 s32Ret = RK_MPI_VPSS_DisableBackupFrame(s32Grp);
599 if (s32Ret != RK_SUCCESS) {
600 return s32Ret;
601 }
602
603 s32Ret = RK_MPI_VPSS_DestroyGrp(s32Grp);
604 if (s32Ret != RK_SUCCESS) {
605 return s32Ret;
606 }
607
608 return RK_SUCCESS;
609 }
610
unit_test_mpi_all(TEST_ALL_CTX_S * ctx)611 RK_S32 unit_test_mpi_all(TEST_ALL_CTX_S *ctx) {
612 MPP_CHN_S stSrcChn, stDestChn;
613 RK_S32 s32Ret = RK_FAILURE;
614 RK_U32 u32Ch = 0;
615 TEST_ALL_CTX_S vdecCtx[VDEC_CH_CNT];
616 pthread_t vdecThread[VDEC_CH_CNT];
617
618 for (u32Ch = 0; u32Ch < VDEC_CH_CNT; u32Ch++) {
619 ctx->u32ChnIndex = u32Ch;
620 memcpy(&(vdecCtx[u32Ch]), ctx, sizeof(TEST_ALL_CTX_S));
621
622 // Does not support JPEG stream framing, read the size of one picture at a time
623 // and send it to the decoder.
624 mpi_create_stream_mode(&vdecCtx[u32Ch], u32Ch);
625 if (u32Ch < VDEC_CH_CNT - 1)
626 pthread_create(&vdecThread[u32Ch], 0, mpi_send_stream, reinterpret_cast<void *>(&vdecCtx[u32Ch]));
627 }
628
629 //create vo layer 0, layer 1, chn 0 -- 3
630 s32Ret = create_vo(ctx);
631 if (s32Ret != RK_SUCCESS) {
632 RK_LOGE("create vo ch failed");
633 return -1;
634 }
635
636 //create vi 0, 0
637 s32Ret = create_vi(ctx);
638 if (s32Ret != RK_SUCCESS) {
639 RK_LOGE("create vi ch failed");
640 return -1;
641 }
642
643 //create vpss grp 0, chn 0 -- 1
644 s32Ret = create_vpss(0, 2, ctx);
645 if (s32Ret != RK_SUCCESS) {
646 RK_LOGE("create vpss ch failed");
647 return -1;
648 }
649
650 //create venc 0, 0
651 s32Ret = create_venc(ctx);
652 if (s32Ret != RK_SUCCESS) {
653 RK_LOGE("create venc ch failed");
654 return -1;
655 }
656
657 // bind vdec[0] to vo [0, 0] [1, 0]
658 // bind vdec[1] to vo [0, 1] [1, 1]
659 for (int i = 0; i < VDEC_CH_CNT; i++) {
660 stSrcChn.enModId = RK_ID_VDEC;
661 stSrcChn.s32DevId = 0;
662 stSrcChn.s32ChnId = i;
663 stDestChn.enModId = RK_ID_VO;
664 stDestChn.s32DevId = 0;
665 stDestChn.s32ChnId = i;
666 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
667 if (s32Ret != RK_SUCCESS) {
668 RK_LOGE("vi band vo fail:%x", s32Ret);
669 return -1;
670 }
671
672 stDestChn.enModId = RK_ID_VO;
673 stDestChn.s32DevId = 1;
674 stDestChn.s32ChnId = i;
675 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
676 if (s32Ret != RK_SUCCESS) {
677 RK_LOGE("vi band vo fail:%x", s32Ret);
678 return -1;
679 }
680
681 // enable vo
682 s32Ret = RK_MPI_VO_EnableChn(0, i);
683 if (s32Ret != RK_SUCCESS) {
684 RK_LOGE("Enalbe vo chn failed, s32Ret = %d\n", s32Ret);
685 return -1;
686 }
687 s32Ret = RK_MPI_VO_EnableChn(1, i);
688 if (s32Ret != RK_SUCCESS) {
689 RK_LOGE("Enalbe vo chn failed, s32Ret = %d\n", s32Ret);
690 return -1;
691 }
692 }
693
694 //bind vi[0] to vo [0, 2] [1, 2]
695 stSrcChn.enModId = RK_ID_VI;
696 stSrcChn.s32DevId = 0;
697 stSrcChn.s32ChnId = 0;
698 stDestChn.enModId = RK_ID_VO;
699 stDestChn.s32DevId = 0;
700 stDestChn.s32ChnId = VDEC_CH_CNT;
701 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
702 if (s32Ret != RK_SUCCESS) {
703 RK_LOGE("vi band vo fail:%x", s32Ret);
704 return -1;
705 }
706
707 stDestChn.enModId = RK_ID_VO;
708 stDestChn.s32DevId = 1;
709 stDestChn.s32ChnId = VDEC_CH_CNT;
710 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
711 if (s32Ret != RK_SUCCESS) {
712 RK_LOGE("vi band vo fail:%x", s32Ret);
713 return -1;
714 }
715
716 //bind vi [0, 0] to vpss grp 0
717 stDestChn.enModId = RK_ID_VPSS;
718 stDestChn.s32DevId = 0;
719 stDestChn.s32ChnId = 0;
720 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
721 if (s32Ret != RK_SUCCESS) {
722 RK_LOGE("vi band vpss fail:%x", s32Ret);
723 return -1;
724 }
725
726 //bind vpss ch 0 to venc 0
727 stSrcChn.enModId = RK_ID_VPSS;
728 stSrcChn.s32DevId = 0;
729 stSrcChn.s32ChnId = 0;
730 stDestChn.enModId = RK_ID_VENC;
731 stDestChn.s32DevId = 0;
732 stDestChn.s32ChnId = 0;
733 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
734 if (s32Ret != RK_SUCCESS) {
735 RK_LOGE("vpss ch 0 band venc fail:%x", s32Ret);
736 return -1;
737 }
738
739 //bind venc 0 to vdec 1
740 stSrcChn.enModId = RK_ID_VENC;
741 stSrcChn.s32DevId = 0;
742 stSrcChn.s32ChnId = 0;
743 stDestChn.enModId = RK_ID_VDEC;
744 stDestChn.s32DevId = 0;
745 stDestChn.s32ChnId = VDEC_CH_CNT - 1;
746 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
747 if (s32Ret != RK_SUCCESS) {
748 RK_LOGE("vpss ch 0 band venc fail:%x", s32Ret);
749 return -1;
750 }
751
752 //bind vpss ch 1 to vo [0, 3] [1, 3]
753 stSrcChn.enModId = RK_ID_VPSS;
754 stSrcChn.s32DevId = 0;
755 stSrcChn.s32ChnId = 1;
756 stDestChn.enModId = RK_ID_VO;
757 stDestChn.s32DevId = 0;
758 stDestChn.s32ChnId = VDEC_CH_CNT + 1;
759 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
760 if (s32Ret != RK_SUCCESS) {
761 RK_LOGE("vpss ch 0 band vo fail:%x", s32Ret);
762 return -1;
763 }
764
765 stDestChn.enModId = RK_ID_VO;
766 stDestChn.s32DevId = 1;
767 stDestChn.s32ChnId = VDEC_CH_CNT + 1;
768 s32Ret = RK_MPI_SYS_Bind(&stSrcChn, &stDestChn);
769 if (s32Ret != RK_SUCCESS) {
770 RK_LOGE("vpss ch 0 band vo fail:%x", s32Ret);
771 return -1;
772 }
773
774 // enable vo
775 s32Ret = RK_MPI_VO_EnableChn(0, VDEC_CH_CNT);
776 if (s32Ret != RK_SUCCESS) {
777 RK_LOGE("Enalbe vo %d chn failed, s32Ret = %d\n", VDEC_CH_CNT, s32Ret);
778 return -1;
779 }
780 s32Ret = RK_MPI_VO_EnableChn(0, VDEC_CH_CNT + 1);
781 if (s32Ret != RK_SUCCESS) {
782 RK_LOGE("Enalbe vo chn failed, s32Ret = %d\n", VDEC_CH_CNT + 1, s32Ret);
783 return -1;
784 }
785 s32Ret = RK_MPI_VO_EnableChn(1, VDEC_CH_CNT);
786 if (s32Ret != RK_SUCCESS) {
787 RK_LOGE("Enalbe vo %d chn failed, s32Ret = %d\n", VDEC_CH_CNT, s32Ret);
788 return -1;
789 }
790 s32Ret = RK_MPI_VO_EnableChn(1, VDEC_CH_CNT + 1);
791 if (s32Ret != RK_SUCCESS) {
792 RK_LOGE("Enalbe vo chn failed, s32Ret = %d\n", VDEC_CH_CNT + 1, s32Ret);
793 return -1;
794 }
795
796 //destory
797 for (u32Ch = 0; u32Ch < VDEC_CH_CNT - 1; u32Ch++) {
798 pthread_join(vdecThread[u32Ch], RK_NULL);
799 }
800
801 for (int i = 0; i < VDEC_CH_CNT; i++) {
802 stSrcChn.enModId = RK_ID_VDEC;
803 stSrcChn.s32DevId = 0;
804 stSrcChn.s32ChnId = i;
805 stDestChn.enModId = RK_ID_VO;
806 stDestChn.s32DevId = 0;
807 stDestChn.s32ChnId = i;
808 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
809 if (s32Ret != RK_SUCCESS) {
810 RK_LOGE("vi unband vo fail:%x", s32Ret);
811 return -1;
812 }
813
814 stDestChn.enModId = RK_ID_VO;
815 stDestChn.s32DevId = 1;
816 stDestChn.s32ChnId = i;
817 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
818 if (s32Ret != RK_SUCCESS) {
819 RK_LOGE("vi band vo fail:%x", s32Ret);
820 return -1;
821 }
822
823 // disable vo
824 s32Ret = RK_MPI_VO_DisableChn(0, i);
825 if (s32Ret != RK_SUCCESS) {
826 RK_LOGE("Enalbe vo chn failed, s32Ret = %d\n", s32Ret);
827 return -1;
828 }
829 s32Ret = RK_MPI_VO_DisableChn(1, i);
830 if (s32Ret != RK_SUCCESS) {
831 RK_LOGE("Enalbe vo chn failed, s32Ret = %d\n", s32Ret);
832 return -1;
833 }
834 mpi_destory_vdec(&vdecCtx[u32Ch], u32Ch);
835 }
836
837 //unbind vi[0] to vo [0, 2] [1, 2]
838 stSrcChn.enModId = RK_ID_VI;
839 stSrcChn.s32DevId = 0;
840 stSrcChn.s32ChnId = 0;
841 stDestChn.enModId = RK_ID_VO;
842 stDestChn.s32DevId = 0;
843 stDestChn.s32ChnId = VDEC_CH_CNT;
844 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
845 if (s32Ret != RK_SUCCESS) {
846 RK_LOGE("vi band vo fail:%x", s32Ret);
847 return -1;
848 }
849
850 stDestChn.enModId = RK_ID_VO;
851 stDestChn.s32DevId = 1;
852 stDestChn.s32ChnId = VDEC_CH_CNT;
853 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
854 if (s32Ret != RK_SUCCESS) {
855 RK_LOGE("vi unband vo fail:%x", s32Ret);
856 return -1;
857 }
858
859 //bind vi [0, 0] to vpss grp 0
860 stDestChn.enModId = RK_ID_VPSS;
861 stDestChn.s32DevId = 0;
862 stDestChn.s32ChnId = 0;
863 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
864 if (s32Ret != RK_SUCCESS) {
865 RK_LOGE("vi unband vpss fail:%x", s32Ret);
866 return -1;
867 }
868
869 //bind vpss ch 0 to venc 0
870 stSrcChn.enModId = RK_ID_VPSS;
871 stSrcChn.s32DevId = 0;
872 stSrcChn.s32ChnId = 0;
873 stDestChn.enModId = RK_ID_VENC;
874 stDestChn.s32DevId = 0;
875 stDestChn.s32ChnId = 0;
876 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
877 if (s32Ret != RK_SUCCESS) {
878 RK_LOGE("vpss ch 0 unband venc fail:%x", s32Ret);
879 return -1;
880 }
881
882 //unbind venc 0 to vdec 1
883 stSrcChn.enModId = RK_ID_VENC;
884 stSrcChn.s32DevId = 0;
885 stSrcChn.s32ChnId = 0;
886 stDestChn.enModId = RK_ID_VDEC;
887 stDestChn.s32DevId = 0;
888 stDestChn.s32ChnId = VDEC_CH_CNT - 1;
889 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
890 if (s32Ret != RK_SUCCESS) {
891 RK_LOGE("vpss ch 0 unband venc fail:%x", s32Ret);
892 return -1;
893 }
894
895 //unbind vpss ch 1 to vo [0, 3] [1, 3]
896 stSrcChn.enModId = RK_ID_VPSS;
897 stSrcChn.s32DevId = 0;
898 stSrcChn.s32ChnId = 1;
899 stDestChn.enModId = RK_ID_VO;
900 stDestChn.s32DevId = 0;
901 stDestChn.s32ChnId = VDEC_CH_CNT + 1;
902 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
903 if (s32Ret != RK_SUCCESS) {
904 RK_LOGE("vpss ch 0 unband vo fail:%x", s32Ret);
905 return -1;
906 }
907
908 stDestChn.enModId = RK_ID_VO;
909 stDestChn.s32DevId = 1;
910 stDestChn.s32ChnId = VDEC_CH_CNT + 1;
911 s32Ret = RK_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
912 if (s32Ret != RK_SUCCESS) {
913 RK_LOGE("vpss ch 0 unband vo fail:%x", s32Ret);
914 return -1;
915 }
916
917 // enable vo
918 s32Ret = RK_MPI_VO_DisableChn(0, VDEC_CH_CNT);
919 if (s32Ret != RK_SUCCESS) {
920 RK_LOGE("Disable vo %d chn failed, s32Ret = %d\n", VDEC_CH_CNT, s32Ret);
921 return -1;
922 }
923 s32Ret = RK_MPI_VO_DisableChn(0, VDEC_CH_CNT + 1);
924 if (s32Ret != RK_SUCCESS) {
925 RK_LOGE("Disable vo chn failed, s32Ret = %d\n", VDEC_CH_CNT + 1, s32Ret);
926 return -1;
927 }
928 s32Ret = RK_MPI_VO_DisableChn(1, VDEC_CH_CNT);
929 if (s32Ret != RK_SUCCESS) {
930 RK_LOGE("Disable vo %d chn failed, s32Ret = %d\n", VDEC_CH_CNT, s32Ret);
931 return -1;
932 }
933 s32Ret = RK_MPI_VO_DisableChn(1, VDEC_CH_CNT + 1);
934 if (s32Ret != RK_SUCCESS) {
935 RK_LOGE("Disable vo chn failed, s32Ret = %d\n", VDEC_CH_CNT + 1, s32Ret);
936 return -1;
937 }
938
939 destroy_vi();
940 destory_vpss(0, 2);
941 destory_venc();
942 destory_vo();
943 return RK_SUCCESS;
944 }
945
mpi_all_test_show_options(const TEST_ALL_CTX_S * ctx)946 static void mpi_all_test_show_options(const TEST_ALL_CTX_S *ctx) {
947 RK_PRINT("cmd parse result:\n");
948 RK_PRINT("video file name : %s\n", ctx->srcFileUri);
949 RK_PRINT("vdec width : %d\n", ctx->u32SrcWidth);
950 RK_PRINT("vdec height : %d\n", ctx->u32SrcHeight);
951 RK_PRINT("vdec codecId : %d\n", ctx->enCodecId);
952 RK_PRINT("loop count : %d\n", ctx->s32LoopCount);
953 RK_PRINT("aEntityName : %s\n", ctx->aEntityName);
954 RK_PRINT("enPixelFormat : %d\n", ctx->enPixelFormat);
955 RK_PRINT("vi width : %d\n", ctx->u32SrcWidth1);
956 RK_PRINT("vi height : %d\n", ctx->u32SrcHeight1);
957 return;
958 }
959
960 static const char *const usages[] = {
961 "./rk_mpi_all_test -i /data/xxx.h264 -w 1920 -h 1080 -W 1920 -H 1080 -n /dev/vide20 -f 65543",
962 NULL,
963 };
964
main(int argc,const char ** argv)965 int main(int argc, const char **argv) {
966 TEST_ALL_CTX_S ctx;
967 memset(&ctx, 0, sizeof(TEST_ALL_CTX_S));
968 ctx.s32LoopCount = 1;
969 ctx.u32ReadSize = 1024;
970 ctx.u32SrcWidth = 1920;
971 ctx.u32SrcHeight = 1080;
972 ctx.u32SrcWidth1 = 1920;
973 ctx.u32SrcHeight1 = 1080;
974 ctx.enCodecId = RK_VIDEO_ID_AVC;
975
976 struct argparse_option options[] = {
977 OPT_HELP(),
978 OPT_GROUP("basic options:"),
979 OPT_STRING('i', "input", &(ctx.srcFileUri),
980 "video file name. <required>", NULL, 0, 0),
981 OPT_INTEGER('C', "codec", &(ctx.enCodecId),
982 "video stream codec(8:h264, 9:mjpeg, 12:h265,...) <required on StreamMode>", NULL, 0, 0),
983 OPT_INTEGER('w', "vdec_width", &(ctx.u32SrcWidth),
984 "video source width <required on StreamMode>", NULL, 0, 0),
985 OPT_INTEGER('h', "vdec_height", &(ctx.u32SrcHeight),
986 "video source height <required on StreamMode>", NULL, 0, 0),
987 OPT_INTEGER('l', "loop_count", &(ctx.s32LoopCount),
988 "loop running count. default(1)", NULL, 0, 0),
989 OPT_INTEGER('W', "vi_width", &(ctx.u32SrcWidth1),
990 "video source width <required on StreamMode>", NULL, 0, 0),
991 OPT_INTEGER('H', "vi_height", &(ctx.u32SrcHeight1),
992 "video source height <required on StreamMode>", NULL, 0, 0),
993 OPT_STRING('n', "name", &(ctx.aEntityName),
994 "set the entityName (required, default null;\n\t"
995 "rv1126 sensor:rkispp_m_bypass rkispp_scale0 rkispp_scale1 rkispp_scale2;\n\t"
996 "rv1126 hdmiin/bt1120/sensor:/dev/videox such as /dev/video19 /dev/video20;\n\t"
997 "rk356x hdmiin/bt1120/sensor:/dev/videox such as /dev/video0 /dev/video1", NULL, 0, 0),
998 OPT_INTEGER('f', "format", &(ctx.enPixelFormat),
999 "set the format(default 0; 0:RK_FMT_YUV420SP 10:RK_FMT_YUV422_UYVY"
1000 "131080:RK_FMT_RGB_BAYER_SBGGR_12BPP.....)", NULL, 0, 0),
1001 OPT_END(),
1002 };
1003
1004 struct argparse argparse;
1005 argparse_init(&argparse, options, usages, 0);
1006 argparse_describe(&argparse, "\nselect a test case to run.",
1007 "\nuse --help for details.");
1008
1009 argc = argparse_parse(&argparse, argc, argv);
1010 mpi_all_test_show_options(&ctx);
1011
1012 if (check_options(&ctx)) {
1013 RK_LOGE("illegal input parameters");
1014 argparse_usage(&argparse);
1015 goto __FAILED;
1016 }
1017
1018 if (RK_MPI_SYS_Init() != RK_SUCCESS) {
1019 goto __FAILED;
1020 }
1021
1022 while (ctx.s32LoopCount > 0) {
1023 if (unit_test_mpi_all(&ctx) < 0) {
1024 goto __FAILED;
1025 }
1026 ctx.s32LoopCount--;
1027 }
1028
1029 if (RK_MPI_SYS_Exit() != RK_SUCCESS) {
1030 goto __FAILED;
1031 }
1032
1033 RK_LOGE("test running success!");
1034 return RK_SUCCESS;
1035 __FAILED:
1036 RK_LOGE("test running failed! %d count running done not yet.", ctx.s32LoopCount);
1037 pause();
1038 return RK_FAILURE;
1039 }
1040
1041