1 /*
2 * Copyright (c) 2022 HiSilicon (Shanghai) Technologies CO., LIMITED.
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
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <string.h>
19 #include <unistd.h>
20 #include <pthread.h>
21 #include <signal.h>
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #include <fcntl.h>
25 #include <sys/ioctl.h>
26
27 #include "sample_comm.h"
28 #include "sample_vio.h"
29 #ifdef __cplusplus
30 #if __cplusplus
31 extern "C" {
32 #endif
33 #endif /* End of #ifdef __cplusplus */
34
SAMPLE_VIO_ViOnlineVpssOfflineRoute(HI_U32 u32VoIntfType)35 HI_S32 SAMPLE_VIO_ViOnlineVpssOfflineRoute(HI_U32 u32VoIntfType)
36 {
37 HI_S32 s32Ret = HI_SUCCESS;
38
39 HI_S32 s32ViCnt = 1;
40 VI_DEV ViDev = 0;
41 VI_PIPE ViPipe = 0;
42 VI_CHN ViChn = 0;
43 HI_S32 s32WorkSnsId = 0;
44 SAMPLE_VI_CONFIG_S stViConfig;
45
46 SIZE_S stSize;
47 VB_CONFIG_S stVbConf;
48 PIC_SIZE_E enPicSize;
49 HI_U32 u32BlkSize;
50
51 VO_CHN VoChn = 0;
52 SAMPLE_VO_CONFIG_S stVoConfig;
53
54 WDR_MODE_E enWDRMode = WDR_MODE_NONE;
55 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
56 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
57 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
58 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
59 VI_VPSS_MODE_E enMastPipeMode = VI_ONLINE_VPSS_OFFLINE;
60
61 VPSS_GRP VpssGrp = 0;
62 VPSS_GRP_ATTR_S stVpssGrpAttr;
63 VPSS_CHN VpssChn = VPSS_CHN0;
64 HI_BOOL abChnEnable[VPSS_MAX_PHY_CHN_NUM] = {0};
65 VPSS_CHN_ATTR_S astVpssChnAttr[VPSS_MAX_PHY_CHN_NUM];
66
67 VENC_CHN VencChn[1] = {0};
68 PAYLOAD_TYPE_E enType = PT_H265;
69 SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;
70 HI_U32 u32Profile = 0;
71 HI_BOOL bRcnRefShareBuf = HI_FALSE;
72 VENC_GOP_ATTR_S stGopAttr;
73
74 (hi_void)memset_s(&stViConfig, sizeof(stViConfig), 0, sizeof(stViConfig));
75
76 /* config vi */
77 SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
78
79 stViConfig.s32WorkingViNum = s32ViCnt;
80 stViConfig.as32WorkingViId[0] = 0;
81 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.MipiDev = ViDev;
82 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.s32BusId = 0;
83 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.ViDev = ViDev;
84 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = enWDRMode;
85 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.enMastPipeMode = enMastPipeMode;
86 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[0] = ViPipe;
87 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[1] = -1; /* index: 1 */
88 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[2] = -1; /* index: 2 */
89 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[3] = -1; /* index: 3 */
90 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.ViChn = ViChn;
91 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enPixFormat = enPixFormat;
92 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enDynamicRange = enDynamicRange;
93 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enVideoFormat = enVideoFormat;
94 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enCompressMode = enCompressMode;
95
96 /* get picture size */
97 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType, &enPicSize);
98 if (s32Ret != HI_SUCCESS) {
99 SAMPLE_PRT("get picture size by sensor failed!\n");
100 return s32Ret;
101 }
102
103 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &stSize);
104 if (s32Ret != HI_SUCCESS) {
105 SAMPLE_PRT("get picture size failed!\n");
106 return s32Ret;
107 }
108
109 /* config vb */
110 (hi_void)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
111 stVbConf.u32MaxPoolCnt = 2; /* max pool cnt: 2 */
112
113 u32BlkSize = COMMON_GetPicBufferSize(stSize.u32Width, stSize.u32Height, SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8,
114 COMPRESS_MODE_SEG, DEFAULT_ALIGN);
115 stVbConf.astCommPool[0].u64BlkSize = u32BlkSize;
116 stVbConf.astCommPool[0].u32BlkCnt = 10; /* vb block cnt: 10 */
117
118 u32BlkSize = VI_GetRawBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
119 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
120 stVbConf.astCommPool[1].u64BlkSize = u32BlkSize;
121 stVbConf.astCommPool[1].u32BlkCnt = 4; /* vb block cnt: 4 */
122
123 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
124 if (s32Ret != HI_SUCCESS) {
125 SAMPLE_PRT("system init failed with %d!\n", s32Ret);
126 return s32Ret;
127 }
128
129 /* start vi */
130 s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
131 if (s32Ret != HI_SUCCESS) {
132 SAMPLE_PRT("start vi failed.s32Ret:0x%x !\n", s32Ret);
133 goto EXIT;
134 }
135
136 /* config vpss */
137 (hi_void)memset_s(&stVpssGrpAttr, sizeof(VPSS_GRP_ATTR_S), 0, sizeof(VPSS_GRP_ATTR_S));
138 stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
139 stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;
140 stVpssGrpAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
141 stVpssGrpAttr.enPixelFormat = enPixFormat;
142 stVpssGrpAttr.u32MaxW = stSize.u32Width;
143 stVpssGrpAttr.u32MaxH = stSize.u32Height;
144 stVpssGrpAttr.bNrEn = HI_TRUE;
145 stVpssGrpAttr.stNrAttr.enCompressMode = COMPRESS_MODE_FRAME;
146 stVpssGrpAttr.stNrAttr.enNrMotionMode = NR_MOTION_MODE_NORMAL;
147
148 astVpssChnAttr[VpssChn].u32Width = stSize.u32Width;
149 astVpssChnAttr[VpssChn].u32Height = stSize.u32Height;
150 astVpssChnAttr[VpssChn].enChnMode = VPSS_CHN_MODE_USER;
151 astVpssChnAttr[VpssChn].enCompressMode = enCompressMode;
152 astVpssChnAttr[VpssChn].enDynamicRange = enDynamicRange;
153 astVpssChnAttr[VpssChn].enVideoFormat = enVideoFormat;
154 astVpssChnAttr[VpssChn].enPixelFormat = enPixFormat;
155 astVpssChnAttr[VpssChn].stFrameRate.s32SrcFrameRate = FPS_30;
156 astVpssChnAttr[VpssChn].stFrameRate.s32DstFrameRate = FPS_30;
157 astVpssChnAttr[VpssChn].u32Depth = 0;
158 astVpssChnAttr[VpssChn].bMirror = HI_FALSE;
159 astVpssChnAttr[VpssChn].bFlip = HI_FALSE;
160 astVpssChnAttr[VpssChn].stAspectRatio.enMode = ASPECT_RATIO_NONE;
161
162 /* start vpss */
163 abChnEnable[0] = HI_TRUE;
164 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
165 if (s32Ret != HI_SUCCESS) {
166 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
167 goto EXIT1;
168 }
169
170 /* vi bind vpss */
171 s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe, ViChn, VpssGrp);
172 if (s32Ret != HI_SUCCESS) {
173 SAMPLE_PRT("vi bind vpss failed. s32Ret: 0x%x !\n", s32Ret);
174 goto EXIT2;
175 }
176
177 /* config venc */
178 stGopAttr.enGopMode = VENC_GOPMODE_NORMALP;
179 stGopAttr.stNormalP.s32IPQpDelta = 2; /* IPQpDelta: 2 */
180 s32Ret = SAMPLE_COMM_VENC_Start(VencChn[0], enType, enPicSize, enRcMode, u32Profile, bRcnRefShareBuf, &stGopAttr);
181 if (s32Ret != HI_SUCCESS) {
182 SAMPLE_PRT("start venc failed. s32Ret: 0x%x !\n", s32Ret);
183 goto EXIT3;
184 }
185
186 s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(VpssGrp, VpssChn, VencChn[0]);
187 if (s32Ret != HI_SUCCESS) {
188 SAMPLE_PRT("vpss group %d bind venc chn %d failed. s32Ret: 0x%x !n", VpssGrp, VencChn[0], s32Ret);
189 goto EXIT4;
190 }
191
192 /* config vo */
193 s32Ret = SAMPLE_COMM_VO_GetDefConfig(&stVoConfig);
194 if (s32Ret != HI_SUCCESS) {
195 SAMPLE_PRT("Get VO default config failed. s32Ret: 0x%x!n", s32Ret);
196 goto EXIT5;
197 }
198 stVoConfig.enDstDynamicRange = enDynamicRange;
199 if (u32VoIntfType == 1) {
200 stVoConfig.enVoIntfType = VO_INTF_BT1120;
201 stVoConfig.enIntfSync = VO_OUTPUT_1080P25;
202 } else {
203 stVoConfig.enVoIntfType = VO_INTF_HDMI;
204 }
205 stVoConfig.enPicSize = enPicSize;
206
207 /* start vo */
208 s32Ret = SAMPLE_COMM_VO_StartVO(&stVoConfig);
209 if (s32Ret != HI_SUCCESS) {
210 SAMPLE_PRT("start vo failed. s32Ret: 0x%x !\n", s32Ret);
211 goto EXIT5;
212 }
213
214 /* vpss bind vo */
215 s32Ret = SAMPLE_COMM_VPSS_Bind_VO(VpssGrp, VpssChn, stVoConfig.VoDev, VoChn);
216 if (s32Ret != HI_SUCCESS) {
217 SAMPLE_PRT("vpss group %d bind vo%d failed. s32Ret: 0x%x !\n", VpssGrp, stVoConfig.VoDev, s32Ret);
218 goto EXIT6;
219 }
220
221 s32Ret = SAMPLE_COMM_VENC_StartGetStream(VencChn, sizeof(VencChn) / sizeof(VENC_CHN));
222 if (s32Ret != HI_SUCCESS) {
223 SAMPLE_PRT("Get venc stream failed!\n");
224 goto EXIT7;
225 }
226
227 SAMPLE_VIO_GetChar();
228
229 SAMPLE_COMM_VENC_StopGetStream();
230
231 EXIT7:
232 SAMPLE_COMM_VPSS_UnBind_VO(VpssGrp, VpssChn, stVoConfig.VoDev, VoChn);
233 EXIT6:
234 SAMPLE_COMM_VO_StopVO(&stVoConfig);
235 EXIT5:
236 SAMPLE_COMM_VPSS_UnBind_VENC(VpssGrp, VpssChn, VencChn[0]);
237 EXIT4:
238 SAMPLE_COMM_VENC_Stop(VencChn[0]);
239 EXIT3:
240 SAMPLE_COMM_VI_UnBind_VPSS(ViPipe, ViChn, VpssGrp);
241 EXIT2:
242 SAMPLE_COMM_VPSS_Stop(VpssGrp, abChnEnable);
243 EXIT1:
244 SAMPLE_COMM_VI_StopVi(&stViConfig);
245 EXIT:
246 SAMPLE_COMM_SYS_Exit();
247 return s32Ret;
248 }
249
SAMPLE_VIO_WDR_LDC_DIS_SPREAD(HI_U32 u32VoIntfType)250 HI_S32 SAMPLE_VIO_WDR_LDC_DIS_SPREAD(HI_U32 u32VoIntfType)
251 {
252 HI_S32 s32Ret = HI_SUCCESS;
253
254 HI_S32 s32ViCnt = 1;
255 VI_DEV ViDev = 0;
256 VI_PIPE ViPipe[2] = {0, 1};
257 VI_CHN ViChn = 0;
258 HI_S32 s32WorkSnsId = 0;
259 SAMPLE_VI_CONFIG_S stViConfig;
260
261 SIZE_S stSize;
262 VB_CONFIG_S stVbConf;
263 PIC_SIZE_E enPicSize;
264 HI_U32 u32BlkSize;
265
266 VO_CHN VoChn = 0;
267 SAMPLE_VO_CONFIG_S stVoConfig;
268
269 WDR_MODE_E enWDRMode = WDR_MODE_2To1_LINE;
270 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
271 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
272 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
273 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
274 VI_VPSS_MODE_E enMastPipeMode = VI_OFFLINE_VPSS_OFFLINE;
275
276 VPSS_GRP VpssGrp = 0;
277 VPSS_GRP_ATTR_S stVpssGrpAttr;
278 VPSS_CHN VpssChn = VPSS_CHN0;
279 HI_BOOL abChnEnable[VPSS_MAX_PHY_CHN_NUM] = {0};
280 VPSS_CHN_ATTR_S astVpssChnAttr[VPSS_MAX_PHY_CHN_NUM];
281
282 VENC_CHN VencChn[1] = {0};
283 PAYLOAD_TYPE_E enType = PT_H265;
284 SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;
285 HI_U32 u32Profile = 0;
286 HI_BOOL bRcnRefShareBuf = HI_FALSE;
287 VENC_GOP_ATTR_S stGopAttr;
288
289 VI_LDC_ATTR_S stLDCAttr = { 0 };
290 DIS_CONFIG_S stDISConfig = { 0 };
291 DIS_ATTR_S stDISAttr = { 0 };
292 SPREAD_ATTR_S stSpreadAttr = { 0 };
293
294 (hi_void)memset_s(&stViConfig, sizeof(stViConfig), 0, sizeof(stViConfig));
295 SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
296
297 stViConfig.s32WorkingViNum = s32ViCnt;
298 stViConfig.as32WorkingViId[0] = 0;
299 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.MipiDev = ViDev;
300 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.s32BusId = 0;
301 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.ViDev = ViDev;
302 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = enWDRMode;
303 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.enMastPipeMode = enMastPipeMode;
304 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[0] = ViPipe[0];
305 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[1] = ViPipe[1]; /* index: 1 */
306 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[2] = -1; /* index: 2 */
307 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[3] = -1; /* index: 3 */
308 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.ViChn = ViChn;
309 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enPixFormat = enPixFormat;
310 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enDynamicRange = enDynamicRange;
311 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enVideoFormat = enVideoFormat;
312 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enCompressMode = enCompressMode;
313
314 /* get picture size */
315 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType, &enPicSize);
316 if (s32Ret != HI_SUCCESS) {
317 SAMPLE_PRT("get picture size by sensor failed!\n");
318 return s32Ret;
319 }
320
321 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &stSize);
322 if (s32Ret != HI_SUCCESS) {
323 SAMPLE_PRT("get picture size failed!\n");
324 return s32Ret;
325 }
326
327 /* config vb */
328 (hi_void)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
329 stVbConf.u32MaxPoolCnt = 2; /* max pool count: 2 */
330
331 u32BlkSize = COMMON_GetPicBufferSize(stSize.u32Width, stSize.u32Height, SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8,
332 COMPRESS_MODE_SEG, DEFAULT_ALIGN);
333 stVbConf.astCommPool[0].u64BlkSize = u32BlkSize;
334 stVbConf.astCommPool[0].u32BlkCnt = 10; /* vb block count: 10 */
335
336 u32BlkSize = VI_GetRawBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
337 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
338 stVbConf.astCommPool[1].u64BlkSize = u32BlkSize;
339 stVbConf.astCommPool[1].u32BlkCnt = 6; /* vb block count: 6 */
340
341 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
342 if (s32Ret != HI_SUCCESS) {
343 SAMPLE_PRT("system init failed with %d!\n", s32Ret);
344 return s32Ret;
345 }
346
347 /* start vi */
348 s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
349 if (s32Ret != HI_SUCCESS) {
350 SAMPLE_PRT("start vi failed.s32Ret:0x%x !\n", s32Ret);
351 goto EXIT;
352 }
353
354 s32Ret = HI_MPI_VI_SetPipeRepeatMode(ViPipe[0], VI_PIPE_REPEAT_ONCE);
355 if (s32Ret != HI_SUCCESS) {
356 SAMPLE_PRT("HI_MPI_VI_SetPipeRepeatMode failed.s32Ret:0x%x !\n", s32Ret);
357 goto EXIT1;
358 }
359
360 /* config vpss */
361 (hi_void)memset_s(&stVpssGrpAttr, sizeof(VPSS_GRP_ATTR_S), 0, sizeof(VPSS_GRP_ATTR_S));
362 stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
363 stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;
364 stVpssGrpAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
365 stVpssGrpAttr.enPixelFormat = enPixFormat;
366 stVpssGrpAttr.u32MaxW = stSize.u32Width;
367 stVpssGrpAttr.u32MaxH = stSize.u32Height;
368 stVpssGrpAttr.bNrEn = HI_TRUE;
369 stVpssGrpAttr.stNrAttr.enCompressMode = COMPRESS_MODE_FRAME;
370 stVpssGrpAttr.stNrAttr.enNrMotionMode = NR_MOTION_MODE_NORMAL;
371
372 astVpssChnAttr[VpssChn].u32Width = stSize.u32Width;
373 astVpssChnAttr[VpssChn].u32Height = stSize.u32Height;
374 astVpssChnAttr[VpssChn].enChnMode = VPSS_CHN_MODE_USER;
375 astVpssChnAttr[VpssChn].enCompressMode = enCompressMode;
376 astVpssChnAttr[VpssChn].enDynamicRange = enDynamicRange;
377 astVpssChnAttr[VpssChn].enVideoFormat = enVideoFormat;
378 astVpssChnAttr[VpssChn].enPixelFormat = enPixFormat;
379 astVpssChnAttr[VpssChn].stFrameRate.s32SrcFrameRate = FPS_30;
380 astVpssChnAttr[VpssChn].stFrameRate.s32DstFrameRate = FPS_30;
381 astVpssChnAttr[VpssChn].u32Depth = 0;
382 astVpssChnAttr[VpssChn].bMirror = HI_FALSE;
383 astVpssChnAttr[VpssChn].bFlip = HI_FALSE;
384 astVpssChnAttr[VpssChn].stAspectRatio.enMode = ASPECT_RATIO_NONE;
385
386 /* start vpss */
387 abChnEnable[0] = HI_TRUE;
388 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
389 if (s32Ret != HI_SUCCESS) {
390 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
391 goto EXIT1;
392 }
393
394 /* vi bind vpss */
395 s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe[0], ViChn, VpssGrp);
396 if (s32Ret != HI_SUCCESS) {
397 SAMPLE_PRT("vi bind vpss failed. s32Ret: 0x%x !\n", s32Ret);
398 goto EXIT2;
399 }
400
401 /* config venc */
402 stGopAttr.enGopMode = VENC_GOPMODE_NORMALP;
403 stGopAttr.stNormalP.s32IPQpDelta = 2; /* IPQpDelta: 2 */
404 s32Ret = SAMPLE_COMM_VENC_Start(VencChn[0], enType, enPicSize, enRcMode, u32Profile, bRcnRefShareBuf, &stGopAttr);
405 if (s32Ret != HI_SUCCESS) {
406 SAMPLE_PRT("start venc failed. s32Ret: 0x%x !\n", s32Ret);
407 goto EXIT3;
408 }
409
410 s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(VpssGrp, VpssChn, VencChn[0]);
411 if (s32Ret != HI_SUCCESS) {
412 SAMPLE_PRT("vpss group %d bind venc chn %d failed. s32Ret: 0x%x !n", VpssGrp, VencChn[0], s32Ret);
413 goto EXIT4;
414 }
415
416 /* config vo */
417 s32Ret = SAMPLE_COMM_VO_GetDefConfig(&stVoConfig);
418 if (s32Ret != HI_SUCCESS) {
419 SAMPLE_PRT("Get VO default config failed. s32Ret: 0x%x!n", s32Ret);
420 goto EXIT5;
421 }
422 stVoConfig.enDstDynamicRange = enDynamicRange;
423 if (u32VoIntfType == 1) {
424 stVoConfig.enVoIntfType = VO_INTF_BT1120;
425 stVoConfig.enIntfSync = VO_OUTPUT_1080P25;
426 } else {
427 stVoConfig.enVoIntfType = VO_INTF_HDMI;
428 }
429 stVoConfig.enPicSize = enPicSize;
430
431 /* start vo */
432 s32Ret = SAMPLE_COMM_VO_StartVO(&stVoConfig);
433 if (s32Ret != HI_SUCCESS) {
434 SAMPLE_PRT("start vo failed. s32Ret: 0x%x !\n", s32Ret);
435 goto EXIT5;
436 }
437
438 /* vpss bind vo */
439 s32Ret = SAMPLE_COMM_VPSS_Bind_VO(VpssGrp, VpssChn, stVoConfig.VoDev, VoChn);
440 if (s32Ret != HI_SUCCESS) {
441 SAMPLE_PRT("vpss group %d bind vo%d failed. s32Ret: 0x%x !\n", VpssGrp, stVoConfig.VoDev, s32Ret);
442 goto EXIT6;
443 }
444
445 s32Ret = SAMPLE_COMM_VENC_StartGetStream(VencChn, sizeof(VencChn) / sizeof(VENC_CHN));
446 if (s32Ret != HI_SUCCESS) {
447 SAMPLE_PRT("Get venc stream failed!\n");
448 goto EXIT7;
449 }
450
451 SAMPLE_PRT("Press Enter key to Enable LDC!\n");
452 (HI_VOID)getchar();
453
454 stLDCAttr.bEnable = HI_TRUE;
455 stLDCAttr.stAttr.bAspect = 0;
456 stLDCAttr.stAttr.s32XRatio = 100; /* x ratio: 100 */
457 stLDCAttr.stAttr.s32YRatio = 100; /* y ratio: 100 */
458 stLDCAttr.stAttr.s32XYRatio = 100; /* z ratio: 100 */
459 stLDCAttr.stAttr.s32CenterXOffset = 0;
460 stLDCAttr.stAttr.s32CenterYOffset = 0;
461 stLDCAttr.stAttr.s32DistortionRatio = 500; /* distortion ratio: 500 */
462
463 s32Ret = HI_MPI_VI_SetChnLDCAttr(ViPipe[0], ViChn, &stLDCAttr);
464 if (s32Ret != HI_SUCCESS) {
465 SAMPLE_PRT("HI_MPI_VI_SetChnLDCAttr failed witfh %d\n", s32Ret);
466 goto EXIT8;
467 }
468
469 SAMPLE_PRT("Press Enter key to Enable DIS!\n");
470 (HI_VOID)getchar();
471
472 stDISConfig.enMode = DIS_MODE_6_DOF_GME;
473 stDISConfig.enMotionLevel = DIS_MOTION_LEVEL_NORMAL;
474 stDISConfig.u32CropRatio = 80; /* crop ratio: 80 */
475 stDISConfig.u32BufNum = 5; /* buffer nums: 5 */
476 stDISConfig.enPdtType = DIS_PDT_TYPE_IPC;
477 stDISConfig.u32GyroOutputRange = 0;
478 stDISConfig.u32FrameRate = FPS_30;
479 stDISConfig.bScale = HI_TRUE;
480 stDISConfig.bCameraSteady = HI_FALSE;
481
482 s32Ret = HI_MPI_VI_SetChnDISConfig(ViPipe[0], ViChn, &stDISConfig);
483 if (s32Ret != HI_SUCCESS) {
484 SAMPLE_PRT("HI_MPI_VI_SetChnDISConfig failed.s32Ret:0x%x !\n", s32Ret);
485 goto EXIT8;
486 }
487
488 stDISAttr.bEnable = HI_TRUE;
489 stDISAttr.u32MovingSubjectLevel = 0;
490 stDISAttr.s32RollingShutterCoef = 0;
491 stDISAttr.u32ViewAngle = 1000; /* view angle: 1000 */
492 stDISAttr.bStillCrop = HI_FALSE;
493 stDISAttr.u32HorizontalLimit = 512; /* horizontal limit: 512 */
494 stDISAttr.u32VerticalLimit = 512; /* ertical limit: 512 */
495
496 s32Ret = HI_MPI_VI_SetChnDISAttr(ViPipe[0], ViChn, &stDISAttr);
497 if (s32Ret != HI_SUCCESS) {
498 SAMPLE_PRT("HI_MPI_VI_SetChnDISAttr failed.s32Ret:0x%x !\n", s32Ret);
499 goto EXIT8;
500 }
501
502 SAMPLE_PRT("Press Enter key to Enable Spread!\n");
503 (HI_VOID)getchar();
504
505 stSpreadAttr.bEnable = HI_TRUE;
506 stSpreadAttr.u32SpreadCoef = 16; /* spread coef: 16 */
507 stSpreadAttr.stDestSize.u32Width = stSize.u32Width;
508 stSpreadAttr.stDestSize.u32Height = stSize.u32Height;
509
510 s32Ret = HI_MPI_VI_SetChnSpreadAttr(ViPipe[0], ViChn, &stSpreadAttr);
511 if (s32Ret != HI_SUCCESS) {
512 SAMPLE_PRT("HI_MPI_VI_SetChnSpreadAttr failed witfh %d\n", s32Ret);
513 goto EXIT8;
514 }
515
516 SAMPLE_VIO_GetChar();
517
518 EXIT8:
519 SAMPLE_COMM_VENC_StopGetStream();
520 EXIT7:
521 SAMPLE_COMM_VPSS_UnBind_VO(VpssGrp, VpssChn, stVoConfig.VoDev, VoChn);
522 EXIT6:
523 SAMPLE_COMM_VO_StopVO(&stVoConfig);
524 EXIT5:
525 SAMPLE_COMM_VPSS_UnBind_VENC(VpssGrp, VpssChn, VencChn[0]);
526 EXIT4:
527 SAMPLE_COMM_VENC_Stop(VencChn[0]);
528 EXIT3:
529 SAMPLE_COMM_VI_UnBind_VPSS(ViPipe[0], ViChn, VpssGrp);
530 EXIT2:
531 SAMPLE_COMM_VPSS_Stop(VpssGrp, abChnEnable);
532 EXIT1:
533 SAMPLE_COMM_VI_StopVi(&stViConfig);
534 EXIT:
535 SAMPLE_COMM_SYS_Exit();
536 return s32Ret;
537 }
538
SAMPLE_VIO_ViDoublePipeRoute(HI_U32 u32VoIntfType)539 HI_S32 SAMPLE_VIO_ViDoublePipeRoute(HI_U32 u32VoIntfType)
540 {
541 HI_S32 s32Ret;
542
543 HI_S32 s32ViCnt = 1;
544 VI_DEV ViDev = 0;
545 VI_PIPE ViPipe[2] = {0, 2}; /* pipe0 pipe2 */
546 VI_CHN ViChn = 0;
547 HI_S32 s32WorkSnsId = 0;
548 SAMPLE_VI_CONFIG_S stViConfig;
549
550 SIZE_S stSize;
551 VB_CONFIG_S stVbConf;
552 PIC_SIZE_E enPicSize;
553 HI_U32 u32BlkSize;
554
555 VO_CHN VoChn[2] = {0, 1};
556 SAMPLE_VO_CONFIG_S stVoConfig;
557
558 WDR_MODE_E enWDRMode = WDR_MODE_NONE;
559 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
560 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
561 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
562 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
563 VI_VPSS_MODE_E enMastPipeMode = VI_OFFLINE_VPSS_ONLINE;
564
565 VPSS_GRP VpssGrp[2] = {0, 2}; /* vpss grp0 grp2 */
566 VPSS_GRP_ATTR_S stVpssGrpAttr;
567 VPSS_CHN VpssChn = VPSS_CHN0;
568 HI_BOOL abChnEnable[VPSS_MAX_PHY_CHN_NUM] = {0};
569 VPSS_CHN_ATTR_S astVpssChnAttr[VPSS_MAX_PHY_CHN_NUM];
570
571 VENC_CHN VencChn[1] = {0};
572 PAYLOAD_TYPE_E enType = PT_H265;
573 SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;
574 HI_U32 u32Profile = 0;
575 HI_BOOL bRcnRefShareBuf = HI_FALSE;
576 VENC_GOP_ATTR_S stGopAttr;
577
578 (hi_void)memset_s(&stViConfig, sizeof(stViConfig), 0, sizeof(stViConfig));
579 /* config vi */
580 SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
581
582 stViConfig.s32WorkingViNum = s32ViCnt;
583 stViConfig.as32WorkingViId[0] = 0;
584 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.MipiDev = ViDev;
585 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.s32BusId = 0;
586 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.ViDev = ViDev;
587 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = enWDRMode;
588 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.enMastPipeMode = enMastPipeMode;
589 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[0] = ViPipe[0];
590 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[1] = ViPipe[1]; /* index: 1 */
591 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[2] = -1; /* index: 2 */
592 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[3] = -1; /* index: 3 */
593 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.ViChn = ViChn;
594 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enPixFormat = enPixFormat;
595 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enDynamicRange = enDynamicRange;
596 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enVideoFormat = enVideoFormat;
597 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enCompressMode = enCompressMode;
598
599 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.bMultiPipe = HI_TRUE;
600
601 /* get picture size */
602 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType, &enPicSize);
603 if (s32Ret != HI_SUCCESS) {
604 SAMPLE_PRT("get picture size by sensor failed!\n");
605 return s32Ret;
606 }
607
608 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &stSize);
609 if (s32Ret != HI_SUCCESS) {
610 SAMPLE_PRT("get picture size failed!\n");
611 return s32Ret;
612 }
613
614 /* config vb */
615 (hi_void)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
616 stVbConf.u32MaxPoolCnt = 2; /* max pool count: 2 */
617
618 u32BlkSize = COMMON_GetPicBufferSize(stSize.u32Width, stSize.u32Height, SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8,
619 COMPRESS_MODE_SEG, DEFAULT_ALIGN);
620 stVbConf.astCommPool[0].u64BlkSize = u32BlkSize;
621 stVbConf.astCommPool[0].u32BlkCnt = 20; /* vb block count: 20 */
622
623 u32BlkSize = VI_GetRawBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
624 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
625 stVbConf.astCommPool[1].u64BlkSize = u32BlkSize;
626 stVbConf.astCommPool[1].u32BlkCnt = 4; /* vb block count: 4 */
627
628 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
629 if (s32Ret != HI_SUCCESS) {
630 SAMPLE_PRT("system init failed with %d!\n", s32Ret);
631 return s32Ret;
632 }
633
634 /* start vi */
635 s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
636 if (s32Ret != HI_SUCCESS) {
637 SAMPLE_PRT("start vi failed.s32Ret:0x%x !\n", s32Ret);
638 goto EXIT;
639 }
640
641 /* config vpss */
642 (hi_void)memset_s(&stVpssGrpAttr, sizeof(VPSS_GRP_ATTR_S), 0, sizeof(VPSS_GRP_ATTR_S));
643 stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
644 stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;
645 stVpssGrpAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
646 stVpssGrpAttr.enPixelFormat = enPixFormat;
647 stVpssGrpAttr.u32MaxW = stSize.u32Width;
648 stVpssGrpAttr.u32MaxH = stSize.u32Height;
649 stVpssGrpAttr.bNrEn = HI_TRUE;
650 stVpssGrpAttr.stNrAttr.enCompressMode = COMPRESS_MODE_FRAME;
651 stVpssGrpAttr.stNrAttr.enNrMotionMode = NR_MOTION_MODE_NORMAL;
652
653 astVpssChnAttr[VpssChn].u32Width = stSize.u32Width;
654 astVpssChnAttr[VpssChn].u32Height = stSize.u32Height;
655 astVpssChnAttr[VpssChn].enChnMode = VPSS_CHN_MODE_USER;
656 astVpssChnAttr[VpssChn].enCompressMode = enCompressMode;
657 astVpssChnAttr[VpssChn].enDynamicRange = enDynamicRange;
658 astVpssChnAttr[VpssChn].enVideoFormat = enVideoFormat;
659 astVpssChnAttr[VpssChn].enPixelFormat = enPixFormat;
660 astVpssChnAttr[VpssChn].stFrameRate.s32SrcFrameRate = -1;
661 astVpssChnAttr[VpssChn].stFrameRate.s32DstFrameRate = -1;
662 astVpssChnAttr[VpssChn].u32Depth = 0;
663 astVpssChnAttr[VpssChn].bMirror = HI_FALSE;
664 astVpssChnAttr[VpssChn].bFlip = HI_FALSE;
665 astVpssChnAttr[VpssChn].stAspectRatio.enMode = ASPECT_RATIO_NONE;
666
667 /* start vpss */
668 abChnEnable[0] = HI_TRUE;
669 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp[0], abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
670 if (s32Ret != HI_SUCCESS) {
671 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
672 goto EXIT1;
673 }
674
675 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp[1], abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
676 if (s32Ret != HI_SUCCESS) {
677 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
678 goto EXIT2;
679 }
680
681 /* config venc */
682 stGopAttr.enGopMode = VENC_GOPMODE_NORMALP;
683 stGopAttr.stNormalP.s32IPQpDelta = 2; /* IPQpDelta: 2 */
684 s32Ret = SAMPLE_COMM_VENC_Start(VencChn[0], enType, enPicSize, enRcMode, u32Profile, bRcnRefShareBuf, &stGopAttr);
685 if (s32Ret != HI_SUCCESS) {
686 SAMPLE_PRT("start venc failed. s32Ret: 0x%x !\n", s32Ret);
687 goto EXIT3;
688 }
689
690 s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(VpssGrp[1], VpssChn, VencChn[0]);
691 if (s32Ret != HI_SUCCESS) {
692 SAMPLE_PRT("vpss group %d bind venc chn %d failed. s32Ret: 0x%x !n", VpssGrp[1], VencChn[0], s32Ret);
693 goto EXIT4;
694 }
695
696 /* config vo */
697 s32Ret = SAMPLE_COMM_VO_GetDefConfig(&stVoConfig);
698 if (s32Ret != HI_SUCCESS) {
699 SAMPLE_PRT("Get VO default config failed. s32Ret: 0x%x!n", s32Ret);
700 goto EXIT5;
701 }
702 stVoConfig.enDstDynamicRange = enDynamicRange;
703 if (u32VoIntfType == 1) {
704 stVoConfig.enVoIntfType = VO_INTF_BT1120;
705 stVoConfig.enIntfSync = VO_OUTPUT_1080P25;
706 } else {
707 stVoConfig.enVoIntfType = VO_INTF_HDMI;
708 }
709 stVoConfig.enVoMode = VO_MODE_2MUX;
710 stVoConfig.enPicSize = enPicSize;
711
712 /* start vo */
713 s32Ret = SAMPLE_COMM_VO_StartVO(&stVoConfig);
714 if (s32Ret != HI_SUCCESS) {
715 SAMPLE_PRT("start vo failed. s32Ret: 0x%x !\n", s32Ret);
716 goto EXIT5;
717 }
718
719 /* vpss bind vo */
720 s32Ret = SAMPLE_COMM_VPSS_Bind_VO(VpssGrp[0], VpssChn, stVoConfig.VoDev, VoChn[0]);
721 if (s32Ret != HI_SUCCESS) {
722 SAMPLE_PRT("vpss group %d bind vo%d failed. s32Ret: 0x%x !\n", VpssGrp[0], stVoConfig.VoDev, s32Ret);
723 goto EXIT6;
724 }
725
726 s32Ret = SAMPLE_COMM_VPSS_Bind_VO(VpssGrp[1], VpssChn, stVoConfig.VoDev, VoChn[1]);
727 if (s32Ret != HI_SUCCESS) {
728 SAMPLE_PRT("vpss group %d bind vo%d failed. s32Ret: 0x%x !\n", VpssGrp[1], stVoConfig.VoDev, s32Ret);
729 goto EXIT7;
730 }
731
732 s32Ret = SAMPLE_COMM_VENC_StartGetStream(VencChn, sizeof(VencChn) / sizeof(VENC_CHN));
733 if (s32Ret != HI_SUCCESS) {
734 SAMPLE_PRT("Get venc stream failed!\n");
735 goto EXIT8;
736 }
737
738 SAMPLE_VIO_GetChar();
739
740 SAMPLE_COMM_VENC_StopGetStream();
741
742 EXIT8:
743 SAMPLE_COMM_VPSS_UnBind_VO(VpssGrp[1], VpssChn, stVoConfig.VoDev, VoChn[1]);
744 EXIT7:
745 SAMPLE_COMM_VPSS_UnBind_VO(VpssGrp[0], VpssChn, stVoConfig.VoDev, VoChn[0]);
746 EXIT6:
747 SAMPLE_COMM_VO_StopVO(&stVoConfig);
748 EXIT5:
749 SAMPLE_COMM_VPSS_UnBind_VENC(VpssGrp[1], VpssChn, VencChn[0]);
750 EXIT4:
751 SAMPLE_COMM_VENC_Stop(VencChn[0]);
752 EXIT3:
753 SAMPLE_COMM_VPSS_Stop(VpssGrp[1], abChnEnable);
754 EXIT2:
755 SAMPLE_COMM_VPSS_Stop(VpssGrp[0], abChnEnable);
756 EXIT1:
757 SAMPLE_COMM_VI_StopVi(&stViConfig);
758 EXIT:
759 SAMPLE_COMM_SYS_Exit();
760 return s32Ret;
761 }
762
763
SAMPLE_VIO_ViWdrSwitch(HI_U32 u32VoIntfType)764 HI_S32 SAMPLE_VIO_ViWdrSwitch(HI_U32 u32VoIntfType)
765 {
766 HI_S32 s32Ret = HI_SUCCESS;
767
768 HI_S32 s32ViCnt = 1;
769 VI_DEV ViDev = 0;
770 VI_PIPE ViPipe[2] = {0, 1};
771 VI_CHN ViChn = 0;
772 HI_S32 s32WorkSnsId = 0;
773 SAMPLE_VI_CONFIG_S stViConfig;
774
775 SIZE_S stSize;
776 VB_CONFIG_S stVbConf;
777 PIC_SIZE_E enPicSize;
778 HI_U32 u32BlkSize;
779
780 VO_CHN VoChn = 0;
781 SAMPLE_VO_CONFIG_S stVoConfig;
782
783 WDR_MODE_E enWDRMode = WDR_MODE_NONE;
784 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
785 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
786 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
787 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
788 VI_VPSS_MODE_E enMastPipeMode = VI_ONLINE_VPSS_OFFLINE;
789
790 VPSS_GRP VpssGrp = 0;
791 VPSS_GRP_ATTR_S stVpssGrpAttr;
792 VPSS_CHN VpssChn = VPSS_CHN0;
793 HI_BOOL abChnEnable[VPSS_MAX_PHY_CHN_NUM] = {0};
794 VPSS_CHN_ATTR_S astVpssChnAttr[VPSS_MAX_PHY_CHN_NUM];
795
796 VENC_CHN VencChn[1] = {0};
797 PAYLOAD_TYPE_E enType = PT_H265;
798 SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;
799 HI_U32 u32Profile = 0;
800 HI_BOOL bRcnRefShareBuf = HI_FALSE;
801 VENC_GOP_ATTR_S stGopAttr;
802
803 HI_BOOL bBypassAWB;
804 ISP_MODULE_CTRL_U unModCtrl;
805 HI_S32 s32MilliSec = 80; /* 80ms timeout */
806 ISP_VD_TYPE_E enIspVDType = ISP_VD_FE_START;
807 HI_U8 i = 0;
808
809 (hi_void)memset_s(&stViConfig, sizeof(stViConfig), 0, sizeof(stViConfig));
810 /* config vi */
811 SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
812
813 stViConfig.s32WorkingViNum = s32ViCnt;
814 stViConfig.as32WorkingViId[0] = 0;
815 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.MipiDev = ViDev;
816 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.s32BusId = 0;
817 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.ViDev = ViDev;
818 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = enWDRMode;
819 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.enMastPipeMode = enMastPipeMode;
820 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[0] = ViPipe[0];
821 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[1] = -1; /* index: 1 */
822 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[2] = -1; /* index: 2 */
823 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[3] = -1; /* index: 3 */
824 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.ViChn = ViChn;
825 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enPixFormat = enPixFormat;
826 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enDynamicRange = enDynamicRange;
827 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enVideoFormat = enVideoFormat;
828 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enCompressMode = enCompressMode;
829
830 /* get picture size */
831 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType, &enPicSize);
832 if (s32Ret != HI_SUCCESS) {
833 SAMPLE_PRT("get picture size by sensor failed!\n");
834 return s32Ret;
835 }
836
837 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &stSize);
838 if (s32Ret != HI_SUCCESS) {
839 SAMPLE_PRT("get picture size failed!\n");
840 return s32Ret;
841 }
842
843 /* config vb */
844 (hi_void)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
845 stVbConf.u32MaxPoolCnt = 2; /* max pool count: 2 */
846
847 u32BlkSize = COMMON_GetPicBufferSize(stSize.u32Width, stSize.u32Height, SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8,
848 COMPRESS_MODE_SEG, DEFAULT_ALIGN);
849 stVbConf.astCommPool[0].u64BlkSize = u32BlkSize;
850 stVbConf.astCommPool[0].u32BlkCnt = 10; /* vb block count: 10 */
851
852 u32BlkSize = VI_GetRawBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
853 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
854 stVbConf.astCommPool[1].u64BlkSize = u32BlkSize;
855 stVbConf.astCommPool[1].u32BlkCnt = 4; /* vb block count: 4 */
856
857 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
858 if (s32Ret != HI_SUCCESS) {
859 SAMPLE_PRT("system init failed with %d!\n", s32Ret);
860 return s32Ret;
861 }
862
863 /* start vi */
864 s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
865 if (s32Ret != HI_SUCCESS) {
866 SAMPLE_PRT("start vi failed.s32Ret:0x%x !\n", s32Ret);
867 goto EXIT;
868 }
869
870 /* config vpss */
871 (hi_void)memset_s(&stVpssGrpAttr, sizeof(VPSS_GRP_ATTR_S), 0, sizeof(VPSS_GRP_ATTR_S));
872 stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
873 stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;
874 stVpssGrpAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
875 stVpssGrpAttr.enPixelFormat = enPixFormat;
876 stVpssGrpAttr.u32MaxW = stSize.u32Width;
877 stVpssGrpAttr.u32MaxH = stSize.u32Height;
878 stVpssGrpAttr.bNrEn = HI_FALSE;
879 stVpssGrpAttr.stNrAttr.enCompressMode = COMPRESS_MODE_FRAME;
880 stVpssGrpAttr.stNrAttr.enNrMotionMode = NR_MOTION_MODE_NORMAL;
881
882 astVpssChnAttr[VpssChn].u32Width = stSize.u32Width;
883 astVpssChnAttr[VpssChn].u32Height = stSize.u32Height;
884 astVpssChnAttr[VpssChn].enChnMode = VPSS_CHN_MODE_USER;
885 astVpssChnAttr[VpssChn].enCompressMode = enCompressMode;
886 astVpssChnAttr[VpssChn].enDynamicRange = enDynamicRange;
887 astVpssChnAttr[VpssChn].enVideoFormat = enVideoFormat;
888 astVpssChnAttr[VpssChn].enPixelFormat = enPixFormat;
889 astVpssChnAttr[VpssChn].stFrameRate.s32SrcFrameRate = FPS_30;
890 astVpssChnAttr[VpssChn].stFrameRate.s32DstFrameRate = FPS_30;
891 astVpssChnAttr[VpssChn].u32Depth = 0;
892 astVpssChnAttr[VpssChn].bMirror = HI_FALSE;
893 astVpssChnAttr[VpssChn].bFlip = HI_FALSE;
894 astVpssChnAttr[VpssChn].stAspectRatio.enMode = ASPECT_RATIO_NONE;
895
896 /* start vpss */
897 abChnEnable[0] = HI_TRUE;
898 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
899 if (s32Ret != HI_SUCCESS) {
900 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
901 goto EXIT1;
902 }
903
904 /* vi bind vpss */
905 s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe[0], ViChn, VpssGrp);
906 if (s32Ret != HI_SUCCESS) {
907 SAMPLE_PRT("vi bind vpss failed. s32Ret: 0x%x !\n", s32Ret);
908 goto EXIT2;
909 }
910
911 /* config venc */
912 stGopAttr.enGopMode = VENC_GOPMODE_NORMALP;
913 stGopAttr.stNormalP.s32IPQpDelta = 2; /* IPQpDelta: 2 */
914 s32Ret = SAMPLE_COMM_VENC_Start(VencChn[0], enType, enPicSize, enRcMode, u32Profile, bRcnRefShareBuf, &stGopAttr);
915 if (s32Ret != HI_SUCCESS) {
916 SAMPLE_PRT("start venc failed. s32Ret: 0x%x !\n", s32Ret);
917 goto EXIT3;
918 }
919
920 s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(VpssGrp, VpssChn, VencChn[0]);
921 if (s32Ret != HI_SUCCESS) {
922 SAMPLE_PRT("vpss group %d bind venc chn %d failed. s32Ret: 0x%x !n", VpssGrp, VencChn[0], s32Ret);
923 goto EXIT4;
924 }
925
926 /* config vo */
927 s32Ret = SAMPLE_COMM_VO_GetDefConfig(&stVoConfig);
928 if (s32Ret != HI_SUCCESS) {
929 SAMPLE_PRT("Get VO default config failed. s32Ret: 0x%x!n", s32Ret);
930 goto EXIT5;
931 }
932 stVoConfig.enDstDynamicRange = enDynamicRange;
933 if (u32VoIntfType == 1) {
934 stVoConfig.enVoIntfType = VO_INTF_BT1120;
935 stVoConfig.enIntfSync = VO_OUTPUT_1080P25;
936 } else {
937 stVoConfig.enVoIntfType = VO_INTF_HDMI;
938 }
939 stVoConfig.enPicSize = enPicSize;
940
941 /* start vo */
942 s32Ret = SAMPLE_COMM_VO_StartVO(&stVoConfig);
943 if (s32Ret != HI_SUCCESS) {
944 SAMPLE_PRT("start vo failed. s32Ret: 0x%x !\n", s32Ret);
945 goto EXIT5;
946 }
947
948 /* vpss bind vo */
949 s32Ret = SAMPLE_COMM_VPSS_Bind_VO(VpssGrp, VpssChn, stVoConfig.VoDev, VoChn);
950 if (s32Ret != HI_SUCCESS) {
951 SAMPLE_PRT("vpss group %d bind vo%d failed. s32Ret: 0x%x !\n", VpssGrp, stVoConfig.VoDev, s32Ret);
952 goto EXIT6;
953 }
954
955 s32Ret = SAMPLE_COMM_VENC_StartGetStream(VencChn, sizeof(VencChn) / sizeof(VENC_CHN));
956 if (s32Ret != HI_SUCCESS) {
957 SAMPLE_PRT("Get venc stream failed!\n");
958 goto EXIT7;
959 }
960 SAMPLE_PRT("switch to wdr mode========\n");
961 (HI_VOID)getchar();
962
963 bBypassAWB = ((enMastPipeMode == VI_ONLINE_VPSS_OFFLINE) || (enMastPipeMode == VI_ONLINE_VPSS_ONLINE));
964
965 if (bBypassAWB == HI_TRUE) {
966 s32Ret = HI_MPI_ISP_GetModuleControl(ViPipe[0], &unModCtrl);
967 if (s32Ret != HI_SUCCESS) {
968 SAMPLE_PRT("HI_MPI_ISP_GetModuleControl failed!\n");
969 goto EXIT8;
970 }
971 unModCtrl.bitBypassAWBStat = HI_TRUE;
972 s32Ret = HI_MPI_ISP_SetModuleControl(ViPipe[0], &unModCtrl);
973 if (s32Ret != HI_SUCCESS) {
974 SAMPLE_PRT("HI_MPI_ISP_SetModuleControl failed!\n");
975 goto EXIT8;
976 }
977 for (i = 0; i < 2; i++) { /* loop 2 times */
978 s32Ret = HI_MPI_ISP_GetVDTimeOut(ViPipe[0], enIspVDType, s32MilliSec);
979 if (s32Ret != HI_SUCCESS) {
980 SAMPLE_PRT("HI_MPI_ISP_GetVDTimeOut failed with %#x\n", s32Ret);
981 goto EXIT8;
982 }
983 }
984 }
985
986 s32Ret = SAMPLE_COMM_VPSS_Stop(VpssGrp, abChnEnable);
987 if (s32Ret != HI_SUCCESS) {
988 SAMPLE_PRT("vpss grp %d stop failed. s32Ret: 0x%x!\n", VpssGrp, s32Ret);
989 goto EXIT8;
990 }
991
992 s32Ret = SAMPLE_COMM_VI_SwitchMode_StopVI(&stViConfig);
993 if (s32Ret != HI_SUCCESS) {
994 SAMPLE_PRT("SAMPLE_COMM_VI_SwitchMode_StopVI failed with %#x\n", s32Ret);
995 goto EXIT8;
996 }
997
998 if (stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType == SONY_IMX335_MIPI_5M_30FPS_12BIT) {
999 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType = SONY_IMX335_MIPI_5M_30FPS_10BIT_WDR2TO1;
1000 } else if (stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType == SONY_IMX335_MIPI_4M_30FPS_12BIT) {
1001 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType = SONY_IMX335_MIPI_4M_30FPS_10BIT_WDR2TO1;
1002 } else {
1003 SAMPLE_PRT("sensor:%d, not support switch to wdr mode.\n",
1004 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType);
1005 }
1006
1007 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = WDR_MODE_2To1_LINE;
1008 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[0] = ViPipe[0];
1009 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[1] = ViPipe[1];
1010 s32Ret = SAMPLE_COMM_VI_SwitchMode(&stViConfig);
1011 if (s32Ret != HI_SUCCESS) {
1012 SAMPLE_PRT("SAMPLE_COMM_VI_SwitchMode failed. s32Ret: 0x%x !\n", s32Ret);
1013 goto EXIT8;
1014 }
1015
1016 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
1017 if (s32Ret != HI_SUCCESS) {
1018 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
1019 goto EXIT8;
1020 }
1021
1022 if (bBypassAWB == HI_TRUE) {
1023 s32Ret = HI_MPI_ISP_GetModuleControl(ViPipe[0], &unModCtrl);
1024 if (s32Ret != HI_SUCCESS) {
1025 SAMPLE_PRT("HI_MPI_ISP_GetModuleControl failed. s32Ret: 0x%x!\n", s32Ret);
1026 goto EXIT8;
1027 }
1028 unModCtrl.bitBypassAWBStat = HI_FALSE;
1029 s32Ret = HI_MPI_ISP_SetModuleControl(ViPipe[0], &unModCtrl);
1030 if (s32Ret != HI_SUCCESS) {
1031 SAMPLE_PRT("HI_MPI_ISP_SetModuleControl failed. s32Ret: 0x%x!\n", s32Ret);
1032 goto EXIT8;
1033 }
1034 }
1035
1036 SAMPLE_PRT("switch to linear mode========\n");
1037 (HI_VOID)getchar();
1038
1039 if (bBypassAWB == HI_TRUE) {
1040 s32Ret = HI_MPI_ISP_GetModuleControl(ViPipe[0], &unModCtrl);
1041 if (s32Ret != HI_SUCCESS) {
1042 SAMPLE_PRT("HI_MPI_ISP_GetModuleControl failed. s32Ret: 0x%x!\n", s32Ret);
1043 goto EXIT8;
1044 }
1045 unModCtrl.bitBypassAWBStat = HI_TRUE;
1046 s32Ret = HI_MPI_ISP_SetModuleControl(ViPipe[0], &unModCtrl);
1047 if (s32Ret != HI_SUCCESS) {
1048 SAMPLE_PRT("HI_MPI_ISP_SetModuleControl failed. s32Ret: 0x%x!\n", s32Ret);
1049 goto EXIT8;
1050 }
1051 for (i = 0; i < 2; i++) { /* loop 2 times */
1052 s32Ret = HI_MPI_ISP_GetVDTimeOut(ViPipe[0], enIspVDType, s32MilliSec);
1053 if (s32Ret != HI_SUCCESS) {
1054 SAMPLE_PRT("HI_MPI_ISP_GetVDTimeOut failed with %#x!\n", s32Ret);
1055 goto EXIT8;
1056 }
1057 }
1058 }
1059
1060 s32Ret = SAMPLE_COMM_VPSS_Stop(VpssGrp, abChnEnable);
1061 if (s32Ret != HI_SUCCESS) {
1062 SAMPLE_PRT("vpss grp %d stop failed. s32Ret: 0x%x !\n", VpssGrp, s32Ret);
1063 goto EXIT8;
1064 }
1065 s32Ret = SAMPLE_COMM_VI_SwitchMode_StopVI(&stViConfig);
1066 if (s32Ret != HI_SUCCESS) {
1067 SAMPLE_PRT("SAMPLE_COMM_VI_SwitchMode_StopVI failed. s32Ret: 0x%x !\n", s32Ret);
1068 goto EXIT8;
1069 }
1070
1071 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType = SENSOR0_TYPE;
1072 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = WDR_MODE_NONE;
1073 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[0] = ViPipe[0];
1074 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[1] = -1;
1075
1076 s32Ret = SAMPLE_COMM_VI_SwitchMode(&stViConfig);
1077 if (s32Ret != HI_SUCCESS) {
1078 SAMPLE_PRT("SAMPLE_COMM_VI_SwitchMode failed. s32Ret: 0x%x !\n", s32Ret);
1079 goto EXIT8;
1080 }
1081
1082 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
1083 if (s32Ret != HI_SUCCESS) {
1084 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
1085 goto EXIT8;
1086 }
1087
1088 if (bBypassAWB == HI_TRUE) {
1089 s32Ret = HI_MPI_ISP_GetModuleControl(ViPipe[0], &unModCtrl);
1090 if (s32Ret != HI_SUCCESS) {
1091 SAMPLE_PRT("HI_MPI_ISP_GetModuleControl failed. s32Ret: 0x%x!\n", s32Ret);
1092 goto EXIT8;
1093 }
1094 unModCtrl.bitBypassAWBStat = HI_FALSE;
1095 s32Ret = HI_MPI_ISP_SetModuleControl(ViPipe[0], &unModCtrl);
1096 if (s32Ret != HI_SUCCESS) {
1097 SAMPLE_PRT("HI_MPI_ISP_SetModuleControl failed. s32Ret: 0x%x!\n", s32Ret);
1098 goto EXIT8;
1099 }
1100 }
1101
1102 SAMPLE_VIO_GetChar();
1103
1104 EXIT8:
1105 SAMPLE_COMM_VENC_StopGetStream();
1106 EXIT7:
1107 SAMPLE_COMM_VPSS_UnBind_VO(VpssGrp, VpssChn, stVoConfig.VoDev, VoChn);
1108 EXIT6:
1109 SAMPLE_COMM_VO_StopVO(&stVoConfig);
1110 EXIT5:
1111 SAMPLE_COMM_VPSS_UnBind_VENC(VpssGrp, VpssChn, VencChn[0]);
1112 EXIT4:
1113 SAMPLE_COMM_VENC_Stop(VencChn[0]);
1114 EXIT3:
1115 SAMPLE_COMM_VI_UnBind_VPSS(ViPipe[0], ViChn, VpssGrp);
1116 EXIT2:
1117 SAMPLE_COMM_VPSS_Stop(VpssGrp, abChnEnable);
1118 EXIT1:
1119 SAMPLE_COMM_VI_StopVi(&stViConfig);
1120 EXIT:
1121 SAMPLE_COMM_SYS_Exit();
1122 return s32Ret;
1123 }
1124
SAMPLE_VIO_ViVpssLowDelay(HI_U32 u32VoIntfType)1125 HI_S32 SAMPLE_VIO_ViVpssLowDelay(HI_U32 u32VoIntfType)
1126 {
1127 HI_S32 s32Ret = HI_SUCCESS;
1128 HI_S32 s32ViCnt = 1;
1129 VI_DEV ViDev = 0;
1130 VI_PIPE ViPipe = 0;
1131 VI_CHN ViChn = 0;
1132 HI_S32 s32WorkSnsId = 0;
1133 SAMPLE_VI_CONFIG_S stViConfig;
1134 SIZE_S stSize;
1135 VB_CONFIG_S stVbConf;
1136 PIC_SIZE_E enPicSize;
1137 HI_U32 u32BlkSize;
1138 VO_CHN VoChn = 0;
1139 SAMPLE_VO_CONFIG_S stVoConfig;
1140 WDR_MODE_E enWDRMode = WDR_MODE_NONE;
1141 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
1142 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
1143 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
1144 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
1145 VI_VPSS_MODE_E enMastPipeMode = VI_OFFLINE_VPSS_OFFLINE;
1146 VPSS_GRP VpssGrp = 0;
1147 VPSS_GRP_ATTR_S stVpssGrpAttr;
1148 VPSS_CHN VpssChn = VPSS_CHN0;
1149 HI_BOOL abChnEnable[VPSS_MAX_PHY_CHN_NUM] = {0};
1150 VPSS_CHN_ATTR_S astVpssChnAttr[VPSS_MAX_PHY_CHN_NUM];
1151 VENC_CHN VencChn[1] = {0};
1152 PAYLOAD_TYPE_E enType = PT_H265;
1153 SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;
1154 HI_U32 u32Profile = 0;
1155 HI_BOOL bRcnRefShareBuf = HI_FALSE;
1156 VENC_GOP_ATTR_S stGopAttr;
1157 VI_LDC_ATTR_S stLDCAttr = { 0 };
1158 VI_LOW_DELAY_INFO_S stLowDelayInfo;
1159
1160 (hi_void)memset_s(&stViConfig, sizeof(stViConfig), 0, sizeof(stViConfig));
1161 /* config vi */
1162 SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
1163
1164 stViConfig.s32WorkingViNum = s32ViCnt;
1165 stViConfig.as32WorkingViId[0] = 0;
1166 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.MipiDev = ViDev;
1167 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.s32BusId = 0;
1168 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.ViDev = ViDev;
1169 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = enWDRMode;
1170 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.enMastPipeMode = enMastPipeMode;
1171 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[0] = ViPipe;
1172 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[1] = -1; /* index: 1 */
1173 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[2] = -1; /* index: 2 */
1174 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[3] = -1; /* index: 3 */
1175 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.ViChn = ViChn;
1176 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enPixFormat = enPixFormat;
1177 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enDynamicRange = enDynamicRange;
1178 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enVideoFormat = enVideoFormat;
1179 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enCompressMode = enCompressMode;
1180
1181 /* get picture size */
1182 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType, &enPicSize);
1183 if (s32Ret != HI_SUCCESS) {
1184 SAMPLE_PRT("get picture size by sensor failed!\n");
1185 return s32Ret;
1186 }
1187
1188 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &stSize);
1189 if (s32Ret != HI_SUCCESS) {
1190 SAMPLE_PRT("get picture size failed!\n");
1191 return s32Ret;
1192 }
1193
1194 /* config vb */
1195 (hi_void)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
1196 stVbConf.u32MaxPoolCnt = 2; /* max pool count: 2 */
1197
1198 u32BlkSize = COMMON_GetPicBufferSize(stSize.u32Width, stSize.u32Height, SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8,
1199 COMPRESS_MODE_SEG, DEFAULT_ALIGN);
1200 stVbConf.astCommPool[0].u64BlkSize = u32BlkSize;
1201 stVbConf.astCommPool[0].u32BlkCnt = 8; /* vb block count: 8 */
1202
1203 u32BlkSize = VI_GetRawBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
1204 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
1205 stVbConf.astCommPool[1].u64BlkSize = u32BlkSize;
1206 stVbConf.astCommPool[1].u32BlkCnt = 4; /* vb block count: 4 */
1207
1208 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
1209 if (s32Ret != HI_SUCCESS) {
1210 SAMPLE_PRT("system init failed with %d!\n", s32Ret);
1211 return s32Ret;
1212 }
1213
1214 /* start vi */
1215 s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
1216 if (s32Ret != HI_SUCCESS) {
1217 SAMPLE_PRT("start vi failed.s32Ret:0x%x !\n", s32Ret);
1218 goto EXIT;
1219 }
1220
1221 /* config vpss */
1222 (hi_void)memset_s(&stVpssGrpAttr, sizeof(VPSS_GRP_ATTR_S), 0, sizeof(VPSS_GRP_ATTR_S));
1223 stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
1224 stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;
1225 stVpssGrpAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
1226 stVpssGrpAttr.enPixelFormat = enPixFormat;
1227 stVpssGrpAttr.u32MaxW = stSize.u32Width;
1228 stVpssGrpAttr.u32MaxH = stSize.u32Height;
1229 stVpssGrpAttr.bNrEn = HI_TRUE;
1230 stVpssGrpAttr.stNrAttr.enCompressMode = COMPRESS_MODE_FRAME;
1231 stVpssGrpAttr.stNrAttr.enNrMotionMode = NR_MOTION_MODE_NORMAL;
1232
1233 astVpssChnAttr[VpssChn].u32Width = stSize.u32Width;
1234 astVpssChnAttr[VpssChn].u32Height = stSize.u32Height;
1235 astVpssChnAttr[VpssChn].enChnMode = VPSS_CHN_MODE_USER;
1236 astVpssChnAttr[VpssChn].enCompressMode = enCompressMode;
1237 astVpssChnAttr[VpssChn].enDynamicRange = enDynamicRange;
1238 astVpssChnAttr[VpssChn].enVideoFormat = enVideoFormat;
1239 astVpssChnAttr[VpssChn].enPixelFormat = enPixFormat;
1240 astVpssChnAttr[VpssChn].stFrameRate.s32SrcFrameRate = FPS_30;
1241 astVpssChnAttr[VpssChn].stFrameRate.s32DstFrameRate = FPS_30;
1242 astVpssChnAttr[VpssChn].u32Depth = 0;
1243 astVpssChnAttr[VpssChn].bMirror = HI_FALSE;
1244 astVpssChnAttr[VpssChn].bFlip = HI_FALSE;
1245 astVpssChnAttr[VpssChn].stAspectRatio.enMode = ASPECT_RATIO_NONE;
1246
1247 /* start vpss */
1248 abChnEnable[0] = HI_TRUE;
1249 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
1250 if (s32Ret != HI_SUCCESS) {
1251 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
1252 goto EXIT1;
1253 }
1254
1255 /* vi bind vpss */
1256 s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe, ViChn, VpssGrp);
1257 if (s32Ret != HI_SUCCESS) {
1258 SAMPLE_PRT("vi bind vpss failed. s32Ret: 0x%x !\n", s32Ret);
1259 goto EXIT2;
1260 }
1261
1262 /* config venc */
1263 stGopAttr.enGopMode = VENC_GOPMODE_NORMALP;
1264 stGopAttr.stNormalP.s32IPQpDelta = 2; /* IPQpDelta: 2 */
1265 s32Ret = SAMPLE_COMM_VENC_Start(VencChn[0], enType, enPicSize, enRcMode, u32Profile, bRcnRefShareBuf, &stGopAttr);
1266 if (s32Ret != HI_SUCCESS) {
1267 SAMPLE_PRT("start venc failed. s32Ret: 0x%x !\n", s32Ret);
1268 goto EXIT3;
1269 }
1270
1271 s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(VpssGrp, VpssChn, VencChn[0]);
1272 if (s32Ret != HI_SUCCESS) {
1273 SAMPLE_PRT("vpss group %d bind venc chn %d failed. s32Ret: 0x%x !n", VpssGrp, VencChn[0], s32Ret);
1274 goto EXIT4;
1275 }
1276
1277 /* config vo */
1278 s32Ret = SAMPLE_COMM_VO_GetDefConfig(&stVoConfig);
1279 if (s32Ret != HI_SUCCESS) {
1280 SAMPLE_PRT("Get VO default config failed. s32Ret: 0x%x!n", s32Ret);
1281 goto EXIT5;
1282 }
1283 stVoConfig.enDstDynamicRange = enDynamicRange;
1284 if (u32VoIntfType == 1) {
1285 stVoConfig.enVoIntfType = VO_INTF_BT1120;
1286 stVoConfig.enIntfSync = VO_OUTPUT_1080P25;
1287 } else {
1288 stVoConfig.enVoIntfType = VO_INTF_HDMI;
1289 }
1290 stVoConfig.enPicSize = enPicSize;
1291
1292 /* start vo */
1293 s32Ret = SAMPLE_COMM_VO_StartVO(&stVoConfig);
1294 if (s32Ret != HI_SUCCESS) {
1295 SAMPLE_PRT("start vo failed. s32Ret: 0x%x !\n", s32Ret);
1296 goto EXIT5;
1297 }
1298
1299 /* vpss bind vo */
1300 s32Ret = SAMPLE_COMM_VPSS_Bind_VO(VpssGrp, VpssChn, stVoConfig.VoDev, VoChn);
1301 if (s32Ret != HI_SUCCESS) {
1302 SAMPLE_PRT("vpss group %d bind vo%d failed. s32Ret: 0x%x !\n", VpssGrp, stVoConfig.VoDev, s32Ret);
1303 goto EXIT6;
1304 }
1305
1306 s32Ret = SAMPLE_COMM_VENC_StartGetStream(VencChn, sizeof(VencChn) / sizeof(VENC_CHN));
1307 if (s32Ret != HI_SUCCESS) {
1308 SAMPLE_PRT("Get venc stream failed!\n");
1309 goto EXIT7;
1310 }
1311
1312 stLDCAttr.bEnable = HI_TRUE;
1313 stLDCAttr.stAttr.bAspect = 0;
1314 stLDCAttr.stAttr.s32XRatio = 100; /* x ratio: 100 */
1315 stLDCAttr.stAttr.s32YRatio = 100; /* y ratio: 100 */
1316 stLDCAttr.stAttr.s32XYRatio = 100; /* z ratio: 100 */
1317 stLDCAttr.stAttr.s32CenterXOffset = 0;
1318 stLDCAttr.stAttr.s32CenterYOffset = 0;
1319 stLDCAttr.stAttr.s32DistortionRatio = 500; /* distortion ratio: 500 */
1320 s32Ret = HI_MPI_VI_SetChnLDCAttr(ViPipe, ViChn, &stLDCAttr);
1321 if (s32Ret != HI_SUCCESS) {
1322 SAMPLE_PRT("HI_MPI_VI_SetChnLDCAttr failed witfh %d\n", s32Ret);
1323 goto EXIT8;
1324 }
1325
1326 SAMPLE_PRT("Press Enter key to Enable LowDelay!\n");
1327 (HI_VOID)getchar();
1328
1329 stLowDelayInfo.bEnable = HI_TRUE;
1330 stLowDelayInfo.u32LineCnt = stSize.u32Height / 2; /* line count: 1/2 of height */
1331 HI_MPI_VI_SetChnLowDelayAttr(ViPipe, ViChn, &stLowDelayInfo);
1332 if (s32Ret != HI_SUCCESS) {
1333 SAMPLE_PRT("HI_MPI_VI_SetChnLowDelayAttr failed witfh %d\n", s32Ret);
1334 goto EXIT8;
1335 }
1336
1337 SAMPLE_VIO_GetChar();
1338
1339 EXIT8:
1340 SAMPLE_COMM_VENC_StopGetStream();
1341 EXIT7:
1342 SAMPLE_COMM_VPSS_UnBind_VO(VpssGrp, VpssChn, stVoConfig.VoDev, VoChn);
1343 EXIT6:
1344 SAMPLE_COMM_VO_StopVO(&stVoConfig);
1345 EXIT5:
1346 SAMPLE_COMM_VPSS_UnBind_VENC(VpssGrp, VpssChn, VencChn[0]);
1347 EXIT4:
1348 SAMPLE_COMM_VENC_Stop(VencChn[0]);
1349 EXIT3:
1350 SAMPLE_COMM_VI_UnBind_VPSS(ViPipe, ViChn, VpssGrp);
1351 EXIT2:
1352 SAMPLE_COMM_VPSS_Stop(VpssGrp, abChnEnable);
1353 EXIT1:
1354 SAMPLE_COMM_VI_StopVi(&stViConfig);
1355 EXIT:
1356 SAMPLE_COMM_SYS_Exit();
1357 return s32Ret;
1358 }
1359
SAMPLE_VIO_Rotate(HI_U32 u32VoIntfType)1360 HI_S32 SAMPLE_VIO_Rotate(HI_U32 u32VoIntfType)
1361 {
1362 HI_S32 s32Ret = HI_SUCCESS;
1363 HI_S32 s32ViCnt = 1;
1364 VI_DEV ViDev = 0;
1365 VI_PIPE ViPipe = 0;
1366 VI_CHN ViChn = 0;
1367 HI_S32 s32WorkSnsId = 0;
1368 SAMPLE_VI_CONFIG_S stViConfig;
1369 VI_ROTATION_EX_ATTR_S stViRotationExAttr;
1370 SIZE_S stSize;
1371 VB_CONFIG_S stVbConf;
1372 PIC_SIZE_E enPicSize;
1373 HI_U32 u32BlkSize;
1374 VO_CHN VoChn = 0;
1375 SAMPLE_VO_CONFIG_S stVoConfig;
1376
1377 WDR_MODE_E enWDRMode = WDR_MODE_NONE;
1378 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
1379 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
1380 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
1381 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
1382 VI_VPSS_MODE_E enMastPipeMode = VI_OFFLINE_VPSS_OFFLINE;
1383
1384 (hi_void)memset_s(&stViConfig, sizeof(stViConfig), 0, sizeof(stViConfig));
1385 /* config vi */
1386 SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
1387
1388 stViConfig.s32WorkingViNum = s32ViCnt;
1389 stViConfig.as32WorkingViId[0] = 0;
1390 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.MipiDev = ViDev;
1391 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.s32BusId = 0;
1392 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.ViDev = ViDev;
1393 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = enWDRMode;
1394 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.enMastPipeMode = enMastPipeMode;
1395 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[0] = ViPipe;
1396 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[1] = -1; /* index: 1 */
1397 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[2] = -1; /* index: 2 */
1398 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[3] = -1; /* index: 3 */
1399 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.ViChn = ViChn;
1400 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enPixFormat = enPixFormat;
1401 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enDynamicRange = enDynamicRange;
1402 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enVideoFormat = enVideoFormat;
1403 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enCompressMode = enCompressMode;
1404
1405 /* get picture size */
1406 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType, &enPicSize);
1407 if (s32Ret != HI_SUCCESS) {
1408 SAMPLE_PRT("get picture size by sensor failed!\n");
1409 return s32Ret;
1410 }
1411
1412 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &stSize);
1413 if (s32Ret != HI_SUCCESS) {
1414 SAMPLE_PRT("get picture size failed!\n");
1415 return s32Ret;
1416 }
1417
1418 /* config vb */
1419 (hi_void)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
1420 stVbConf.u32MaxPoolCnt = 2; /* max pool count: 2 */
1421
1422 u32BlkSize = VI_GetRawBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
1423 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
1424 stVbConf.astCommPool[0].u64BlkSize = u32BlkSize;
1425 stVbConf.astCommPool[0].u32BlkCnt = 10; /* vb block count: 10 */
1426
1427 u32BlkSize = VI_GetRawBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
1428 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
1429 stVbConf.astCommPool[1].u64BlkSize = u32BlkSize;
1430 stVbConf.astCommPool[1].u32BlkCnt = 4; /* vb block count: 4 */
1431
1432 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
1433 if (s32Ret != HI_SUCCESS) {
1434 SAMPLE_PRT("system init failed with %d!\n", s32Ret);
1435 return s32Ret;
1436 }
1437
1438 /* start vi */
1439 s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
1440 if (s32Ret != HI_SUCCESS) {
1441 SAMPLE_PRT("start vi failed.s32Ret:0x%x !\n", s32Ret);
1442 goto EXIT;
1443 }
1444
1445 /* config vo */
1446 s32Ret = SAMPLE_COMM_VO_GetDefConfig(&stVoConfig);
1447 if (s32Ret != HI_SUCCESS) {
1448 SAMPLE_PRT("Get VO default config failed. s32Ret: 0x%x!n", s32Ret);
1449 goto EXIT1;
1450 }
1451 stVoConfig.enDstDynamicRange = enDynamicRange;
1452 if (u32VoIntfType == 1) {
1453 stVoConfig.enVoIntfType = VO_INTF_BT1120;
1454 stVoConfig.enIntfSync = VO_OUTPUT_1080P25;
1455 } else {
1456 stVoConfig.enVoIntfType = VO_INTF_HDMI;
1457 }
1458 stVoConfig.enPicSize = enPicSize;
1459
1460 /* start vo */
1461 s32Ret = SAMPLE_COMM_VO_StartVO(&stVoConfig);
1462 if (s32Ret != HI_SUCCESS) {
1463 SAMPLE_PRT("start vo failed. s32Ret: 0x%x !\n", s32Ret);
1464 goto EXIT1;
1465 }
1466
1467 /* vi bind vo */
1468 s32Ret = SAMPLE_COMM_VI_Bind_VO(ViPipe, ViChn, stVoConfig.VoDev, VoChn);
1469 if (s32Ret != HI_SUCCESS) {
1470 SAMPLE_PRT("vi pipe %d bind vo%d failed. s32Ret: 0x%x !\n", ViPipe, stVoConfig.VoDev, s32Ret);
1471 goto EXIT2;
1472 }
1473
1474 SAMPLE_PRT("Press Enter key to switch Rotation 90!\n");
1475 (HI_VOID)getchar();
1476
1477 s32Ret = HI_MPI_VI_SetChnRotation(ViPipe, ViChn, ROTATION_90);
1478 if (s32Ret != HI_SUCCESS) {
1479 SAMPLE_PRT("HI_MPI_VI_SetChnRotation failed with %d\n", s32Ret);
1480 goto EXIT3;
1481 }
1482
1483 SAMPLE_PRT("Press Enter key to switch Rotation 180!\n");
1484 (HI_VOID)getchar();
1485
1486 s32Ret = HI_MPI_VI_SetChnRotation(ViPipe, ViChn, ROTATION_180);
1487 if (s32Ret != HI_SUCCESS) {
1488 SAMPLE_PRT("HI_MPI_VI_SetChnRotation failed with %d\n", s32Ret);
1489 goto EXIT3;
1490 }
1491
1492 SAMPLE_PRT("Press Enter key to switch Rotation 270!\n");
1493 (HI_VOID)getchar();
1494
1495 s32Ret = HI_MPI_VI_SetChnRotation(ViPipe, ViChn, ROTATION_270);
1496 if (s32Ret != HI_SUCCESS) {
1497 SAMPLE_PRT("HI_MPI_VI_SetChnRotation failed witfh %d\n", s32Ret);
1498 goto EXIT3;
1499 }
1500
1501 SAMPLE_PRT("Press Enter key to switch Rotation 0!\n");
1502 (HI_VOID)getchar();
1503
1504 s32Ret = HI_MPI_VI_SetChnRotation(ViPipe, ViChn, ROTATION_0);
1505 if (s32Ret != HI_SUCCESS) {
1506 SAMPLE_PRT("HI_MPI_VI_SetChnRotation failed with %d\n", s32Ret);
1507 goto EXIT3;
1508 }
1509
1510 SAMPLE_PRT("Press Enter key to switch RotateEx 60!\n");
1511 (HI_VOID)getchar();
1512 stViRotationExAttr.bEnable = HI_TRUE;
1513 stViRotationExAttr.stRotationEx.enViewType = ROTATION_VIEW_TYPE_ALL;
1514 stViRotationExAttr.stRotationEx.u32Angle = 60; /* angle: 60 */
1515 stViRotationExAttr.stRotationEx.s32CenterXOffset = 0;
1516 stViRotationExAttr.stRotationEx.s32CenterYOffset = 0;
1517 stViRotationExAttr.stRotationEx.stDestSize.u32Width = stSize.u32Width;
1518 stViRotationExAttr.stRotationEx.stDestSize.u32Height = stSize.u32Height;
1519 s32Ret = HI_MPI_VI_SetChnRotationEx(ViPipe, ViChn, &stViRotationExAttr);
1520 if (s32Ret != HI_SUCCESS) {
1521 SAMPLE_PRT("HI_MPI_VI_SetChnRotationEx failed with %d\n", s32Ret);
1522 goto EXIT3;
1523 }
1524
1525 SAMPLE_PRT("Enter any key to Disable RotateEx!!\n");
1526 (HI_VOID)getchar();
1527 stViRotationExAttr.bEnable = HI_FALSE;
1528 s32Ret = HI_MPI_VI_SetChnRotationEx(ViPipe, ViChn, &stViRotationExAttr);
1529 if (s32Ret != HI_SUCCESS) {
1530 SAMPLE_PRT("HI_MPI_VI_SetChnRotationEx failed with %d\n", s32Ret);
1531 goto EXIT3;
1532 }
1533
1534 SAMPLE_VIO_GetChar();
1535
1536 EXIT3:
1537 SAMPLE_COMM_VI_UnBind_VO(ViPipe, ViChn, stVoConfig.VoDev, VoChn);
1538 EXIT2:
1539 SAMPLE_COMM_VO_StopVO(&stVoConfig);
1540 EXIT1:
1541 SAMPLE_COMM_VI_StopVi(&stViConfig);
1542 EXIT:
1543 SAMPLE_COMM_SYS_Exit();
1544 return s32Ret;
1545 }
1546
SAMPLE_VIO_FPN(HI_U32 u32VoIntfType)1547 HI_S32 SAMPLE_VIO_FPN(HI_U32 u32VoIntfType)
1548 {
1549 HI_S32 s32Ret = HI_SUCCESS;
1550 HI_S32 s32ViCnt = 1;
1551 VI_DEV ViDev = 0;
1552 VI_PIPE ViPipe = 0;
1553 VI_CHN ViChn = 0;
1554 HI_S32 s32WorkSnsId = 0;
1555 SAMPLE_VI_CONFIG_S stViConfig;
1556 SIZE_S stSize;
1557 VB_CONFIG_S stVbConf;
1558 PIC_SIZE_E enPicSize;
1559 HI_U32 u32BlkSize;
1560 VO_CHN VoChn = 0;
1561 SAMPLE_VO_CONFIG_S stVoConfig;
1562 WDR_MODE_E enWDRMode = WDR_MODE_NONE;
1563 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
1564 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
1565 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
1566 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
1567 VI_VPSS_MODE_E enMastPipeMode = VI_ONLINE_VPSS_OFFLINE;
1568 SAMPLE_VI_FPN_CALIBRATE_INFO_S stViFpnCalibrateInfo;
1569 SAMPLE_VI_FPN_CORRECTION_INFO_S stViFpnCorrectionInfo;
1570
1571 (hi_void)memset_s(&stViConfig, sizeof(stViConfig), 0, sizeof(stViConfig));
1572
1573 /* config vi */
1574 SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
1575
1576 stViConfig.s32WorkingViNum = s32ViCnt;
1577 stViConfig.as32WorkingViId[0] = 0;
1578 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.MipiDev = ViDev;
1579 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.s32BusId = 0;
1580 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.ViDev = ViDev;
1581 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = enWDRMode;
1582 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.enMastPipeMode = enMastPipeMode;
1583 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[0] = ViPipe;
1584 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[1] = -1; /* index: 1 */
1585 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[2] = -1; /* index: 2 */
1586 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[3] = -1; /* index: 3 */
1587 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.ViChn = ViChn;
1588 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enPixFormat = enPixFormat;
1589 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enDynamicRange = enDynamicRange;
1590 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enVideoFormat = enVideoFormat;
1591 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enCompressMode = enCompressMode;
1592
1593 /* get picture size */
1594 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType, &enPicSize);
1595 if (s32Ret != HI_SUCCESS) {
1596 SAMPLE_PRT("get picture size by sensor failed!\n");
1597 return s32Ret;
1598 }
1599
1600 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &stSize);
1601 if (s32Ret != HI_SUCCESS) {
1602 SAMPLE_PRT("get picture size failed!\n");
1603 return s32Ret;
1604 }
1605
1606 /* config vb */
1607 (hi_void)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
1608 stVbConf.u32MaxPoolCnt = 2; /* max pool count: 2 */
1609
1610 u32BlkSize = COMMON_GetPicBufferSize(stSize.u32Width, stSize.u32Height, SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8,
1611 COMPRESS_MODE_SEG, DEFAULT_ALIGN);
1612 stVbConf.astCommPool[0].u64BlkSize = u32BlkSize;
1613 stVbConf.astCommPool[0].u32BlkCnt = 10; /* vb block count: 10 */
1614
1615 u32BlkSize = VI_GetRawBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
1616 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
1617 stVbConf.astCommPool[1].u64BlkSize = u32BlkSize;
1618 stVbConf.astCommPool[1].u32BlkCnt = 4; /* vb block count: 4 */
1619
1620 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
1621 if (s32Ret != HI_SUCCESS) {
1622 SAMPLE_PRT("system init failed with %d!\n", s32Ret);
1623 return s32Ret;
1624 }
1625
1626 /* start vi */
1627 s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
1628 if (s32Ret != HI_SUCCESS) {
1629 SAMPLE_PRT("start vi failed.s32Ret:0x%x !\n", s32Ret);
1630 goto EXIT;
1631 }
1632
1633 /* config vo */
1634 s32Ret = SAMPLE_COMM_VO_GetDefConfig(&stVoConfig);
1635 if (s32Ret != HI_SUCCESS) {
1636 SAMPLE_PRT("Get VO default config failed. s32Ret: 0x%x!n", s32Ret);
1637 goto EXIT1;
1638 }
1639 stVoConfig.enDstDynamicRange = enDynamicRange;
1640 if (u32VoIntfType == 1) {
1641 stVoConfig.enVoIntfType = VO_INTF_BT1120;
1642 stVoConfig.enIntfSync = VO_OUTPUT_1080P25;
1643 } else {
1644 stVoConfig.enVoIntfType = VO_INTF_HDMI;
1645 }
1646 stVoConfig.enPicSize = enPicSize;
1647
1648 /* start vo */
1649 s32Ret = SAMPLE_COMM_VO_StartVO(&stVoConfig);
1650 if (s32Ret != HI_SUCCESS) {
1651 SAMPLE_PRT("start vo failed. s32Ret: 0x%x !\n", s32Ret);
1652 goto EXIT1;
1653 }
1654
1655 /* vi bind vo */
1656 s32Ret = SAMPLE_COMM_VI_Bind_VO(ViPipe, ViChn, stVoConfig.VoDev, VoChn);
1657 if (s32Ret != HI_SUCCESS) {
1658 SAMPLE_PRT("vi pipe %d bind vo%d failed. s32Ret: 0x%x !\n", ViPipe, stVoConfig.VoDev, s32Ret);
1659 goto EXIT2;
1660 }
1661
1662 stViFpnCalibrateInfo.u32Threshold = 4095; /* threshold : 4095 */
1663 stViFpnCalibrateInfo.u32FrameNum = 16; /* frame num: 16 */
1664 stViFpnCalibrateInfo.enFpnType = ISP_FPN_TYPE_FRAME;
1665 stViFpnCalibrateInfo.enPixelFormat = PIXEL_FORMAT_RGB_BAYER_16BPP;
1666 stViFpnCalibrateInfo.enCompressMode = COMPRESS_MODE_NONE;
1667
1668 s32Ret = SAMPLE_COMM_VI_FpnCalibrateConfig(ViPipe, &stViFpnCalibrateInfo);
1669 if (s32Ret != HI_SUCCESS) {
1670 SAMPLE_PRT("ViPipe%d FPN Calibrate failed. s32Ret: 0x%x !\n", ViPipe, s32Ret);
1671 goto EXIT3;
1672 }
1673
1674 SAMPLE_PRT("Press Enter key to FPN correction!\n");
1675 (HI_VOID)getchar();
1676
1677 stViFpnCorrectionInfo.enOpType = OP_TYPE_AUTO;
1678 stViFpnCorrectionInfo.enFpnType = stViFpnCalibrateInfo.enFpnType;
1679 stViFpnCorrectionInfo.u32Strength = 0;
1680 stViFpnCorrectionInfo.enPixelFormat = stViFpnCalibrateInfo.enPixelFormat;
1681 stViFpnCorrectionInfo.enCompressMode = stViFpnCalibrateInfo.enCompressMode;
1682
1683 s32Ret = SAMPLE_COMM_VI_FpnCorrectionConfig(ViPipe, &stViFpnCorrectionInfo);
1684 if (s32Ret != HI_SUCCESS) {
1685 SAMPLE_PRT("ViPipe%d FPN Correct failed. s32Ret: 0x%x !\n", ViPipe, s32Ret);
1686 goto EXIT3;
1687 }
1688
1689 SAMPLE_VIO_GetChar();
1690
1691 SAMPLE_COMM_VI_DisableFpnCorrection(ViPipe, &stViFpnCorrectionInfo);
1692 EXIT3:
1693 SAMPLE_COMM_VI_UnBind_VO(ViPipe, ViChn, stVoConfig.VoDev, VoChn);
1694 EXIT2:
1695 SAMPLE_COMM_VO_StopVO(&stVoConfig);
1696 EXIT1:
1697 SAMPLE_COMM_VI_StopVi(&stViConfig);
1698 EXIT:
1699 SAMPLE_COMM_SYS_Exit();
1700 return s32Ret;
1701 }
1702
SAMPLE_VIO_ViDoubleWdrPipe(HI_U32 u32VoIntfType)1703 HI_S32 SAMPLE_VIO_ViDoubleWdrPipe(HI_U32 u32VoIntfType)
1704 {
1705 HI_S32 s32Ret;
1706
1707 HI_S32 s32ViCnt = 2;
1708 VI_DEV ViDev[2] = {0, 1};
1709 VI_PIPE ViPipe[4] = {0, 1, 2, 3};
1710 VI_CHN ViChn = 0;
1711 SAMPLE_VI_CONFIG_S stViConfig;
1712
1713 SIZE_S stSize;
1714 VB_CONFIG_S stVbConf;
1715 PIC_SIZE_E enPicSize;
1716 HI_U32 u32BlkSize;
1717
1718 VO_CHN VoChn = 0;
1719 SAMPLE_VO_CONFIG_S stVoConfig;
1720
1721 WDR_MODE_E enWDRMode = WDR_MODE_2To1_LINE;
1722 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
1723 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
1724 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
1725 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
1726
1727 VPSS_GRP VpssGrp[2] = {0, 1};
1728 VPSS_GRP_ATTR_S stVpssGrpAttr;
1729 VPSS_CHN VpssChn = VPSS_CHN0;
1730 HI_BOOL abChnEnable[VPSS_MAX_PHY_CHN_NUM] = {0};
1731 VPSS_CHN_ATTR_S astVpssChnAttr[VPSS_MAX_PHY_CHN_NUM];
1732
1733 (hi_void)memset_s(&stViConfig, sizeof(stViConfig), 0, sizeof(stViConfig));
1734
1735 /* config vi */
1736 SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
1737
1738 stViConfig.s32WorkingViNum = s32ViCnt;
1739 stViConfig.as32WorkingViId[0] = 0;
1740 stViConfig.as32WorkingViId[1] = 1;
1741 stViConfig.astViInfo[0].stSnsInfo.MipiDev = ViDev[0];
1742 stViConfig.astViInfo[0].stSnsInfo.s32BusId = 0;
1743 stViConfig.astViInfo[0].stDevInfo.ViDev = ViDev[0];
1744 stViConfig.astViInfo[0].stDevInfo.enWDRMode = enWDRMode;
1745 stViConfig.astViInfo[0].stPipeInfo.enMastPipeMode = VI_OFFLINE_VPSS_OFFLINE;
1746 stViConfig.astViInfo[0].stPipeInfo.aPipe[0] = ViPipe[0];
1747 stViConfig.astViInfo[0].stPipeInfo.aPipe[1] = ViPipe[1]; /* index: 1 */
1748 stViConfig.astViInfo[0].stPipeInfo.aPipe[2] = -1; /* index: 2 */
1749 stViConfig.astViInfo[0].stPipeInfo.aPipe[3] = -1; /* index: 3 */
1750 stViConfig.astViInfo[0].stChnInfo.ViChn = ViChn;
1751 stViConfig.astViInfo[0].stChnInfo.enPixFormat = enPixFormat;
1752 stViConfig.astViInfo[0].stChnInfo.enDynamicRange = enDynamicRange;
1753 stViConfig.astViInfo[0].stChnInfo.enVideoFormat = enVideoFormat;
1754 stViConfig.astViInfo[0].stChnInfo.enCompressMode = enCompressMode;
1755
1756 stViConfig.astViInfo[1].stSnsInfo.MipiDev = ViDev[1];
1757 stViConfig.astViInfo[1].stSnsInfo.s32BusId = 1;
1758 stViConfig.astViInfo[1].stDevInfo.ViDev = ViDev[1];
1759 stViConfig.astViInfo[1].stDevInfo.enWDRMode = enWDRMode;
1760 stViConfig.astViInfo[1].stPipeInfo.enMastPipeMode = VI_OFFLINE_VPSS_OFFLINE;
1761 stViConfig.astViInfo[1].stPipeInfo.aPipe[0] = ViPipe[2]; /* vi pipe index: 2 */
1762 stViConfig.astViInfo[1].stPipeInfo.aPipe[1] = ViPipe[3]; /* vi pipe index: 3 */
1763 stViConfig.astViInfo[1].stPipeInfo.aPipe[2] = -1; /* index: 2 */
1764 stViConfig.astViInfo[1].stPipeInfo.aPipe[3] = -1; /* index: 3 */
1765 stViConfig.astViInfo[1].stChnInfo.ViChn = ViChn;
1766 stViConfig.astViInfo[1].stChnInfo.enPixFormat = enPixFormat;
1767 stViConfig.astViInfo[1].stChnInfo.enDynamicRange = enDynamicRange;
1768 stViConfig.astViInfo[1].stChnInfo.enVideoFormat = enVideoFormat;
1769 stViConfig.astViInfo[1].stChnInfo.enCompressMode = enCompressMode;
1770
1771 if ((stViConfig.astViInfo[0].stSnsInfo.enSnsType != SONY_IMX327_2L_MIPI_2M_30FPS_12BIT_WDR2TO1) &&
1772 (stViConfig.astViInfo[0].stSnsInfo.enSnsType != SONY_IMX307_2L_MIPI_2M_30FPS_12BIT_WDR2TO1) &&
1773 (stViConfig.astViInfo[0].stSnsInfo.enSnsType != OMNIVISION_OV2775_2L_MIPI_2M_30FPS_12BIT_WDR2TO1)) {
1774 SAMPLE_PRT("Not Support!\n");
1775 return HI_SUCCESS;
1776 }
1777
1778 /* get picture size */
1779 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(stViConfig.astViInfo[0].stSnsInfo.enSnsType, &enPicSize);
1780 if (s32Ret != HI_SUCCESS) {
1781 SAMPLE_PRT("get picture size by sensor failed!\n");
1782 return s32Ret;
1783 }
1784
1785 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &stSize);
1786 if (s32Ret != HI_SUCCESS) {
1787 SAMPLE_PRT("get picture size failed!\n");
1788 return s32Ret;
1789 }
1790
1791 /* config vb */
1792 (hi_void)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
1793 stVbConf.u32MaxPoolCnt = 2; /* max pool count: 2 */
1794
1795 u32BlkSize = COMMON_GetPicBufferSize(stSize.u32Width, stSize.u32Height, SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8,
1796 COMPRESS_MODE_SEG, DEFAULT_ALIGN);
1797 stVbConf.astCommPool[0].u64BlkSize = u32BlkSize;
1798 stVbConf.astCommPool[0].u32BlkCnt = 20; /* vb block count: 20 */
1799
1800 u32BlkSize = VI_GetRawBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
1801 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
1802 stVbConf.astCommPool[1].u64BlkSize = u32BlkSize;
1803 stVbConf.astCommPool[1].u32BlkCnt = 4; /* vb block count: 4 */
1804
1805 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
1806 if (s32Ret != HI_SUCCESS) {
1807 SAMPLE_PRT("system init failed with %d!\n", s32Ret);
1808 return s32Ret;
1809 }
1810
1811 /* start vi */
1812 s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
1813 if (s32Ret != HI_SUCCESS) {
1814 SAMPLE_PRT("start vi failed.s32Ret:0x%x !\n", s32Ret);
1815 goto EXIT;
1816 }
1817
1818 /* config vpss */
1819 (hi_void)memset_s(&stVpssGrpAttr, sizeof(VPSS_GRP_ATTR_S), 0, sizeof(VPSS_GRP_ATTR_S));
1820 stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
1821 stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;
1822 stVpssGrpAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
1823 stVpssGrpAttr.enPixelFormat = enPixFormat;
1824 stVpssGrpAttr.u32MaxW = stSize.u32Width;
1825 stVpssGrpAttr.u32MaxH = stSize.u32Height;
1826 stVpssGrpAttr.bNrEn = HI_TRUE;
1827 stVpssGrpAttr.stNrAttr.enCompressMode = COMPRESS_MODE_FRAME;
1828 stVpssGrpAttr.stNrAttr.enNrMotionMode = NR_MOTION_MODE_NORMAL;
1829
1830 astVpssChnAttr[VpssChn].u32Width = stSize.u32Width;
1831 astVpssChnAttr[VpssChn].u32Height = stSize.u32Height;
1832 astVpssChnAttr[VpssChn].enChnMode = VPSS_CHN_MODE_USER;
1833 astVpssChnAttr[VpssChn].enCompressMode = enCompressMode;
1834 astVpssChnAttr[VpssChn].enDynamicRange = enDynamicRange;
1835 astVpssChnAttr[VpssChn].enVideoFormat = enVideoFormat;
1836 astVpssChnAttr[VpssChn].enPixelFormat = enPixFormat;
1837 astVpssChnAttr[VpssChn].stFrameRate.s32SrcFrameRate = FPS_30;
1838 astVpssChnAttr[VpssChn].stFrameRate.s32DstFrameRate = FPS_30;
1839 astVpssChnAttr[VpssChn].u32Depth = 0;
1840 astVpssChnAttr[VpssChn].bMirror = HI_FALSE;
1841 astVpssChnAttr[VpssChn].bFlip = HI_FALSE;
1842 astVpssChnAttr[VpssChn].stAspectRatio.enMode = ASPECT_RATIO_NONE;
1843
1844 /* start vpss */
1845 abChnEnable[0] = HI_TRUE;
1846 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp[0], abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
1847 if (s32Ret != HI_SUCCESS) {
1848 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
1849 goto EXIT1;
1850 }
1851
1852 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp[1], abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
1853 if (s32Ret != HI_SUCCESS) {
1854 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
1855 goto EXIT2;
1856 }
1857
1858 /* vi bind vpss */
1859 s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe[0], ViChn, VpssGrp[0]);
1860 if (s32Ret != HI_SUCCESS) {
1861 SAMPLE_PRT("vi bind vpss failed. s32Ret: 0x%x !\n", s32Ret);
1862 goto EXIT3;
1863 }
1864
1865 s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe[2], ViChn, VpssGrp[1]); /* vi pipe index: 2 */
1866 if (s32Ret != HI_SUCCESS) {
1867 SAMPLE_PRT("vi bind vpss failed. s32Ret: 0x%x !\n", s32Ret);
1868 goto EXIT4;
1869 }
1870
1871 /* config vo */
1872 s32Ret = SAMPLE_COMM_VO_GetDefConfig(&stVoConfig);
1873 if (s32Ret != HI_SUCCESS) {
1874 SAMPLE_PRT("Get VO default config failed. s32Ret: 0x%x!n", s32Ret);
1875 goto EXIT5;
1876 }
1877 stVoConfig.enDstDynamicRange = enDynamicRange;
1878 if (u32VoIntfType == 1) {
1879 stVoConfig.enVoIntfType = VO_INTF_BT1120;
1880 } else {
1881 stVoConfig.enVoIntfType = VO_INTF_HDMI;
1882 }
1883 stVoConfig.enPicSize = enPicSize;
1884
1885 /* start vo */
1886 s32Ret = SAMPLE_COMM_VO_StartVO(&stVoConfig);
1887 if (s32Ret != HI_SUCCESS) {
1888 SAMPLE_PRT("start vo failed. s32Ret: 0x%x !\n", s32Ret);
1889 goto EXIT5;
1890 }
1891
1892 /* vpss bind vo */
1893 s32Ret = SAMPLE_COMM_VPSS_Bind_VO(VpssGrp[0], VpssChn, stVoConfig.VoDev, VoChn);
1894 if (s32Ret != HI_SUCCESS) {
1895 SAMPLE_PRT("vpss group %d bind vo%d failed. s32Ret: 0x%x !\n", VpssGrp[0], stVoConfig.VoDev, s32Ret);
1896 goto EXIT6;
1897 }
1898
1899 SAMPLE_VIO_GetChar();
1900
1901 SAMPLE_COMM_VPSS_UnBind_VO(VpssGrp[0], VpssChn, stVoConfig.VoDev, VoChn);
1902
1903 EXIT6:
1904 SAMPLE_COMM_VO_StopVO(&stVoConfig);
1905 EXIT5:
1906 SAMPLE_COMM_VI_UnBind_VPSS(ViPipe[2], ViChn, VpssGrp[1]); /* vi pipe index: 2 */
1907 EXIT4:
1908 SAMPLE_COMM_VI_UnBind_VPSS(ViPipe[0], ViChn, VpssGrp[0]);
1909 EXIT3:
1910 SAMPLE_COMM_VPSS_Stop(VpssGrp[1], abChnEnable);
1911 EXIT2:
1912 SAMPLE_COMM_VPSS_Stop(VpssGrp[0], abChnEnable);
1913 EXIT1:
1914 SAMPLE_COMM_VI_StopVi(&stViConfig);
1915 EXIT:
1916 SAMPLE_COMM_SYS_Exit();
1917 return s32Ret;
1918 }
1919
SAMPLE_VIO_VPSS_VO_MIPI_TX(HI_VOID)1920 HI_S32 SAMPLE_VIO_VPSS_VO_MIPI_TX(HI_VOID)
1921 {
1922 HI_S32 s32Ret = HI_SUCCESS;
1923 HI_S32 s32ViCnt = 1;
1924 VI_DEV ViDev = 0;
1925 VI_PIPE ViPipe = 0;
1926 VI_CHN ViChn = 0;
1927 HI_S32 s32WorkSnsId = 0;
1928 SAMPLE_VI_CONFIG_S stViConfig;
1929 SIZE_S stSize;
1930 VB_CONFIG_S stVbConf;
1931 PIC_SIZE_E enPicSize;
1932 HI_U32 u32BlkSize;
1933 VO_CHN VoChn = 0;
1934 SAMPLE_VO_CONFIG_S stVoConfig;
1935 WDR_MODE_E enWDRMode = WDR_MODE_NONE;
1936 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
1937 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
1938 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
1939 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
1940 VI_VPSS_MODE_E enMastPipeMode = VI_ONLINE_VPSS_OFFLINE;
1941 VPSS_GRP VpssGrp = 0;
1942 VPSS_GRP_ATTR_S stVpssGrpAttr;
1943 VPSS_CHN VpssChn = VPSS_CHN0;
1944 HI_BOOL abChnEnable[VPSS_MAX_PHY_CHN_NUM] = {0};
1945 VPSS_CHN_ATTR_S astVpssChnAttr[VPSS_MAX_PHY_CHN_NUM];
1946
1947 (hi_void)memset_s(&stViConfig, sizeof(stViConfig), 0, sizeof(stViConfig));
1948 /* config vi */
1949 SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
1950
1951 stViConfig.s32WorkingViNum = s32ViCnt;
1952 stViConfig.as32WorkingViId[0] = 0;
1953 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.MipiDev = ViDev;
1954 stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.s32BusId = 0;
1955 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.ViDev = ViDev;
1956 stViConfig.astViInfo[s32WorkSnsId].stDevInfo.enWDRMode = enWDRMode;
1957 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.enMastPipeMode = enMastPipeMode;
1958 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[0] = ViPipe;
1959 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[1] = -1; /* index: 1 */
1960 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[2] = -1; /* index: 2 */
1961 stViConfig.astViInfo[s32WorkSnsId].stPipeInfo.aPipe[3] = -1; /* index: 3 */
1962 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.ViChn = ViChn;
1963 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enPixFormat = enPixFormat;
1964 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enDynamicRange = enDynamicRange;
1965 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enVideoFormat = enVideoFormat;
1966 stViConfig.astViInfo[s32WorkSnsId].stChnInfo.enCompressMode = enCompressMode;
1967
1968 /* get picture size */
1969 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(stViConfig.astViInfo[s32WorkSnsId].stSnsInfo.enSnsType, &enPicSize);
1970 if (s32Ret != HI_SUCCESS) {
1971 SAMPLE_PRT("get picture size by sensor failed!\n");
1972 return s32Ret;
1973 }
1974
1975 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enPicSize, &stSize);
1976 if (s32Ret != HI_SUCCESS) {
1977 SAMPLE_PRT("get picture size failed!\n");
1978 return s32Ret;
1979 }
1980
1981 /* config vb */
1982 (hi_void)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
1983 stVbConf.u32MaxPoolCnt = 2; /* max pool count: 2 */
1984
1985 u32BlkSize = COMMON_GetPicBufferSize(stSize.u32Width, stSize.u32Height, SAMPLE_PIXEL_FORMAT, DATA_BITWIDTH_8,
1986 COMPRESS_MODE_SEG, DEFAULT_ALIGN);
1987 stVbConf.astCommPool[0].u64BlkSize = u32BlkSize;
1988 stVbConf.astCommPool[0].u32BlkCnt = 10; /* vb block count: 10 */
1989
1990 u32BlkSize = VI_GetRawBufferSize(stSize.u32Width, stSize.u32Height, PIXEL_FORMAT_RGB_BAYER_16BPP,
1991 COMPRESS_MODE_NONE, DEFAULT_ALIGN);
1992 stVbConf.astCommPool[1].u64BlkSize = u32BlkSize;
1993 stVbConf.astCommPool[1].u32BlkCnt = 4; /* vb block count: 4 */
1994
1995 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
1996 if (s32Ret != HI_SUCCESS) {
1997 SAMPLE_PRT("system init failed with %d!\n", s32Ret);
1998 return s32Ret;
1999 }
2000
2001 /* start vi */
2002 s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
2003 if (s32Ret != HI_SUCCESS) {
2004 SAMPLE_PRT("start vi failed.s32Ret:0x%x !\n", s32Ret);
2005 goto EXIT;
2006 }
2007
2008 /* config vpss */
2009 (hi_void)memset_s(&stVpssGrpAttr, sizeof(VPSS_GRP_ATTR_S), 0, sizeof(VPSS_GRP_ATTR_S));
2010 stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
2011 stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;
2012 stVpssGrpAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
2013 stVpssGrpAttr.enPixelFormat = enPixFormat;
2014 stVpssGrpAttr.u32MaxW = stSize.u32Width;
2015 stVpssGrpAttr.u32MaxH = stSize.u32Height;
2016 stVpssGrpAttr.bNrEn = HI_TRUE;
2017 stVpssGrpAttr.stNrAttr.enCompressMode = COMPRESS_MODE_FRAME;
2018 stVpssGrpAttr.stNrAttr.enNrMotionMode = NR_MOTION_MODE_NORMAL;
2019
2020 astVpssChnAttr[VpssChn].u32Width = stSize.u32Width;
2021 astVpssChnAttr[VpssChn].u32Height = stSize.u32Height;
2022 astVpssChnAttr[VpssChn].enChnMode = VPSS_CHN_MODE_USER;
2023 astVpssChnAttr[VpssChn].enCompressMode = enCompressMode;
2024 astVpssChnAttr[VpssChn].enDynamicRange = enDynamicRange;
2025 astVpssChnAttr[VpssChn].enVideoFormat = enVideoFormat;
2026 astVpssChnAttr[VpssChn].enPixelFormat = enPixFormat;
2027 astVpssChnAttr[VpssChn].stFrameRate.s32SrcFrameRate = FPS_30;
2028 astVpssChnAttr[VpssChn].stFrameRate.s32DstFrameRate = FPS_30;
2029 astVpssChnAttr[VpssChn].u32Depth = 0;
2030 astVpssChnAttr[VpssChn].bMirror = HI_FALSE;
2031 astVpssChnAttr[VpssChn].bFlip = HI_FALSE;
2032 astVpssChnAttr[VpssChn].stAspectRatio.enMode = ASPECT_RATIO_NONE;
2033
2034 /* start vpss */
2035 abChnEnable[0] = HI_TRUE;
2036 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, abChnEnable, &stVpssGrpAttr, astVpssChnAttr);
2037 if (s32Ret != HI_SUCCESS) {
2038 SAMPLE_PRT("start vpss group failed. s32Ret: 0x%x !\n", s32Ret);
2039 goto EXIT1;
2040 }
2041
2042 /* vpss bind vo */
2043 s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe, ViChn, VpssGrp);
2044 if (s32Ret != HI_SUCCESS) {
2045 SAMPLE_PRT("vpss bind vi failed. s32Ret: 0x%x !\n", s32Ret);
2046 goto EXIT2;
2047 }
2048
2049 /* config vo */
2050 s32Ret = SAMPLE_COMM_VO_GetDefConfig(&stVoConfig);
2051 if (s32Ret != HI_SUCCESS) {
2052 SAMPLE_PRT("Get VO default config failed. s32Ret: 0x%x!n", s32Ret);
2053 goto EXIT3;
2054 }
2055 stVoConfig.enDstDynamicRange = enDynamicRange;
2056
2057 stVoConfig.enVoIntfType = VO_INTF_MIPI;
2058 stVoConfig.enIntfSync = VO_OUTPUT_1080x1920_60;
2059
2060 stVoConfig.enPicSize = enPicSize;
2061
2062 /* start vo */
2063 s32Ret = SAMPLE_COMM_VO_StartVO(&stVoConfig);
2064 if (s32Ret != HI_SUCCESS) {
2065 SAMPLE_PRT("start vo failed. s32Ret: 0x%x !\n", s32Ret);
2066 goto EXIT3;
2067 }
2068
2069 /* vpss bind vo */
2070 s32Ret = SAMPLE_COMM_VPSS_Bind_VO(VpssGrp, VpssChn, stVoConfig.VoDev, VoChn);
2071 if (s32Ret != HI_SUCCESS) {
2072 SAMPLE_PRT("vpss group %d bind vo%d failed. s32Ret: 0x%x !\n", VpssGrp, stVoConfig.VoDev, s32Ret);
2073 goto EXIT4;
2074 }
2075
2076 SAMPLE_VIO_GetChar();
2077
2078 SAMPLE_COMM_VPSS_UnBind_VO(VpssGrp, VpssChn, stVoConfig.VoDev, VoChn);
2079
2080 EXIT4:
2081 SAMPLE_COMM_VO_StopVO(&stVoConfig);
2082 EXIT3:
2083 SAMPLE_COMM_VI_UnBind_VPSS(ViPipe, ViChn, VpssGrp);
2084 EXIT2:
2085 SAMPLE_COMM_VPSS_Stop(VpssGrp, abChnEnable);
2086 EXIT1:
2087 SAMPLE_COMM_VI_StopVi(&stViConfig);
2088 EXIT:
2089 SAMPLE_COMM_SYS_Exit();
2090 return s32Ret;
2091 }
2092
2093 #ifdef __cplusplus
2094 #if __cplusplus
2095 }
2096 #endif
2097 #endif /* End of #ifdef __cplusplus */
2098