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 #include "sample_comm.h"
16
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 #include <sys/ioctl.h>
23 #include <poll.h>
24 #include <sys/time.h>
25 #include <fcntl.h>
26 #include <errno.h>
27 #include <pthread.h>
28 #include <math.h>
29 #include <unistd.h>
30 #include <signal.h>
31 #include <sys/prctl.h>
32
33 #include "hi_mipi.h"
34 #include "hi_common.h"
35
36 #ifdef __cplusplus
37 #if __cplusplus
38 extern "C" {
39 #endif
40 #endif /* End of #ifdef __cplusplus */
41
42 #define MIPI_DEV_NODE "/dev/hi_mipi"
43
44 combo_dev_attr_t MIPI_4lane_CHN0_SENSOR_IMX335_12BIT_5M_NOWDR_ATTR = {
45 .devno = 0,
46 .input_mode = INPUT_MODE_MIPI,
47 .data_rate = MIPI_DATA_RATE_X1,
48 .img_rect = { 0, 0, IMG_5M_WIDTH, IMG_5M_HEIGHT },
49 { .mipi_attr = { DATA_TYPE_RAW_12BIT, HI_MIPI_WDR_MODE_NONE, { 0, 1, 2, 3 } } }
50 };
51
52 combo_dev_attr_t MIPI_4lane_CHN0_SENSOR_IMX335_10BIT_5M_WDR2TO1_ATTR = {
53 .devno = 0,
54 .input_mode = INPUT_MODE_MIPI,
55 .data_rate = MIPI_DATA_RATE_X1,
56 .img_rect = { 0, 0, IMG_5M_WIDTH, IMG_5M_HEIGHT },
57 { .mipi_attr = { DATA_TYPE_RAW_10BIT, HI_MIPI_WDR_MODE_VC, { 0, 1, 2, 3 } } }
58 };
59
60 combo_dev_attr_t MIPI_4lane_CHN0_SENSOR_IMX335_12BIT_4M_NOWDR_ATTR = {
61 .devno = 0,
62 .input_mode = INPUT_MODE_MIPI,
63 .data_rate = MIPI_DATA_RATE_X1,
64 .img_rect = { 0, 204, IMG_4M_WIDTH, IMG_4M_HEIGHT },
65 { .mipi_attr = { DATA_TYPE_RAW_12BIT, HI_MIPI_WDR_MODE_NONE, { 0, 1, 2, 3 } } }
66 };
67
68 combo_dev_attr_t MIPI_4lane_CHN0_SENSOR_IMX335_10BIT_4M_WDR2TO1_ATTR = {
69 .devno = 0,
70 .input_mode = INPUT_MODE_MIPI,
71 .data_rate = MIPI_DATA_RATE_X1,
72 .img_rect = { 0, 204, IMG_4M_WIDTH, IMG_4M_HEIGHT },
73 { .mipi_attr = { DATA_TYPE_RAW_10BIT, HI_MIPI_WDR_MODE_VC, { 0, 1, 2, 3 } } }
74 };
75
76 VI_DEV_ATTR_S DEV_ATTR_IMX335_5M_BASE = {
77 VI_MODE_MIPI,
78 VI_WORK_MODE_1Multiplex,
79 { 0xFFF00000, 0x0 },
80 VI_SCAN_PROGRESSIVE,
81 { -1, -1, -1, -1 },
82 VI_DATA_SEQ_YUYV,
83 {
84 VI_VSYNC_PULSE,
85 VI_VSYNC_NEG_LOW,
86 VI_HSYNC_VALID_SINGNAL,
87 VI_HSYNC_NEG_HIGH,
88 VI_VSYNC_VALID_SINGAL,
89 VI_VSYNC_VALID_NEG_HIGH,
90 {
91 /* hsync_hfb hsync_act hsync_hhb */
92 0, IMG_1M_WIDTH, 0,
93 /* vsync0_vhb vsync0_act vsync0_hhb */
94 0, IMG_1M_HEIGHT, 0,
95 /* vsync1_vhb vsync1_act vsync1_hhb */
96 0, 0, 0
97 }
98 },
99 VI_DATA_TYPE_RGB,
100 HI_FALSE,
101 { IMG_5M_WIDTH, IMG_5M_HEIGHT },
102 {
103 { { IMG_5M_WIDTH, IMG_5M_HEIGHT }, },
104 { VI_REPHASE_MODE_NONE, VI_REPHASE_MODE_NONE }
105 },
106 { WDR_MODE_NONE, IMG_5M_HEIGHT },
107 DATA_RATE_X1
108 };
109
110 VI_DEV_ATTR_S DEV_ATTR_IMX335_4M_BASE = {
111 VI_MODE_MIPI,
112 VI_WORK_MODE_1Multiplex,
113 { 0xFFF00000, 0x0 },
114 VI_SCAN_PROGRESSIVE,
115 { -1, -1, -1, -1 },
116 VI_DATA_SEQ_YUYV,
117 {
118 VI_VSYNC_PULSE,
119 VI_VSYNC_NEG_LOW,
120 VI_HSYNC_VALID_SINGNAL,
121 VI_HSYNC_NEG_HIGH,
122 VI_VSYNC_VALID_SINGAL,
123 VI_VSYNC_VALID_NEG_HIGH,
124 {
125 /* hsync_hfb hsync_act hsync_hhb */
126 0, IMG_1M_WIDTH, 0,
127 /* vsync0_vhb vsync0_act vsync0_hhb */
128 0, IMG_1M_HEIGHT, 0,
129 /* vsync1_vhb vsync1_act vsync1_hhb */
130 0, 0, 0
131 }
132 },
133 VI_DATA_TYPE_RGB,
134 HI_FALSE,
135 { IMG_4M_WIDTH, IMG_4M_HEIGHT },
136 {
137 { { IMG_4M_WIDTH, IMG_4M_HEIGHT }, },
138 { VI_REPHASE_MODE_NONE, VI_REPHASE_MODE_NONE }
139 },
140 { WDR_MODE_NONE, IMG_4M_HEIGHT },
141 DATA_RATE_X1
142 };
143
144 static VI_PIPE_ATTR_S PIPE_ATTR_2592x1944_RAW12_420_3DNR_RFR = {
145 VI_PIPE_BYPASS_NONE,
146 HI_FALSE,
147 HI_FALSE,
148 IMG_5M_WIDTH,
149 IMG_5M_HEIGHT,
150 PIXEL_FORMAT_RGB_BAYER_12BPP,
151 COMPRESS_MODE_LINE,
152 DATA_BITWIDTH_12,
153 HI_FALSE,
154 { PIXEL_FORMAT_YVU_SEMIPLANAR_420, DATA_BITWIDTH_8, VI_NR_REF_FROM_RFR, COMPRESS_MODE_NONE },
155 HI_FALSE,
156 { -1, -1 },
157 HI_FALSE
158 };
159
160 static VI_PIPE_ATTR_S PIPE_ATTR_2592x1944_RAW10_420_3DNR_RFR = {
161 VI_PIPE_BYPASS_NONE,
162 HI_FALSE,
163 HI_FALSE,
164 IMG_5M_WIDTH,
165 IMG_5M_HEIGHT,
166 PIXEL_FORMAT_RGB_BAYER_10BPP,
167 COMPRESS_MODE_LINE,
168 DATA_BITWIDTH_10,
169 HI_FALSE,
170 { PIXEL_FORMAT_YVU_SEMIPLANAR_420, DATA_BITWIDTH_8, VI_NR_REF_FROM_RFR, COMPRESS_MODE_NONE },
171 HI_FALSE,
172 { -1, -1 },
173 HI_FALSE
174 };
175
176 static VI_PIPE_ATTR_S PIPE_ATTR_2592x1536_RAW12_420_3DNR_RFR = {
177 VI_PIPE_BYPASS_NONE,
178 HI_FALSE,
179 HI_FALSE,
180 IMG_4M_WIDTH,
181 IMG_4M_HEIGHT,
182 PIXEL_FORMAT_RGB_BAYER_12BPP,
183 COMPRESS_MODE_LINE,
184 DATA_BITWIDTH_12,
185 HI_FALSE,
186 { PIXEL_FORMAT_YVU_SEMIPLANAR_420, DATA_BITWIDTH_8, VI_NR_REF_FROM_RFR, COMPRESS_MODE_NONE },
187 HI_FALSE,
188 { -1, -1 },
189 HI_FALSE
190 };
191
192 static VI_PIPE_ATTR_S PIPE_ATTR_2592x1536_RAW10_420_3DNR_RFR = {
193 VI_PIPE_BYPASS_NONE,
194 HI_FALSE,
195 HI_FALSE,
196 IMG_4M_WIDTH,
197 IMG_4M_HEIGHT,
198 PIXEL_FORMAT_RGB_BAYER_10BPP,
199 COMPRESS_MODE_LINE,
200 DATA_BITWIDTH_10,
201 HI_FALSE,
202 { PIXEL_FORMAT_YVU_SEMIPLANAR_420, DATA_BITWIDTH_8, VI_NR_REF_FROM_RFR, COMPRESS_MODE_NONE },
203 HI_FALSE,
204 { -1, -1 },
205 HI_FALSE
206 };
207
208 static VI_CHN_ATTR_S CHN_ATTR_2592x1944_420_SDR8_LINEAR = {
209 { IMG_5M_WIDTH, IMG_5M_HEIGHT },
210 PIXEL_FORMAT_YVU_SEMIPLANAR_420,
211 DYNAMIC_RANGE_SDR8,
212 VIDEO_FORMAT_LINEAR,
213 COMPRESS_MODE_NONE,
214 0,
215 0,
216 0,
217 { -1, -1 }
218 };
219
220 static VI_CHN_ATTR_S CHN_ATTR_2592x1536_420_SDR8_LINEAR = {
221 { IMG_4M_WIDTH, IMG_4M_HEIGHT },
222 PIXEL_FORMAT_YVU_SEMIPLANAR_420,
223 DYNAMIC_RANGE_SDR8,
224 VIDEO_FORMAT_LINEAR,
225 COMPRESS_MODE_NONE,
226 0,
227 0,
228 0,
229 { -1, -1 }
230 };
231
SAMPLE_COMM_VI_SetMipiHsMode(lane_divide_mode_t enHsMode)232 HI_S32 SAMPLE_COMM_VI_SetMipiHsMode(lane_divide_mode_t enHsMode)
233 {
234 HI_S32 fd = -1;
235 HI_S32 s32Ret = HI_FAILURE;
236
237 fd = open(MIPI_DEV_NODE, O_RDWR);
238 if (fd < 0) {
239 SAMPLE_PRT("open hi_mipi dev failed\n");
240 return s32Ret;
241 }
242
243 s32Ret = ioctl(fd, HI_MIPI_SET_HS_MODE, &enHsMode);
244 if (s32Ret != HI_SUCCESS) {
245 SAMPLE_PRT("HI_MIPI_SET_HS_MODE failed\n");
246 }
247
248 close(fd);
249 return s32Ret;
250 }
251
SAMPLE_COMM_VI_EnableMipiClock(SAMPLE_VI_CONFIG_S * pstViConfig)252 HI_S32 SAMPLE_COMM_VI_EnableMipiClock(SAMPLE_VI_CONFIG_S *pstViConfig)
253 {
254 HI_S32 i;
255 HI_S32 s32ViNum;
256 HI_S32 s32Ret = HI_FAILURE;
257 HI_S32 fd = -1;
258 combo_dev_t devno;
259 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
260
261 if (pstViConfig == HI_NULL) {
262 SAMPLE_PRT("null ptr\n");
263 return s32Ret;
264 }
265
266 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
267 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
268 return s32Ret;
269 }
270
271 fd = open(MIPI_DEV_NODE, O_RDWR);
272 if (fd < 0) {
273 SAMPLE_PRT("open hi_mipi dev failed\n");
274 return s32Ret;
275 }
276
277 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
278 s32ViNum = pstViConfig->as32WorkingViId[i];
279 if (s32ViNum >= VI_MAX_DEV_NUM) {
280 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
281 goto EXIT;
282 }
283 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
284 devno = pstViInfo->stSnsInfo.MipiDev;
285 s32Ret = ioctl(fd, HI_MIPI_ENABLE_MIPI_CLOCK, &devno);
286 if (s32Ret != HI_SUCCESS) {
287 SAMPLE_PRT("MIPI_ENABLE_CLOCK %d failed\n", devno);
288 goto EXIT;
289 }
290 }
291
292 EXIT:
293 close(fd);
294 return s32Ret;
295 }
296
SAMPLE_COMM_VI_DisableMipiClock(SAMPLE_VI_CONFIG_S * pstViConfig)297 static HI_S32 SAMPLE_COMM_VI_DisableMipiClock(SAMPLE_VI_CONFIG_S *pstViConfig)
298 {
299 HI_S32 i;
300 HI_S32 s32ViNum;
301 HI_S32 s32Ret = HI_FAILURE;
302 HI_S32 fd = -1;
303 combo_dev_t devno;
304 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
305
306 if (pstViConfig == HI_NULL) {
307 SAMPLE_PRT("null ptr\n");
308 return s32Ret;
309 }
310
311 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
312 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
313 return s32Ret;
314 }
315
316 fd = open(MIPI_DEV_NODE, O_RDWR);
317 if (fd < 0) {
318 SAMPLE_PRT("open hi_mipi dev failed\n");
319 return s32Ret;
320 }
321
322 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
323 s32ViNum = pstViConfig->as32WorkingViId[i];
324 if (s32ViNum >= VI_MAX_DEV_NUM) {
325 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
326 goto EXIT;
327 }
328
329 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
330 devno = pstViInfo->stSnsInfo.MipiDev;
331 s32Ret = ioctl(fd, HI_MIPI_DISABLE_MIPI_CLOCK, &devno);
332 if (s32Ret != HI_SUCCESS) {
333 SAMPLE_PRT("MIPI_DISABLE_CLOCK %d failed\n", devno);
334 goto EXIT;
335 }
336 }
337
338 EXIT:
339 close(fd);
340 return s32Ret;
341 }
342
SAMPLE_COMM_VI_ResetMipi(SAMPLE_VI_CONFIG_S * pstViConfig)343 HI_S32 SAMPLE_COMM_VI_ResetMipi(SAMPLE_VI_CONFIG_S *pstViConfig)
344 {
345 HI_S32 i;
346 HI_S32 s32ViNum;
347 HI_S32 s32Ret = HI_FAILURE;
348 HI_S32 fd = -1;
349 combo_dev_t devno;
350 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
351
352 if (pstViConfig == HI_NULL) {
353 SAMPLE_PRT("null ptr\n");
354 return s32Ret;
355 }
356
357 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
358 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
359 return s32Ret;
360 }
361
362 fd = open(MIPI_DEV_NODE, O_RDWR);
363 if (fd < 0) {
364 SAMPLE_PRT("open hi_mipi dev failed\n");
365 return s32Ret;
366 }
367
368 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
369 s32ViNum = pstViConfig->as32WorkingViId[i];
370 if (s32ViNum >= VI_MAX_DEV_NUM) {
371 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
372 goto EXIT;
373 }
374
375 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
376 devno = pstViInfo->stSnsInfo.MipiDev;
377 s32Ret = ioctl(fd, HI_MIPI_RESET_MIPI, &devno);
378 if (s32Ret != HI_SUCCESS) {
379 SAMPLE_PRT("RESET_MIPI %d failed\n", devno);
380 goto EXIT;
381 }
382 }
383
384 EXIT:
385 close(fd);
386 return s32Ret;
387 }
388
SAMPLE_COMM_VI_UnresetMipi(SAMPLE_VI_CONFIG_S * pstViConfig)389 HI_S32 SAMPLE_COMM_VI_UnresetMipi(SAMPLE_VI_CONFIG_S *pstViConfig)
390 {
391 HI_S32 i;
392 HI_S32 s32ViNum;
393 HI_S32 s32Ret = HI_FAILURE;
394 HI_S32 fd = -1;
395 combo_dev_t devno;
396 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
397
398 if (pstViConfig == HI_NULL) {
399 SAMPLE_PRT("null ptr\n");
400 return s32Ret;
401 }
402
403 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
404 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
405 return s32Ret;
406 }
407
408 fd = open(MIPI_DEV_NODE, O_RDWR);
409 if (fd < 0) {
410 SAMPLE_PRT("open hi_mipi dev failed\n");
411 return s32Ret;
412 }
413
414 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
415 s32ViNum = pstViConfig->as32WorkingViId[i];
416 if (s32ViNum >= VI_MAX_DEV_NUM) {
417 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
418 goto EXIT;
419 }
420
421 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
422 devno = pstViInfo->stSnsInfo.MipiDev;
423 s32Ret = ioctl(fd, HI_MIPI_UNRESET_MIPI, &devno);
424 if (s32Ret != HI_SUCCESS) {
425 SAMPLE_PRT("UNRESET_MIPI %d failed\n", devno);
426 goto EXIT;
427 }
428 }
429
430 EXIT:
431 close(fd);
432 return s32Ret;
433 }
434
SAMPLE_COMM_VI_EnableSensorClock(HI_VOID)435 static HI_S32 SAMPLE_COMM_VI_EnableSensorClock(HI_VOID)
436 {
437 HI_S32 s32Ret = HI_FAILURE;
438 HI_S32 fd = -1;
439 sns_clk_source_t SnsDev;
440
441 fd = open(MIPI_DEV_NODE, O_RDWR);
442 if (fd < 0) {
443 SAMPLE_PRT("open hi_mipi dev failed\n");
444 return s32Ret;
445 }
446
447 for (SnsDev = 0; SnsDev < SNS_MAX_CLK_SOURCE_NUM; SnsDev++) {
448 s32Ret = ioctl(fd, HI_MIPI_ENABLE_SENSOR_CLOCK, &SnsDev);
449 if (s32Ret != HI_SUCCESS) {
450 SAMPLE_PRT("HI_MIPI_ENABLE_SENSOR_CLOCK failed\n");
451 goto EXIT;
452 }
453 }
454
455 EXIT:
456 close(fd);
457 return s32Ret;
458 }
459
SAMPLE_COMM_VI_DisableSensorClock(HI_VOID)460 static HI_S32 SAMPLE_COMM_VI_DisableSensorClock(HI_VOID)
461 {
462 HI_S32 s32Ret = HI_FAILURE;
463 HI_S32 fd = -1;
464 sns_clk_source_t SnsDev;
465
466 fd = open(MIPI_DEV_NODE, O_RDWR);
467 if (fd < 0) {
468 SAMPLE_PRT("open hi_mipi dev failed\n");
469 return s32Ret;
470 }
471
472 for (SnsDev = 0; SnsDev < SNS_MAX_CLK_SOURCE_NUM; SnsDev++) {
473 s32Ret = ioctl(fd, HI_MIPI_DISABLE_SENSOR_CLOCK, &SnsDev);
474 if (s32Ret != HI_SUCCESS) {
475 SAMPLE_PRT("HI_MIPI_DISABLE_SENSOR_CLOCK failed\n");
476 goto EXIT;
477 }
478 }
479
480 EXIT:
481 close(fd);
482 return s32Ret;
483 }
484
SAMPLE_COMM_VI_ResetSensor(HI_VOID)485 static HI_S32 SAMPLE_COMM_VI_ResetSensor(HI_VOID)
486 {
487 HI_S32 s32Ret = HI_FAILURE;
488 HI_S32 fd = -1;
489 sns_rst_source_t SnsDev;
490
491 fd = open(MIPI_DEV_NODE, O_RDWR);
492 if (fd < 0) {
493 SAMPLE_PRT("open hi_mipi dev failed\n");
494 return s32Ret;
495 }
496
497 for (SnsDev = 0; SnsDev < SNS_MAX_RST_SOURCE_NUM; SnsDev++) {
498 s32Ret = ioctl(fd, HI_MIPI_RESET_SENSOR, &SnsDev);
499 if (s32Ret != HI_SUCCESS) {
500 SAMPLE_PRT("HI_MIPI_RESET_SENSOR failed\n");
501 goto EXIT;
502 }
503 }
504
505 EXIT:
506 close(fd);
507 return s32Ret;
508 }
509
SAMPLE_COMM_VI_UnresetSensor(HI_VOID)510 static HI_S32 SAMPLE_COMM_VI_UnresetSensor(HI_VOID)
511 {
512 HI_S32 s32Ret = HI_FAILURE;
513 HI_S32 fd = -1;
514 sns_rst_source_t SnsDev;
515
516 fd = open(MIPI_DEV_NODE, O_RDWR);
517 if (fd < 0) {
518 SAMPLE_PRT("open hi_mipi dev failed\n");
519 return s32Ret;
520 }
521
522 for (SnsDev = 0; SnsDev < SNS_MAX_RST_SOURCE_NUM; SnsDev++) {
523 s32Ret = ioctl(fd, HI_MIPI_UNRESET_SENSOR, &SnsDev);
524 if (s32Ret != HI_SUCCESS) {
525 SAMPLE_PRT("HI_MIPI_UNRESET_SENSOR failed\n");
526 goto EXIT;
527 }
528 }
529
530 EXIT:
531 close(fd);
532 return s32Ret;
533 }
534
SAMPLE_COMM_VI_GetComboAttrBySns(SAMPLE_SNS_TYPE_E enSnsType,combo_dev_t MipiDev,combo_dev_attr_t * pstComboAttr)535 HI_VOID SAMPLE_COMM_VI_GetComboAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, combo_dev_t MipiDev,
536 combo_dev_attr_t *pstComboAttr)
537 {
538 switch (enSnsType) {
539 case SONY_IMX335_MIPI_5M_30FPS_12BIT:
540 (hi_void)memcpy_s(pstComboAttr, sizeof(combo_dev_attr_t),
541 &MIPI_4lane_CHN0_SENSOR_IMX335_12BIT_5M_NOWDR_ATTR, sizeof(combo_dev_attr_t));
542 break;
543
544 case SONY_IMX335_MIPI_5M_30FPS_10BIT_WDR2TO1:
545 (hi_void)memcpy_s(pstComboAttr, sizeof(combo_dev_attr_t),
546 &MIPI_4lane_CHN0_SENSOR_IMX335_10BIT_5M_WDR2TO1_ATTR, sizeof(combo_dev_attr_t));
547 break;
548
549 case SONY_IMX335_MIPI_4M_30FPS_12BIT:
550 (hi_void)memcpy_s(pstComboAttr, sizeof(combo_dev_attr_t),
551 &MIPI_4lane_CHN0_SENSOR_IMX335_12BIT_4M_NOWDR_ATTR, sizeof(combo_dev_attr_t));
552 break;
553
554 case SONY_IMX335_MIPI_4M_30FPS_10BIT_WDR2TO1:
555 (hi_void)memcpy_s(pstComboAttr, sizeof(combo_dev_attr_t),
556 &MIPI_4lane_CHN0_SENSOR_IMX335_10BIT_4M_WDR2TO1_ATTR, sizeof(combo_dev_attr_t));
557 break;
558
559 default:
560 SAMPLE_PRT("not support enSnsType: %d\n", enSnsType);
561 (hi_void)memcpy_s(pstComboAttr, sizeof(combo_dev_attr_t),
562 &MIPI_4lane_CHN0_SENSOR_IMX335_12BIT_4M_NOWDR_ATTR, sizeof(combo_dev_attr_t));
563 break;
564 }
565
566 return;
567 }
568
SAMPLE_COMM_VI_SetMipiAttr(SAMPLE_VI_CONFIG_S * pstViConfig)569 HI_S32 SAMPLE_COMM_VI_SetMipiAttr(SAMPLE_VI_CONFIG_S *pstViConfig)
570 {
571 HI_S32 i;
572 HI_S32 s32ViNum;
573 HI_S32 s32Ret = HI_FAILURE;
574 HI_S32 fd = -1;
575 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
576 combo_dev_attr_t stcomboDevAttr;
577
578 if (pstViConfig == HI_NULL) {
579 SAMPLE_PRT("null ptr\n");
580 return s32Ret;
581 }
582
583 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
584 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
585 return s32Ret;
586 }
587
588 fd = open(MIPI_DEV_NODE, O_RDWR);
589 if (fd < 0) {
590 SAMPLE_PRT("open hi_mipi dev failed.\n");
591 return s32Ret;
592 }
593
594 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
595 s32ViNum = pstViConfig->as32WorkingViId[i];
596 if (s32ViNum >= VI_MAX_DEV_NUM) {
597 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
598 goto EXIT;
599 }
600
601 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
602 SAMPLE_COMM_VI_GetComboAttrBySns(pstViInfo->stSnsInfo.enSnsType, pstViInfo->stSnsInfo.MipiDev, &stcomboDevAttr);
603 stcomboDevAttr.devno = pstViInfo->stSnsInfo.MipiDev;
604
605 SAMPLE_PRT("MipiDev%d SetMipiAttr enWDRMode: %d\n", pstViInfo->stSnsInfo.MipiDev,
606 pstViInfo->stDevInfo.enWDRMode);
607
608 s32Ret = ioctl(fd, HI_MIPI_SET_DEV_ATTR, &stcomboDevAttr);
609 if (s32Ret != HI_SUCCESS) {
610 SAMPLE_PRT("MIPI_SET_DEV_ATTR failed.\n");
611 goto EXIT;
612 }
613 }
614
615 EXIT:
616 close(fd);
617 return s32Ret;
618 }
619
SAMPLE_COMM_VI_GetMipiLaneDivideMode(SAMPLE_VI_CONFIG_S * pstViConfig)620 HI_U32 SAMPLE_COMM_VI_GetMipiLaneDivideMode(SAMPLE_VI_CONFIG_S *pstViConfig)
621 {
622 lane_divide_mode_t lane_divide_mode = LANE_DIVIDE_MODE_0;
623
624 return (HI_U32)lane_divide_mode;
625 }
626
SAMPLE_COMM_VI_StartMIPI(SAMPLE_VI_CONFIG_S * pstViConfig)627 HI_S32 SAMPLE_COMM_VI_StartMIPI(SAMPLE_VI_CONFIG_S *pstViConfig)
628 {
629 HI_S32 s32Ret = HI_FAILURE;
630 lane_divide_mode_t lane_divide_mode;
631
632 if (pstViConfig == HI_NULL) {
633 SAMPLE_PRT("%s: null ptr\n", __FUNCTION__);
634 return s32Ret;
635 }
636
637 lane_divide_mode = SAMPLE_COMM_VI_GetMipiLaneDivideMode(pstViConfig);
638 s32Ret = SAMPLE_COMM_VI_SetMipiHsMode(lane_divide_mode);
639 if (s32Ret != HI_SUCCESS) {
640 SAMPLE_PRT("SAMPLE_COMM_VI_SetMipiHsMode failed!\n");
641 return s32Ret;
642 }
643
644 s32Ret = SAMPLE_COMM_VI_EnableMipiClock(pstViConfig);
645 if (s32Ret != HI_SUCCESS) {
646 SAMPLE_PRT("SAMPLE_COMM_VI_EnableMipiClock failed!\n");
647 return s32Ret;
648 }
649
650 s32Ret = SAMPLE_COMM_VI_ResetMipi(pstViConfig);
651 if (s32Ret != HI_SUCCESS) {
652 SAMPLE_PRT("SAMPLE_COMM_VI_ResetMipi failed!\n");
653 return s32Ret;
654 }
655
656 s32Ret = SAMPLE_COMM_VI_EnableSensorClock();
657 if (s32Ret != HI_SUCCESS) {
658 SAMPLE_PRT("SAMPLE_COMM_VI_EnableSensorClock failed!\n");
659 return s32Ret;
660 }
661
662 s32Ret = SAMPLE_COMM_VI_ResetSensor();
663 if (s32Ret != HI_SUCCESS) {
664 SAMPLE_PRT("SAMPLE_COMM_VI_ResetSensor failed!\n");
665 return s32Ret;
666 }
667
668 usleep(10000); /* sleep 10000us to avoid reset signal invalid. */
669
670 s32Ret = SAMPLE_COMM_VI_SetMipiAttr(pstViConfig);
671 if (s32Ret != HI_SUCCESS) {
672 SAMPLE_PRT("SAMPLE_COMM_VI_SetMipiAttr failed!\n");
673 return s32Ret;
674 }
675
676 s32Ret = SAMPLE_COMM_VI_UnresetMipi(pstViConfig);
677 if (s32Ret != HI_SUCCESS) {
678 SAMPLE_PRT("SAMPLE_COMM_VI_UnresetMipi failed!\n");
679 return s32Ret;
680 }
681
682 s32Ret = SAMPLE_COMM_VI_UnresetSensor();
683 if (s32Ret != HI_SUCCESS) {
684 SAMPLE_PRT("SAMPLE_COMM_VI_UnresetSensor failed!\n");
685 return s32Ret;
686 }
687
688 return s32Ret;
689 }
690
SAMPLE_COMM_VI_StopMIPI(SAMPLE_VI_CONFIG_S * pstViConfig)691 HI_S32 SAMPLE_COMM_VI_StopMIPI(SAMPLE_VI_CONFIG_S *pstViConfig)
692 {
693 HI_S32 s32Ret = HI_FAILURE;
694
695 if (pstViConfig == HI_NULL) {
696 SAMPLE_PRT("%s: null ptr\n", __FUNCTION__);
697 return s32Ret;
698 }
699
700 s32Ret = SAMPLE_COMM_VI_ResetSensor();
701 if (s32Ret != HI_SUCCESS) {
702 SAMPLE_PRT("SAMPLE_COMM_VI_ResetSensor failed!\n");
703 return s32Ret;
704 }
705
706 s32Ret = SAMPLE_COMM_VI_DisableSensorClock();
707 if (s32Ret != HI_SUCCESS) {
708 SAMPLE_PRT("SAMPLE_COMM_VI_DisableSensorClock failed!\n");
709 return s32Ret;
710 }
711
712 s32Ret = SAMPLE_COMM_VI_ResetMipi(pstViConfig);
713 if (s32Ret != HI_SUCCESS) {
714 SAMPLE_PRT("SAMPLE_COMM_VI_ResetMipi failed!\n");
715 return s32Ret;
716 }
717
718 s32Ret = SAMPLE_COMM_VI_DisableMipiClock(pstViConfig);
719 if (s32Ret != HI_SUCCESS) {
720 SAMPLE_PRT("SAMPLE_COMM_VI_DisableMipiClock failed!\n");
721 return s32Ret;
722 }
723
724 return s32Ret;
725 }
726
727 /* when mode[0] is VI_OFFLINE_VPSS_ONLINE, other pipe mode must set VI_OFFLINE_VPSS_ONLINE. */
SAMPLE_COMM_VI_UpdateVIVPSSMode(VI_VPSS_MODE_S * pstVIVPSSMode)728 static HI_VOID SAMPLE_COMM_VI_UpdateVIVPSSMode(VI_VPSS_MODE_S *pstVIVPSSMode)
729 {
730 HI_S32 i;
731
732 if (pstVIVPSSMode->aenMode[0] == VI_OFFLINE_VPSS_ONLINE) {
733 for (i = 0; i < VI_MAX_PIPE_NUM; i++) {
734 pstVIVPSSMode->aenMode[i] = pstVIVPSSMode->aenMode[0];
735 }
736 }
737 }
738
SAMPLE_COMM_VI_SetParam(SAMPLE_VI_CONFIG_S * pstViConfig)739 HI_S32 SAMPLE_COMM_VI_SetParam(SAMPLE_VI_CONFIG_S *pstViConfig)
740 {
741 HI_S32 i, j;
742 HI_S32 s32ViNum;
743 HI_S32 s32Ret = HI_FAILURE;
744 VI_PIPE ViPipe;
745 VI_PIPE SnapPipe;
746 VI_VPSS_MODE_S stVIVPSSMode;
747 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
748
749 if (pstViConfig == HI_NULL) {
750 SAMPLE_PRT("null ptr\n");
751 return s32Ret;
752 }
753
754 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
755 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
756 return s32Ret;
757 }
758
759 s32Ret = HI_MPI_SYS_GetVIVPSSMode(&stVIVPSSMode);
760 if (s32Ret != HI_SUCCESS) {
761 SAMPLE_PRT("Get VI-VPSS mode Param failed with %#x!\n", s32Ret);
762 return s32Ret;
763 }
764
765 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
766 s32ViNum = pstViConfig->as32WorkingViId[i];
767 if (s32ViNum >= VI_MAX_DEV_NUM) {
768 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
769 return s32Ret;
770 }
771
772 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
773 ViPipe = pstViInfo->stPipeInfo.aPipe[0];
774 if (ViPipe >= VI_MAX_PIPE_NUM) {
775 continue;
776 }
777 stVIVPSSMode.aenMode[ViPipe] = pstViInfo->stPipeInfo.enMastPipeMode;
778
779 if ((pstViInfo->stPipeInfo.bMultiPipe == HI_TRUE) ||
780 (pstViInfo->stPipeInfo.enMastPipeMode == VI_OFFLINE_VPSS_ONLINE)) {
781 SAMPLE_COMM_VI_UpdateVIVPSSMode(&stVIVPSSMode);
782 for (j = 1; j < WDR_MAX_PIPE_NUM; j++) {
783 ViPipe = pstViInfo->stPipeInfo.aPipe[j];
784 if (ViPipe != -1) {
785 stVIVPSSMode.aenMode[ViPipe] = pstViInfo->stPipeInfo.enMastPipeMode;
786 }
787 }
788 }
789
790 if ((pstViInfo->stSnapInfo.bSnap) && (pstViInfo->stSnapInfo.bDoublePipe)) {
791 SnapPipe = pstViInfo->stPipeInfo.aPipe[1];
792 if (SnapPipe != -1) {
793 stVIVPSSMode.aenMode[SnapPipe] = pstViInfo->stSnapInfo.enSnapPipeMode;
794 }
795 }
796 }
797
798 s32Ret = HI_MPI_SYS_SetVIVPSSMode(&stVIVPSSMode);
799 if (s32Ret != HI_SUCCESS) {
800 SAMPLE_PRT("Set VI-VPSS mode Param failed with %#x!\n", s32Ret);
801 return s32Ret;
802 }
803
804 return s32Ret;
805 }
806
SAMPLE_COMM_VI_GetDevAttrBySns(SAMPLE_SNS_TYPE_E enSnsType,VI_DEV_ATTR_S * pstViDevAttr)807 HI_VOID SAMPLE_COMM_VI_GetDevAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, VI_DEV_ATTR_S *pstViDevAttr)
808 {
809 switch (enSnsType) {
810 case SONY_IMX335_MIPI_5M_30FPS_12BIT:
811 (hi_void)memcpy_s(pstViDevAttr, sizeof(VI_DEV_ATTR_S), &DEV_ATTR_IMX335_5M_BASE, sizeof(VI_DEV_ATTR_S));
812 break;
813
814 case SONY_IMX335_MIPI_5M_30FPS_10BIT_WDR2TO1:
815 (hi_void)memcpy_s(pstViDevAttr, sizeof(VI_DEV_ATTR_S), &DEV_ATTR_IMX335_5M_BASE, sizeof(VI_DEV_ATTR_S));
816 pstViDevAttr->au32ComponentMask[0] = 0xFFC00000;
817 break;
818
819 case SONY_IMX335_MIPI_4M_30FPS_12BIT:
820 (hi_void)memcpy_s(pstViDevAttr, sizeof(VI_DEV_ATTR_S), &DEV_ATTR_IMX335_4M_BASE, sizeof(VI_DEV_ATTR_S));
821 break;
822
823 case SONY_IMX335_MIPI_4M_30FPS_10BIT_WDR2TO1:
824 (hi_void)memcpy_s(pstViDevAttr, sizeof(VI_DEV_ATTR_S), &DEV_ATTR_IMX335_4M_BASE, sizeof(VI_DEV_ATTR_S));
825 pstViDevAttr->au32ComponentMask[0] = 0xFFC00000;
826 break;
827
828 default:
829 (hi_void)memcpy_s(pstViDevAttr, sizeof(VI_DEV_ATTR_S), &DEV_ATTR_IMX335_4M_BASE, sizeof(VI_DEV_ATTR_S));
830 break;
831 }
832
833 return;
834 }
835
SAMPLE_COMM_VI_GetPipeAttrBySns(SAMPLE_SNS_TYPE_E enSnsType,VI_PIPE_ATTR_S * pstPipeAttr)836 HI_VOID SAMPLE_COMM_VI_GetPipeAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, VI_PIPE_ATTR_S *pstPipeAttr)
837 {
838 switch (enSnsType) {
839 case SONY_IMX335_MIPI_5M_30FPS_12BIT:
840 (hi_void)memcpy_s(pstPipeAttr, sizeof(VI_PIPE_ATTR_S), &PIPE_ATTR_2592x1944_RAW12_420_3DNR_RFR,
841 sizeof(VI_PIPE_ATTR_S));
842 break;
843
844 case SONY_IMX335_MIPI_5M_30FPS_10BIT_WDR2TO1:
845 (hi_void)memcpy_s(pstPipeAttr, sizeof(VI_PIPE_ATTR_S), &PIPE_ATTR_2592x1944_RAW10_420_3DNR_RFR,
846 sizeof(VI_PIPE_ATTR_S));
847 break;
848
849 case SONY_IMX335_MIPI_4M_30FPS_12BIT:
850 (hi_void)memcpy_s(pstPipeAttr, sizeof(VI_PIPE_ATTR_S), &PIPE_ATTR_2592x1536_RAW12_420_3DNR_RFR,
851 sizeof(VI_PIPE_ATTR_S));
852 break;
853
854 case SONY_IMX335_MIPI_4M_30FPS_10BIT_WDR2TO1:
855 (hi_void)memcpy_s(pstPipeAttr, sizeof(VI_PIPE_ATTR_S), &PIPE_ATTR_2592x1536_RAW10_420_3DNR_RFR,
856 sizeof(VI_PIPE_ATTR_S));
857 break;
858
859 default:
860 (hi_void)memcpy_s(pstPipeAttr, sizeof(VI_PIPE_ATTR_S), &PIPE_ATTR_2592x1536_RAW12_420_3DNR_RFR,
861 sizeof(VI_PIPE_ATTR_S));
862 break;
863 }
864
865 return;
866 }
867
SAMPLE_COMM_VI_GetChnAttrBySns(SAMPLE_SNS_TYPE_E enSnsType,VI_CHN_ATTR_S * pstChnAttr)868 HI_VOID SAMPLE_COMM_VI_GetChnAttrBySns(SAMPLE_SNS_TYPE_E enSnsType, VI_CHN_ATTR_S *pstChnAttr)
869 {
870 switch (enSnsType) {
871 case SONY_IMX335_MIPI_5M_30FPS_12BIT:
872 case SONY_IMX335_MIPI_5M_30FPS_10BIT_WDR2TO1:
873 (hi_void)
874 memcpy_s(pstChnAttr, sizeof(VI_CHN_ATTR_S), &CHN_ATTR_2592x1944_420_SDR8_LINEAR, sizeof(VI_CHN_ATTR_S));
875 break;
876
877 case SONY_IMX335_MIPI_4M_30FPS_12BIT:
878 case SONY_IMX335_MIPI_4M_30FPS_10BIT_WDR2TO1:
879 (hi_void)
880 memcpy_s(pstChnAttr, sizeof(VI_CHN_ATTR_S), &CHN_ATTR_2592x1536_420_SDR8_LINEAR, sizeof(VI_CHN_ATTR_S));
881 break;
882
883 default:
884 (hi_void)
885 memcpy_s(pstChnAttr, sizeof(VI_CHN_ATTR_S), &CHN_ATTR_2592x1536_420_SDR8_LINEAR, sizeof(VI_CHN_ATTR_S));
886 break;
887 }
888
889 return;
890 }
891
SAMPLE_COMM_VI_StartDev(SAMPLE_VI_INFO_S * pstViInfo)892 HI_S32 SAMPLE_COMM_VI_StartDev(SAMPLE_VI_INFO_S *pstViInfo)
893 {
894 HI_S32 s32Ret;
895 VI_DEV ViDev;
896 SAMPLE_SNS_TYPE_E enSnsType;
897 VI_DEV_ATTR_S stViDevAttr;
898
899 if (pstViInfo == NULL) {
900 SAMPLE_PRT("null pointer\n");
901 return HI_FAILURE;
902 }
903 enSnsType = pstViInfo->stSnsInfo.enSnsType;
904 SAMPLE_COMM_VI_GetDevAttrBySns(enSnsType, &stViDevAttr);
905 stViDevAttr.stWDRAttr.enWDRMode = pstViInfo->stDevInfo.enWDRMode;
906
907 ViDev = pstViInfo->stDevInfo.ViDev;
908 s32Ret = HI_MPI_VI_SetDevAttr(ViDev, &stViDevAttr);
909 if (s32Ret != HI_SUCCESS) {
910 SAMPLE_PRT("HI_MPI_VI_SetDevAttr failed with %#x!\n", s32Ret);
911 return s32Ret;
912 }
913
914 s32Ret = HI_MPI_VI_EnableDev(ViDev);
915 if (s32Ret != HI_SUCCESS) {
916 SAMPLE_PRT("HI_MPI_VI_EnableDev failed with %#x!\n", s32Ret);
917 return s32Ret;
918 }
919
920 return s32Ret;
921 }
922
SAMPLE_COMM_VI_StopDev(SAMPLE_VI_INFO_S * pstViInfo)923 HI_S32 SAMPLE_COMM_VI_StopDev(SAMPLE_VI_INFO_S *pstViInfo)
924 {
925 HI_S32 s32Ret;
926 VI_DEV ViDev;
927
928 if (pstViInfo == NULL) {
929 SAMPLE_PRT("null pointer\n");
930 return HI_FAILURE;
931 }
932 ViDev = pstViInfo->stDevInfo.ViDev;
933 s32Ret = HI_MPI_VI_DisableDev(ViDev);
934 if (s32Ret != HI_SUCCESS) {
935 SAMPLE_PRT("HI_MPI_VI_DisableDev failed with %#x!\n", s32Ret);
936 return s32Ret;
937 }
938
939 return s32Ret;
940 }
941
SAMPLE_COMM_VI_BindPipeDev(SAMPLE_VI_INFO_S * pstViInfo)942 HI_S32 SAMPLE_COMM_VI_BindPipeDev(SAMPLE_VI_INFO_S *pstViInfo)
943 {
944 HI_S32 i;
945 HI_S32 s32PipeCnt = 0;
946 HI_S32 s32Ret;
947 VI_DEV_BIND_PIPE_S stDevBindPipe = { 0 };
948
949 if (pstViInfo == NULL) {
950 SAMPLE_PRT("null pointer\n");
951 return HI_FAILURE;
952 }
953 for (i = 0; i < WDR_MAX_PIPE_NUM; i++) {
954 if ((pstViInfo->stPipeInfo.aPipe[i] >= 0) && (pstViInfo->stPipeInfo.aPipe[i] < VI_MAX_PIPE_NUM)) {
955 stDevBindPipe.PipeId[s32PipeCnt] = pstViInfo->stPipeInfo.aPipe[i];
956 s32PipeCnt++;
957 stDevBindPipe.u32Num = s32PipeCnt;
958 }
959 }
960
961 s32Ret = HI_MPI_VI_SetDevBindPipe(pstViInfo->stDevInfo.ViDev, &stDevBindPipe);
962 if (s32Ret != HI_SUCCESS) {
963 SAMPLE_PRT("HI_MPI_VI_SetDevBindPipe failed with %#x!\n", s32Ret);
964 return s32Ret;
965 }
966
967 return s32Ret;
968 }
969
SAMPLE_COMM_VI_ModeSwitchCreateSingleViPipe(VI_PIPE ViPipe,VI_PIPE_ATTR_S * pstPipeAttr)970 static HI_S32 SAMPLE_COMM_VI_ModeSwitchCreateSingleViPipe(VI_PIPE ViPipe, VI_PIPE_ATTR_S *pstPipeAttr)
971 {
972 HI_S32 s32Ret;
973
974 s32Ret = HI_MPI_VI_CreatePipe(ViPipe, pstPipeAttr);
975 if (s32Ret != HI_SUCCESS) {
976 SAMPLE_PRT("HI_MPI_VI_CreatePipe failed with %#x!\n", s32Ret);
977 return s32Ret;
978 }
979
980 return s32Ret;
981 }
982
SAMPLE_COMM_VI_ModeSwitch_EnableSingleViPipe(VI_PIPE ViPipe)983 static HI_S32 SAMPLE_COMM_VI_ModeSwitch_EnableSingleViPipe(VI_PIPE ViPipe)
984 {
985 HI_S32 s32Ret;
986
987 s32Ret = HI_MPI_VI_StartPipe(ViPipe);
988 if (s32Ret != HI_SUCCESS) {
989 HI_MPI_VI_DestroyPipe(ViPipe);
990 SAMPLE_PRT("HI_MPI_VI_StartPipe failed with %#x!\n", s32Ret);
991 return s32Ret;
992 }
993
994 return s32Ret;
995 }
996
SAMPLE_COMM_VI_StopSingleViPipe(VI_PIPE ViPipe)997 static HI_S32 SAMPLE_COMM_VI_StopSingleViPipe(VI_PIPE ViPipe)
998 {
999 HI_S32 s32Ret;
1000
1001 s32Ret = HI_MPI_VI_StopPipe(ViPipe);
1002 if (s32Ret != HI_SUCCESS) {
1003 SAMPLE_PRT("HI_MPI_VI_StopPipe failed with %#x!\n", s32Ret);
1004 return s32Ret;
1005 }
1006
1007 s32Ret = HI_MPI_VI_DestroyPipe(ViPipe);
1008 if (s32Ret != HI_SUCCESS) {
1009 SAMPLE_PRT("HI_MPI_VI_DestroyPipe failed with %#x!\n", s32Ret);
1010 return s32Ret;
1011 }
1012
1013 return s32Ret;
1014 }
1015
SAMPLE_COMM_VI_ModeSwitch_StartViPipe(SAMPLE_VI_INFO_S * pstViInfo)1016 static HI_S32 SAMPLE_COMM_VI_ModeSwitch_StartViPipe(SAMPLE_VI_INFO_S *pstViInfo)
1017 {
1018 HI_S32 i, j;
1019 HI_S32 s32Ret = HI_SUCCESS;
1020 VI_PIPE ViPipe;
1021 VI_PIPE_ATTR_S stPipeAttr;
1022
1023 for (i = 0; i < WDR_MAX_PIPE_NUM; i++) {
1024 if (pstViInfo->stPipeInfo.aPipe[i] >= 0 && pstViInfo->stPipeInfo.aPipe[i] < VI_MAX_PIPE_NUM) {
1025 ViPipe = pstViInfo->stPipeInfo.aPipe[i];
1026 SAMPLE_COMM_VI_GetPipeAttrBySns(pstViInfo->stSnsInfo.enSnsType, &stPipeAttr);
1027 s32Ret = SAMPLE_COMM_VI_ModeSwitchCreateSingleViPipe(ViPipe, &stPipeAttr);
1028 if (s32Ret != HI_SUCCESS) {
1029 SAMPLE_PRT("SAMPLE_COMM_VI_StartSingleViPipe %d failed!\n", ViPipe);
1030 goto EXIT;
1031 }
1032 }
1033 }
1034
1035 return s32Ret;
1036
1037 EXIT:
1038 for (j = 0; j < i; j++) {
1039 ViPipe = j;
1040 SAMPLE_COMM_VI_StopSingleViPipe(ViPipe);
1041 }
1042 return s32Ret;
1043 }
1044
SAMPLE_COMM_VI_ModeSwitch_EnableViPipe(SAMPLE_VI_INFO_S * pstViInfo)1045 HI_S32 SAMPLE_COMM_VI_ModeSwitch_EnableViPipe(SAMPLE_VI_INFO_S *pstViInfo)
1046 {
1047 HI_S32 i, j;
1048 HI_S32 s32Ret = HI_SUCCESS;
1049 VI_PIPE ViPipe;
1050 VI_PIPE_ATTR_S stPipeAttr;
1051
1052 if (pstViInfo == NULL) {
1053 SAMPLE_PRT("null pointer\n");
1054 return HI_FAILURE;
1055 }
1056 for (i = 0; i < WDR_MAX_PIPE_NUM; i++) {
1057 if ((pstViInfo->stPipeInfo.aPipe[i] >= 0) && (pstViInfo->stPipeInfo.aPipe[i] < VI_MAX_PIPE_NUM)) {
1058 ViPipe = pstViInfo->stPipeInfo.aPipe[i];
1059 SAMPLE_COMM_VI_GetPipeAttrBySns(pstViInfo->stSnsInfo.enSnsType, &stPipeAttr);
1060 s32Ret = SAMPLE_COMM_VI_ModeSwitch_EnableSingleViPipe(ViPipe);
1061 if (s32Ret != HI_SUCCESS) {
1062 SAMPLE_PRT("SAMPLE_COMM_VI_StartSingleViPipe %d failed!\n", ViPipe);
1063 goto EXIT;
1064 }
1065 }
1066 }
1067
1068 return s32Ret;
1069
1070 EXIT:
1071 for (j = 0; j < i; j++) {
1072 ViPipe = j;
1073 SAMPLE_COMM_VI_StopSingleViPipe(ViPipe);
1074 }
1075 return s32Ret;
1076 }
1077
SAMPLE_COMM_VI_StartViPipe(SAMPLE_VI_INFO_S * pstViInfo)1078 static HI_S32 SAMPLE_COMM_VI_StartViPipe(SAMPLE_VI_INFO_S *pstViInfo)
1079 {
1080 HI_S32 i, j;
1081 HI_S32 s32Ret = HI_FAILURE;
1082 VI_PIPE ViPipe;
1083 VI_PIPE_ATTR_S stPipeAttr;
1084
1085 for (i = 0; i < WDR_MAX_PIPE_NUM; i++) {
1086 if ((pstViInfo->stPipeInfo.aPipe[i] >= 0) && (pstViInfo->stPipeInfo.aPipe[i] < VI_MAX_PIPE_NUM)) {
1087 ViPipe = pstViInfo->stPipeInfo.aPipe[i];
1088 SAMPLE_COMM_VI_GetPipeAttrBySns(pstViInfo->stSnsInfo.enSnsType, &stPipeAttr);
1089 if (pstViInfo->stPipeInfo.bIspBypass == HI_TRUE) {
1090 stPipeAttr.bIspBypass = HI_TRUE;
1091 stPipeAttr.enPixFmt = pstViInfo->stPipeInfo.enPixFmt;
1092 stPipeAttr.enBitWidth = DATA_BITWIDTH_8;
1093 }
1094
1095 if ((ViPipe == 2) || (ViPipe == 3)) { /* V500 pipe2 and pipe3 only support cmp_none */
1096 stPipeAttr.enCompressMode = COMPRESS_MODE_NONE;
1097 }
1098
1099 if ((pstViInfo->stSnapInfo.bSnap) && (pstViInfo->stSnapInfo.bDoublePipe) &&
1100 (ViPipe == pstViInfo->stSnapInfo.SnapPipe)) {
1101 s32Ret = HI_MPI_VI_CreatePipe(ViPipe, &stPipeAttr);
1102 if (s32Ret != HI_SUCCESS) {
1103 SAMPLE_PRT("HI_MPI_VI_CreatePipe failed with %#x!\n", s32Ret);
1104 goto EXIT;
1105 }
1106 } else {
1107 s32Ret = HI_MPI_VI_CreatePipe(ViPipe, &stPipeAttr);
1108 if (s32Ret != HI_SUCCESS) {
1109 SAMPLE_PRT("HI_MPI_VI_CreatePipe failed with %#x!\n", s32Ret);
1110 return s32Ret;
1111 }
1112
1113 if (pstViInfo->stPipeInfo.bVcNumCfged == HI_TRUE) {
1114 s32Ret = HI_MPI_VI_SetPipeVCNumber(ViPipe, pstViInfo->stPipeInfo.u32VCNum[i]);
1115 if (s32Ret != HI_SUCCESS) {
1116 HI_MPI_VI_DestroyPipe(ViPipe);
1117 SAMPLE_PRT("HI_MPI_VI_SetPipeVCNumber failed with %#x!\n", s32Ret);
1118 return s32Ret;
1119 }
1120 }
1121
1122 s32Ret = HI_MPI_VI_StartPipe(ViPipe);
1123 if (s32Ret != HI_SUCCESS) {
1124 HI_MPI_VI_DestroyPipe(ViPipe);
1125 SAMPLE_PRT("HI_MPI_VI_StartPipe failed with %#x!\n", s32Ret);
1126 return s32Ret;
1127 }
1128 }
1129 }
1130 }
1131
1132 return s32Ret;
1133
1134 EXIT:
1135 for (j = 0; j < i; j++) {
1136 ViPipe = j;
1137 SAMPLE_COMM_VI_StopSingleViPipe(ViPipe);
1138 }
1139 return s32Ret;
1140 }
1141
SAMPLE_COMM_VI_StopViPipe(SAMPLE_VI_INFO_S * pstViInfo)1142 HI_VOID SAMPLE_COMM_VI_StopViPipe(SAMPLE_VI_INFO_S *pstViInfo)
1143 {
1144 HI_S32 i;
1145 VI_PIPE ViPipe;
1146
1147 for (i = 0; i < WDR_MAX_PIPE_NUM; i++) {
1148 if ((pstViInfo->stPipeInfo.aPipe[i] >= 0) && (pstViInfo->stPipeInfo.aPipe[i] < VI_MAX_PIPE_NUM)) {
1149 ViPipe = pstViInfo->stPipeInfo.aPipe[i];
1150 SAMPLE_COMM_VI_StopSingleViPipe(ViPipe);
1151 }
1152 }
1153
1154 return;
1155 }
1156
SAMPLE_COMM_VI_ModeSwitch_StartViChn(SAMPLE_VI_INFO_S * pstViInfo)1157 static HI_S32 SAMPLE_COMM_VI_ModeSwitch_StartViChn(SAMPLE_VI_INFO_S *pstViInfo)
1158 {
1159 HI_S32 i;
1160 HI_BOOL bNeedChn;
1161 HI_S32 s32Ret = HI_SUCCESS;
1162 VI_PIPE ViPipe;
1163 VI_CHN ViChn;
1164 VI_CHN_ATTR_S stChnAttr;
1165
1166 for (i = 0; i < WDR_MAX_PIPE_NUM; i++) {
1167 if ((pstViInfo->stPipeInfo.aPipe[i] >= 0) && (pstViInfo->stPipeInfo.aPipe[i] < VI_MAX_PIPE_NUM)) {
1168 if (pstViInfo->stDevInfo.enWDRMode == WDR_MODE_NONE) {
1169 bNeedChn = HI_TRUE;
1170 } else {
1171 bNeedChn = (i > 0) ? HI_FALSE : HI_TRUE;
1172 }
1173 if (bNeedChn) {
1174 ViPipe = pstViInfo->stPipeInfo.aPipe[i];
1175 ViChn = pstViInfo->stChnInfo.ViChn;
1176 SAMPLE_COMM_VI_GetChnAttrBySns(pstViInfo->stSnsInfo.enSnsType, &stChnAttr);
1177 stChnAttr.enDynamicRange = pstViInfo->stChnInfo.enDynamicRange;
1178 stChnAttr.enVideoFormat = pstViInfo->stChnInfo.enVideoFormat;
1179 stChnAttr.enPixelFormat = pstViInfo->stChnInfo.enPixFormat;
1180 stChnAttr.enCompressMode = pstViInfo->stChnInfo.enCompressMode;
1181 s32Ret = HI_MPI_VI_SetChnAttr(ViPipe, ViChn, &stChnAttr);
1182 if (s32Ret != HI_SUCCESS) {
1183 SAMPLE_PRT("HI_MPI_VI_SetChnAttr failed with %#x!\n", s32Ret);
1184 return s32Ret;
1185 }
1186 }
1187 }
1188 }
1189
1190 return s32Ret;
1191 }
1192
SAMPLE_COMM_VI_StartViChn(SAMPLE_VI_INFO_S * pstViInfo)1193 static HI_S32 SAMPLE_COMM_VI_StartViChn(SAMPLE_VI_INFO_S *pstViInfo)
1194 {
1195 HI_S32 i;
1196 HI_BOOL bNeedChn;
1197 HI_S32 s32Ret = HI_SUCCESS;
1198 VI_PIPE ViPipe;
1199 VI_CHN ViChn;
1200 VI_CHN_ATTR_S stChnAttr;
1201 VI_VPSS_MODE_E enMastPipeMode;
1202
1203 for (i = 0; i < WDR_MAX_PIPE_NUM; i++) {
1204 if ((pstViInfo->stPipeInfo.aPipe[i] >= 0) && (pstViInfo->stPipeInfo.aPipe[i] < VI_MAX_PIPE_NUM)) {
1205 if (pstViInfo->stDevInfo.enWDRMode == WDR_MODE_NONE) {
1206 bNeedChn = HI_TRUE;
1207 } else {
1208 bNeedChn = (i > 0) ? HI_FALSE : HI_TRUE;
1209 }
1210 if (bNeedChn) {
1211 ViPipe = pstViInfo->stPipeInfo.aPipe[i];
1212 ViChn = pstViInfo->stChnInfo.ViChn;
1213 SAMPLE_COMM_VI_GetChnAttrBySns(pstViInfo->stSnsInfo.enSnsType, &stChnAttr);
1214 stChnAttr.enDynamicRange = pstViInfo->stChnInfo.enDynamicRange;
1215 stChnAttr.enVideoFormat = pstViInfo->stChnInfo.enVideoFormat;
1216 stChnAttr.enPixelFormat = pstViInfo->stChnInfo.enPixFormat;
1217 stChnAttr.enCompressMode = pstViInfo->stChnInfo.enCompressMode;
1218 s32Ret = HI_MPI_VI_SetChnAttr(ViPipe, ViChn, &stChnAttr);
1219 if (s32Ret != HI_SUCCESS) {
1220 SAMPLE_PRT("HI_MPI_VI_SetChnAttr failed with %#x!\n", s32Ret);
1221 return s32Ret;
1222 }
1223
1224 enMastPipeMode = pstViInfo->stPipeInfo.enMastPipeMode;
1225 if ((enMastPipeMode == VI_OFFLINE_VPSS_OFFLINE) || (enMastPipeMode == VI_ONLINE_VPSS_OFFLINE)) {
1226 s32Ret = HI_MPI_VI_EnableChn(ViPipe, ViChn);
1227 if (s32Ret != HI_SUCCESS) {
1228 SAMPLE_PRT("HI_MPI_VI_EnableChn failed with %#x!\n", s32Ret);
1229 return s32Ret;
1230 }
1231 }
1232 }
1233 }
1234 }
1235
1236 return s32Ret;
1237 }
1238
SAMPLE_COMM_VI_StopViChn(SAMPLE_VI_INFO_S * pstViInfo)1239 static HI_S32 SAMPLE_COMM_VI_StopViChn(SAMPLE_VI_INFO_S *pstViInfo)
1240 {
1241 HI_S32 i;
1242 HI_BOOL bNeedChn;
1243 HI_S32 s32Ret = HI_SUCCESS;
1244 VI_PIPE ViPipe;
1245 VI_CHN ViChn;
1246 VI_VPSS_MODE_E enMastPipeMode;
1247
1248 for (i = 0; i < WDR_MAX_PIPE_NUM; i++) {
1249 if ((pstViInfo->stPipeInfo.aPipe[i] >= 0) && (pstViInfo->stPipeInfo.aPipe[i] < VI_MAX_PIPE_NUM)) {
1250 if (pstViInfo->stDevInfo.enWDRMode == WDR_MODE_NONE) {
1251 bNeedChn = HI_TRUE;
1252 } else {
1253 bNeedChn = (i > 0) ? HI_FALSE : HI_TRUE;
1254 }
1255 if (bNeedChn) {
1256 enMastPipeMode = pstViInfo->stPipeInfo.enMastPipeMode;
1257 if ((enMastPipeMode == VI_OFFLINE_VPSS_OFFLINE) || (enMastPipeMode == VI_ONLINE_VPSS_OFFLINE)) {
1258 ViPipe = pstViInfo->stPipeInfo.aPipe[i];
1259 ViChn = pstViInfo->stChnInfo.ViChn;
1260 s32Ret = HI_MPI_VI_DisableChn(ViPipe, ViChn);
1261 if (s32Ret != HI_SUCCESS) {
1262 SAMPLE_PRT("HI_MPI_VI_DisableChn failed with %#x!\n", s32Ret);
1263 return s32Ret;
1264 }
1265 }
1266 }
1267 }
1268 }
1269
1270 return s32Ret;
1271 }
1272
SAMPLE_COMM_VI_CreateSingleVi(SAMPLE_VI_INFO_S * pstViInfo)1273 HI_S32 SAMPLE_COMM_VI_CreateSingleVi(SAMPLE_VI_INFO_S *pstViInfo)
1274 {
1275 HI_S32 s32Ret;
1276
1277 if (pstViInfo == NULL) {
1278 SAMPLE_PRT("null pointer\n");
1279 return HI_FAILURE;
1280 }
1281 s32Ret = SAMPLE_COMM_VI_StartDev(pstViInfo);
1282 if (s32Ret != HI_SUCCESS) {
1283 SAMPLE_PRT("SAMPLE_COMM_VI_StartDev failed !\n");
1284 return s32Ret;
1285 }
1286
1287 /* we should bind pipe, then create pipe. */
1288 s32Ret = SAMPLE_COMM_VI_BindPipeDev(pstViInfo);
1289 if (s32Ret != HI_SUCCESS) {
1290 SAMPLE_PRT("SAMPLE_COMM_VI_BindPipeDev failed !\n");
1291 goto EXIT1;
1292 }
1293
1294 s32Ret = SAMPLE_COMM_VI_StartViPipe(pstViInfo);
1295 if (s32Ret != HI_SUCCESS) {
1296 SAMPLE_PRT("SAMPLE_COMM_VI_StartViPipe failed !\n");
1297 goto EXIT1;
1298 }
1299
1300 s32Ret = SAMPLE_COMM_VI_StartViChn(pstViInfo);
1301 if (s32Ret != HI_SUCCESS) {
1302 SAMPLE_PRT("SAMPLE_COMM_VI_StartViChn failed !\n");
1303 goto EXIT2;
1304 }
1305
1306 return s32Ret;
1307
1308 EXIT2:
1309 SAMPLE_COMM_VI_StopViPipe(pstViInfo);
1310 EXIT1:
1311 SAMPLE_COMM_VI_StopDev(pstViInfo);
1312 return s32Ret;
1313 }
1314
SAMPLE_COMM_ModeSwitch_VI_CreateSingleVi(SAMPLE_VI_INFO_S * pstViInfo)1315 HI_S32 SAMPLE_COMM_ModeSwitch_VI_CreateSingleVi(SAMPLE_VI_INFO_S *pstViInfo)
1316 {
1317 HI_S32 s32Ret;
1318
1319 if (pstViInfo == NULL) {
1320 SAMPLE_PRT("null pointer\n");
1321 return HI_FAILURE;
1322 }
1323
1324 s32Ret = SAMPLE_COMM_VI_StartDev(pstViInfo);
1325 if (s32Ret != HI_SUCCESS) {
1326 SAMPLE_PRT("SAMPLE_COMM_VI_StartDev failed !\n");
1327 return s32Ret;
1328 }
1329
1330 /* we should bind pipe,then create pipe */
1331 s32Ret = SAMPLE_COMM_VI_BindPipeDev(pstViInfo);
1332 if (s32Ret != HI_SUCCESS) {
1333 SAMPLE_PRT("SAMPLE_COMM_VI_BindPipeDev failed !\n");
1334 goto EXIT1;
1335 }
1336
1337 s32Ret = SAMPLE_COMM_VI_ModeSwitch_StartViPipe(pstViInfo);
1338 if (s32Ret != HI_SUCCESS) {
1339 SAMPLE_PRT("SAMPLE_COMM_VI_ModeSwitch_StartViPipe failed !\n");
1340 goto EXIT1;
1341 }
1342
1343 s32Ret = SAMPLE_COMM_VI_ModeSwitch_StartViChn(pstViInfo);
1344 if (s32Ret != HI_SUCCESS) {
1345 SAMPLE_PRT("SAMPLE_COMM_VI_ModeSwitch_StartViChn failed !\n");
1346 goto EXIT2;
1347 }
1348
1349 return HI_SUCCESS;
1350
1351 EXIT2:
1352 SAMPLE_COMM_VI_StopViPipe(pstViInfo);
1353 EXIT1:
1354 SAMPLE_COMM_VI_StopDev(pstViInfo);
1355 return s32Ret;
1356 }
1357
SAMPLE_COMM_VI_StartPipe_Chn(SAMPLE_VI_INFO_S * pstViInfo)1358 static HI_S32 SAMPLE_COMM_VI_StartPipe_Chn(SAMPLE_VI_INFO_S *pstViInfo)
1359 {
1360 HI_S32 s32Ret;
1361
1362 s32Ret = SAMPLE_COMM_VI_ModeSwitch_EnableViPipe(pstViInfo);
1363 if (s32Ret != HI_SUCCESS) {
1364 SAMPLE_PRT("SAMPLE_COMM_VI_ModeSwitch_EnableViPipe failed !\n");
1365 goto EXIT1;
1366 }
1367
1368 s32Ret = SAMPLE_COMM_VI_StartViChn(pstViInfo);
1369 if (s32Ret != HI_SUCCESS) {
1370 SAMPLE_PRT("SAMPLE_COMM_VI_StartViChn failed !\n");
1371 goto EXIT2;
1372 }
1373
1374 return s32Ret;
1375
1376 EXIT2:
1377 SAMPLE_COMM_VI_StopViPipe(pstViInfo);
1378 EXIT1:
1379 SAMPLE_COMM_VI_StopDev(pstViInfo);
1380 return s32Ret;
1381 }
1382
SAMPLE_COMM_VI_DestroySingleVi(SAMPLE_VI_INFO_S * pstViInfo)1383 HI_VOID SAMPLE_COMM_VI_DestroySingleVi(SAMPLE_VI_INFO_S *pstViInfo)
1384 {
1385 SAMPLE_COMM_VI_StopViChn(pstViInfo);
1386
1387 SAMPLE_COMM_VI_StopViPipe(pstViInfo);
1388
1389 SAMPLE_COMM_VI_StopDev(pstViInfo);
1390 }
1391
SAMPLE_COMM_VI_CreateVi(SAMPLE_VI_CONFIG_S * pstViConfig)1392 HI_S32 SAMPLE_COMM_VI_CreateVi(SAMPLE_VI_CONFIG_S *pstViConfig)
1393 {
1394 HI_S32 i, j;
1395 HI_S32 s32ViNum;
1396 HI_S32 s32Ret = HI_FAILURE;
1397 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
1398
1399 if (pstViConfig == HI_NULL) {
1400 SAMPLE_PRT("null ptr\n");
1401 return s32Ret;
1402 }
1403
1404 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
1405 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
1406 return s32Ret;
1407 }
1408
1409 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
1410 s32ViNum = pstViConfig->as32WorkingViId[i];
1411 if (s32ViNum >= VI_MAX_DEV_NUM) {
1412 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
1413 goto EXIT;
1414 }
1415
1416 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
1417 s32Ret = SAMPLE_COMM_VI_CreateSingleVi(pstViInfo);
1418 if (s32Ret != HI_SUCCESS) {
1419 SAMPLE_PRT("SAMPLE_COMM_VI_CreateSingleVi failed !\n");
1420 goto EXIT;
1421 }
1422 }
1423
1424 return s32Ret;
1425
1426 EXIT:
1427 for (j = 0; j < i; j++) {
1428 s32ViNum = pstViConfig->as32WorkingViId[j];
1429 if (s32ViNum >= VI_MAX_DEV_NUM) {
1430 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
1431 continue;
1432 }
1433
1434 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
1435 SAMPLE_COMM_VI_DestroySingleVi(pstViInfo);
1436 }
1437 return s32Ret;
1438 }
1439
SAMPLE_COMM_ModeSwitch_VI_CreateVi(SAMPLE_VI_CONFIG_S * pstViConfig)1440 static HI_S32 SAMPLE_COMM_ModeSwitch_VI_CreateVi(SAMPLE_VI_CONFIG_S *pstViConfig)
1441 {
1442 HI_S32 i, j;
1443 HI_S32 s32ViNum;
1444 HI_S32 s32Ret = HI_FAILURE;
1445 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
1446
1447 if (pstViConfig == HI_NULL) {
1448 SAMPLE_PRT("null ptr\n");
1449 return s32Ret;
1450 }
1451
1452 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
1453 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
1454 return s32Ret;
1455 }
1456
1457 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
1458 s32ViNum = pstViConfig->as32WorkingViId[i];
1459 if (s32ViNum >= VI_MAX_DEV_NUM) {
1460 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
1461 goto EXIT;
1462 }
1463
1464 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
1465 s32Ret = SAMPLE_COMM_ModeSwitch_VI_CreateSingleVi(pstViInfo);
1466 if (s32Ret != HI_SUCCESS) {
1467 SAMPLE_PRT("SAMPLE_COMM_ModeSwitch_VI_CreateSingleVi failed!\n");
1468 goto EXIT;
1469 }
1470 }
1471
1472 return s32Ret;
1473
1474 EXIT:
1475 for (j = 0; j < i; j++) {
1476 s32ViNum = pstViConfig->as32WorkingViId[j];
1477 if (s32ViNum >= VI_MAX_DEV_NUM) {
1478 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
1479 continue;
1480 }
1481
1482 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
1483 SAMPLE_COMM_VI_DestroySingleVi(pstViInfo);
1484 }
1485 return s32Ret;
1486 }
1487
SAMPLE_COMM_VI_DestroyVi(SAMPLE_VI_CONFIG_S * pstViConfig)1488 HI_S32 SAMPLE_COMM_VI_DestroyVi(SAMPLE_VI_CONFIG_S *pstViConfig)
1489 {
1490 HI_S32 i;
1491 HI_S32 s32ViNum;
1492 HI_S32 s32Ret = HI_FAILURE;
1493 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
1494
1495 if (pstViConfig == HI_NULL) {
1496 SAMPLE_PRT("null ptr\n");
1497 return s32Ret;
1498 }
1499
1500 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
1501 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
1502 return s32Ret;
1503 }
1504
1505 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
1506 s32ViNum = pstViConfig->as32WorkingViId[i];
1507 if (s32ViNum >= VI_MAX_DEV_NUM) {
1508 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
1509 continue;
1510 }
1511
1512 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
1513 SAMPLE_COMM_VI_DestroySingleVi(pstViInfo);
1514 }
1515
1516 return HI_SUCCESS;
1517 }
1518
SAMPLE_COMM_VI_StartIsp(SAMPLE_VI_INFO_S * pstViInfo)1519 HI_S32 SAMPLE_COMM_VI_StartIsp(SAMPLE_VI_INFO_S *pstViInfo)
1520 {
1521 HI_S32 i;
1522 HI_BOOL bNeedPipe;
1523 HI_S32 s32Ret = HI_SUCCESS;
1524 VI_PIPE ViPipe;
1525 HI_U32 u32SnsId;
1526 ISP_PUB_ATTR_S stPubAttr;
1527 VI_PIPE_ATTR_S stPipeAttr;
1528
1529 if (pstViInfo == NULL) {
1530 SAMPLE_PRT("null pointer\n");
1531 return HI_FAILURE;
1532 }
1533 SAMPLE_COMM_VI_GetPipeAttrBySns(pstViInfo->stSnsInfo.enSnsType, &stPipeAttr);
1534 if (stPipeAttr.enPipeBypassMode == VI_PIPE_BYPASS_BE) {
1535 return s32Ret;
1536 }
1537
1538 for (i = 0; i < WDR_MAX_PIPE_NUM; i++) {
1539 if ((pstViInfo->stPipeInfo.aPipe[i] >= 0) && (pstViInfo->stPipeInfo.aPipe[i] < VI_MAX_PIPE_NUM)) {
1540 SAMPLE_COMM_ISP_GetIspAttrBySns(pstViInfo->stSnsInfo.enSnsType, &stPubAttr);
1541 stPubAttr.enWDRMode = pstViInfo->stDevInfo.enWDRMode;
1542 ViPipe = pstViInfo->stPipeInfo.aPipe[i];
1543 if (pstViInfo->stDevInfo.enWDRMode == WDR_MODE_NONE) {
1544 bNeedPipe = HI_TRUE;
1545 } else {
1546 bNeedPipe = (i > 0) ? HI_FALSE : HI_TRUE;
1547 }
1548 if (bNeedPipe != HI_TRUE) {
1549 continue;
1550 }
1551
1552 u32SnsId = pstViInfo->stSnsInfo.s32SnsId;
1553 s32Ret = SAMPLE_COMM_ISP_Sensor_Regiter_callback(ViPipe, u32SnsId);
1554 if (s32Ret != HI_SUCCESS) {
1555 SAMPLE_PRT("register sensor %d to ISP %d failed\n", u32SnsId, ViPipe);
1556 SAMPLE_COMM_ISP_Stop(ViPipe);
1557 return s32Ret;
1558 }
1559
1560 if (((pstViInfo->stSnapInfo.bDoublePipe) && (pstViInfo->stSnapInfo.SnapPipe == ViPipe)) ||
1561 ((pstViInfo->stPipeInfo.bMultiPipe) && (i > 0))) {
1562 s32Ret = SAMPLE_COMM_ISP_BindSns(ViPipe, u32SnsId, pstViInfo->stSnsInfo.enSnsType, -1);
1563 if (s32Ret != HI_SUCCESS) {
1564 SAMPLE_PRT("register sensor %d bus id %d failed\n", u32SnsId, pstViInfo->stSnsInfo.s32BusId);
1565 SAMPLE_COMM_ISP_Stop(ViPipe);
1566 return s32Ret;
1567 }
1568 } else {
1569 s32Ret = SAMPLE_COMM_ISP_BindSns(ViPipe, u32SnsId, pstViInfo->stSnsInfo.enSnsType,
1570 pstViInfo->stSnsInfo.s32BusId);
1571 if (s32Ret != HI_SUCCESS) {
1572 SAMPLE_PRT("register sensor %d bus id %d failed\n", u32SnsId, pstViInfo->stSnsInfo.s32BusId);
1573 SAMPLE_COMM_ISP_Stop(ViPipe);
1574 return s32Ret;
1575 }
1576 }
1577
1578 s32Ret = SAMPLE_COMM_ISP_Aelib_Callback(ViPipe);
1579 if (s32Ret != HI_SUCCESS) {
1580 SAMPLE_PRT("SAMPLE_COMM_ISP_Aelib_Callback failed\n");
1581 SAMPLE_COMM_ISP_Stop(ViPipe);
1582 return s32Ret;
1583 }
1584
1585 s32Ret = SAMPLE_COMM_ISP_Awblib_Callback(ViPipe);
1586 if (s32Ret != HI_SUCCESS) {
1587 SAMPLE_PRT("SAMPLE_COMM_ISP_Awblib_Callback failed\n");
1588 SAMPLE_COMM_ISP_Stop(ViPipe);
1589 return s32Ret;
1590 }
1591
1592 s32Ret = HI_MPI_ISP_MemInit(ViPipe);
1593 if (s32Ret != HI_SUCCESS) {
1594 SAMPLE_PRT("Init Ext memory failed with %#x!\n", s32Ret);
1595 SAMPLE_COMM_ISP_Stop(ViPipe);
1596 return s32Ret;
1597 }
1598
1599 s32Ret = HI_MPI_ISP_SetPubAttr(ViPipe, &stPubAttr);
1600 if (s32Ret != HI_SUCCESS) {
1601 SAMPLE_PRT("SetPubAttr failed with %#x!\n", s32Ret);
1602 SAMPLE_COMM_ISP_Stop(ViPipe);
1603 return s32Ret;
1604 }
1605
1606 s32Ret = HI_MPI_ISP_Init(ViPipe);
1607 if (s32Ret != HI_SUCCESS) {
1608 SAMPLE_PRT("ISP Init failed with %#x!\n", s32Ret);
1609 SAMPLE_COMM_ISP_Stop(ViPipe);
1610 return s32Ret;
1611 }
1612
1613 s32Ret = SAMPLE_COMM_ISP_Run(ViPipe);
1614 if (s32Ret != HI_SUCCESS) {
1615 SAMPLE_PRT("ISP Run failed with %#x!\n", s32Ret);
1616 SAMPLE_COMM_ISP_Stop(ViPipe);
1617 return s32Ret;
1618 }
1619 }
1620 }
1621
1622 return s32Ret;
1623 }
1624
SAMPLE_COMM_VI_StopIsp(SAMPLE_VI_INFO_S * pstViInfo)1625 HI_S32 SAMPLE_COMM_VI_StopIsp(SAMPLE_VI_INFO_S *pstViInfo)
1626 {
1627 HI_S32 i;
1628 HI_BOOL bNeedPipe;
1629 VI_PIPE ViPipe;
1630
1631 if (pstViInfo == NULL) {
1632 SAMPLE_PRT("null pointer\n");
1633 return HI_FAILURE;
1634 }
1635 for (i = 0; i < WDR_MAX_PIPE_NUM; i++) {
1636 if ((pstViInfo->stPipeInfo.aPipe[i] >= 0) && (pstViInfo->stPipeInfo.aPipe[i] < VI_MAX_PIPE_NUM)) {
1637 if (pstViInfo->stDevInfo.enWDRMode == WDR_MODE_NONE) {
1638 bNeedPipe = HI_TRUE;
1639 } else {
1640 bNeedPipe = (i > 0) ? HI_FALSE : HI_TRUE;
1641 }
1642 if (bNeedPipe != HI_TRUE) {
1643 continue;
1644 }
1645 ViPipe = pstViInfo->stPipeInfo.aPipe[i];
1646 SAMPLE_COMM_ISP_Stop(ViPipe);
1647 }
1648 }
1649
1650 return HI_SUCCESS;
1651 }
1652
SAMPLE_COMM_VI_CreateIsp(SAMPLE_VI_CONFIG_S * pstViConfig)1653 static HI_S32 SAMPLE_COMM_VI_CreateIsp(SAMPLE_VI_CONFIG_S *pstViConfig)
1654 {
1655 HI_S32 i;
1656 HI_S32 s32ViNum;
1657 HI_S32 s32Ret = HI_FAILURE;
1658 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
1659
1660 if (pstViConfig == HI_NULL) {
1661 SAMPLE_PRT("null ptr\n");
1662 return s32Ret;
1663 }
1664
1665 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
1666 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
1667 return s32Ret;
1668 }
1669
1670 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
1671 s32ViNum = pstViConfig->as32WorkingViId[i];
1672 if (s32ViNum >= VI_MAX_DEV_NUM) {
1673 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
1674 return s32Ret;
1675 }
1676
1677 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
1678 s32Ret = SAMPLE_COMM_VI_StartIsp(pstViInfo);
1679 if (s32Ret != HI_SUCCESS) {
1680 SAMPLE_PRT("SAMPLE_COMM_VI_StartIsp failed !\n");
1681 return s32Ret;
1682 }
1683 }
1684
1685 return s32Ret;
1686 }
1687
SAMPLE_COMM_VI_DestroyIsp(SAMPLE_VI_CONFIG_S * pstViConfig)1688 static HI_S32 SAMPLE_COMM_VI_DestroyIsp(SAMPLE_VI_CONFIG_S *pstViConfig)
1689 {
1690 HI_S32 i;
1691 HI_S32 s32ViNum;
1692 HI_S32 s32Ret = HI_FAILURE;
1693 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
1694
1695 if (pstViConfig == HI_NULL) {
1696 SAMPLE_PRT("null ptr\n");
1697 return s32Ret;
1698 }
1699
1700 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
1701 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
1702 return s32Ret;
1703 }
1704
1705 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
1706 s32ViNum = pstViConfig->as32WorkingViId[i];
1707 if (s32ViNum >= VI_MAX_DEV_NUM) {
1708 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
1709 continue;
1710 }
1711
1712 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
1713 s32Ret = SAMPLE_COMM_VI_StopIsp(pstViInfo);
1714 if (s32Ret != HI_SUCCESS) {
1715 SAMPLE_PRT("SAMPLE_COMM_VI_StopIsp failed !\n");
1716 return s32Ret;
1717 }
1718 }
1719
1720 return s32Ret;
1721 }
1722
SAMPLE_COMM_VI_StartVi(SAMPLE_VI_CONFIG_S * pstViConfig)1723 HI_S32 SAMPLE_COMM_VI_StartVi(SAMPLE_VI_CONFIG_S *pstViConfig)
1724 {
1725 HI_S32 s32Ret = HI_FAILURE;
1726
1727 if (pstViConfig == HI_NULL) {
1728 SAMPLE_PRT("%s: null ptr\n", __FUNCTION__);
1729 return s32Ret;
1730 }
1731
1732 s32Ret = SAMPLE_COMM_VI_StartMIPI(pstViConfig);
1733 if (s32Ret != HI_SUCCESS) {
1734 SAMPLE_PRT("SAMPLE_COMM_VI_StartMIPI failed!\n");
1735 return s32Ret;
1736 }
1737
1738 s32Ret = SAMPLE_COMM_VI_SetParam(pstViConfig);
1739 if (s32Ret != HI_SUCCESS) {
1740 SAMPLE_PRT("SAMPLE_COMM_VI_SetParam failed!\n");
1741 return s32Ret;
1742 }
1743
1744 s32Ret = SAMPLE_COMM_VI_CreateVi(pstViConfig);
1745 if (s32Ret != HI_SUCCESS) {
1746 SAMPLE_PRT("SAMPLE_COMM_VI_CreateVi failed!\n");
1747 return s32Ret;
1748 }
1749
1750 s32Ret = SAMPLE_COMM_VI_CreateIsp(pstViConfig);
1751 if (s32Ret != HI_SUCCESS) {
1752 SAMPLE_COMM_VI_DestroyVi(pstViConfig);
1753 SAMPLE_PRT("SAMPLE_COMM_VI_CreateIsp failed!\n");
1754 return s32Ret;
1755 }
1756
1757 return s32Ret;
1758 }
1759
SAMPLE_COMM_VI_StopVi(SAMPLE_VI_CONFIG_S * pstViConfig)1760 HI_S32 SAMPLE_COMM_VI_StopVi(SAMPLE_VI_CONFIG_S *pstViConfig)
1761 {
1762 HI_S32 s32Ret;
1763
1764 s32Ret = SAMPLE_COMM_VI_DestroyIsp(pstViConfig);
1765 if (s32Ret != HI_SUCCESS) {
1766 SAMPLE_PRT("SAMPLE_COMM_VI_DestroyIsp failed !\n");
1767 return s32Ret;
1768 }
1769
1770 s32Ret = SAMPLE_COMM_VI_DestroyVi(pstViConfig);
1771 if (s32Ret != HI_SUCCESS) {
1772 SAMPLE_PRT("SAMPLE_COMM_VI_DestroyVi failed !\n");
1773 return s32Ret;
1774 }
1775
1776 s32Ret = SAMPLE_COMM_VI_StopMIPI(pstViConfig);
1777 if (s32Ret != HI_SUCCESS) {
1778 SAMPLE_PRT("SAMPLE_COMM_VI_StopMIPI failed !\n");
1779 return s32Ret;
1780 }
1781
1782 return s32Ret;
1783 }
1784
SAMPLE_COMM_VI_SwitchISPMode(SAMPLE_VI_CONFIG_S * pstViConfig)1785 HI_S32 SAMPLE_COMM_VI_SwitchISPMode(SAMPLE_VI_CONFIG_S *pstViConfig)
1786 {
1787 HI_S32 i, j;
1788 HI_S32 s32ViNum;
1789 HI_S32 s32Ret = HI_FAILURE;
1790 HI_BOOL bNeedPipe;
1791 HI_BOOL bSwitchWDR[VI_MAX_PIPE_NUM] = { HI_FALSE };
1792 VI_PIPE ViPipe;
1793 ISP_PUB_ATTR_S stPubAttr;
1794 ISP_PUB_ATTR_S stPrePubAttr;
1795 SAMPLE_VI_INFO_S *pstViInfo = HI_NULL;
1796 ISP_INNER_STATE_INFO_S stInnerStateInfo = { 0 };
1797 HI_BOOL bSwitchFinish;
1798
1799 if (pstViConfig == HI_NULL) {
1800 SAMPLE_PRT("null ptr\n");
1801 return s32Ret;
1802 }
1803
1804 if (pstViConfig->s32WorkingViNum > VI_MAX_DEV_NUM) {
1805 SAMPLE_PRT("Invalid workingViNum, %d\n", pstViConfig->s32WorkingViNum);
1806 return s32Ret;
1807 }
1808
1809 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
1810 s32ViNum = pstViConfig->as32WorkingViId[i];
1811 if (s32ViNum >= VI_MAX_DEV_NUM) {
1812 SAMPLE_PRT("Invalid s32ViNum:%d\n", s32ViNum);
1813 return s32Ret;
1814 }
1815
1816 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
1817 for (j = 0; j < WDR_MAX_PIPE_NUM; j++) {
1818 ViPipe = pstViInfo->stPipeInfo.aPipe[j];
1819 if ((ViPipe >= 0) && (ViPipe < VI_MAX_PIPE_NUM)) {
1820 SAMPLE_COMM_ISP_GetIspAttrBySns(pstViInfo->stSnsInfo.enSnsType, &stPubAttr);
1821 stPubAttr.enWDRMode = pstViInfo->stDevInfo.enWDRMode;
1822 SAMPLE_PRT("SAMPLE_COMM_VI_SwitchISPMode enWDRMode is %d!\n", stPubAttr.enWDRMode);
1823 if (pstViInfo->stDevInfo.enWDRMode == WDR_MODE_NONE) {
1824 bNeedPipe = HI_TRUE;
1825 } else {
1826 bNeedPipe = (j > 0) ? HI_FALSE : HI_TRUE;
1827 }
1828 if (bNeedPipe != HI_TRUE) {
1829 continue;
1830 }
1831
1832 s32Ret = HI_MPI_ISP_GetPubAttr(ViPipe, &stPrePubAttr);
1833 if (s32Ret != HI_SUCCESS) {
1834 SAMPLE_PRT("GetPubAttr failed with %#x!\n", s32Ret);
1835 SAMPLE_COMM_ISP_Stop(ViPipe);
1836 return s32Ret;
1837 }
1838
1839 s32Ret = HI_MPI_ISP_SetPubAttr(ViPipe, &stPubAttr);
1840 if (s32Ret != HI_SUCCESS) {
1841 SAMPLE_PRT("SetPubAttr failed with %#x!\n", s32Ret);
1842 SAMPLE_COMM_ISP_Stop(ViPipe);
1843 return s32Ret;
1844 }
1845
1846 if (stPrePubAttr.enWDRMode != stPubAttr.enWDRMode) {
1847 bSwitchWDR[ViPipe] = HI_TRUE;
1848 }
1849 }
1850 }
1851 }
1852
1853 while (1) {
1854 bSwitchFinish = HI_TRUE;
1855 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
1856 s32ViNum = pstViConfig->as32WorkingViId[i];
1857 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
1858 ViPipe = pstViInfo->stPipeInfo.aPipe[0];
1859 if ((ViPipe >= 0) && (ViPipe < VI_MAX_PIPE_NUM)) {
1860 HI_MPI_ISP_QueryInnerStateInfo(ViPipe, &stInnerStateInfo);
1861 if (bSwitchWDR[ViPipe] == HI_TRUE) {
1862 bSwitchFinish = stInnerStateInfo.bWDRSwitchFinish;
1863 } else {
1864 bSwitchFinish = stInnerStateInfo.bResSwitchFinish;
1865 }
1866 if (bSwitchFinish == HI_FALSE) {
1867 break;
1868 }
1869 }
1870 }
1871
1872 if (bSwitchFinish == HI_TRUE) {
1873 SAMPLE_PRT("Switch finish!\n");
1874 break;
1875 } else {
1876 usleep(1000); /* sleep 1000us */
1877 }
1878 }
1879
1880 for (i = 0; i < pstViConfig->s32WorkingViNum; i++) {
1881 s32ViNum = pstViConfig->as32WorkingViId[i];
1882 pstViInfo = &pstViConfig->astViInfo[s32ViNum];
1883
1884 SAMPLE_COMM_VI_StartPipe_Chn(pstViInfo);
1885 }
1886
1887 return HI_SUCCESS;
1888 }
1889
SAMPLE_COMM_VI_SwitchMode_StopVI(SAMPLE_VI_CONFIG_S * pstViConfigSrc)1890 HI_S32 SAMPLE_COMM_VI_SwitchMode_StopVI(SAMPLE_VI_CONFIG_S *pstViConfigSrc)
1891 {
1892 HI_S32 s32Ret;
1893
1894 s32Ret = SAMPLE_COMM_VI_DestroyVi(pstViConfigSrc);
1895 if (s32Ret != HI_SUCCESS) {
1896 SAMPLE_PRT("SAMPLE_COMM_VI_DestroyVi failed !\n");
1897 return s32Ret;
1898 }
1899
1900 s32Ret = SAMPLE_COMM_VI_StopMIPI(pstViConfigSrc);
1901 if (s32Ret != HI_SUCCESS) {
1902 SAMPLE_PRT("SAMPLE_COMM_VI_StopMIPI failed !\n");
1903 return s32Ret;
1904 }
1905
1906 return s32Ret;
1907 }
1908
SAMPLE_COMM_VI_SwitchMode(SAMPLE_VI_CONFIG_S * pstViConfigDes)1909 HI_S32 SAMPLE_COMM_VI_SwitchMode(SAMPLE_VI_CONFIG_S *pstViConfigDes)
1910 {
1911 HI_S32 s32Ret;
1912
1913 s32Ret = SAMPLE_COMM_VI_StartMIPI(pstViConfigDes);
1914 if (s32Ret != HI_SUCCESS) {
1915 SAMPLE_PRT("SAMPLE_COMM_VI_StartMIPI failed!\n");
1916 return s32Ret;
1917 }
1918
1919 /* create vi without enable chn and enable pipe. */
1920 s32Ret = SAMPLE_COMM_ModeSwitch_VI_CreateVi(pstViConfigDes);
1921 if (s32Ret != HI_SUCCESS) {
1922 SAMPLE_PRT("SAMPLE_COMM_ModeSwitch_VI_CreateVi failed!\n");
1923 return s32Ret;
1924 }
1925
1926 s32Ret = SAMPLE_COMM_VI_SwitchISPMode(pstViConfigDes);
1927 if (s32Ret != HI_SUCCESS) {
1928 SAMPLE_PRT("SAMPLE_COMM_VI_SwitchISPMode failed!\n");
1929 return s32Ret;
1930 }
1931
1932 return s32Ret;
1933 }
1934
SAMPLE_COMM_VI_GetSizeBySensor(SAMPLE_SNS_TYPE_E enMode,PIC_SIZE_E * penSize)1935 HI_S32 SAMPLE_COMM_VI_GetSizeBySensor(SAMPLE_SNS_TYPE_E enMode, PIC_SIZE_E *penSize)
1936 {
1937 HI_S32 s32Ret = HI_FAILURE;
1938
1939 if (penSize == HI_NULL) {
1940 return s32Ret;
1941 }
1942
1943 switch (enMode) {
1944 case SONY_IMX335_MIPI_5M_30FPS_12BIT:
1945 case SONY_IMX335_MIPI_5M_30FPS_10BIT_WDR2TO1:
1946 *penSize = PIC_2592x1944;
1947 break;
1948
1949 case SONY_IMX335_MIPI_4M_30FPS_12BIT:
1950 case SONY_IMX335_MIPI_4M_30FPS_10BIT_WDR2TO1:
1951 *penSize = PIC_2592x1536;
1952 break;
1953
1954 default:
1955 *penSize = PIC_2592x1536;
1956 break;
1957 }
1958
1959 return HI_SUCCESS;
1960 }
1961
SAMPLE_COMM_VI_GetFrameRateBySensor(SAMPLE_SNS_TYPE_E enMode,HI_U32 * pu32FrameRate)1962 HI_S32 SAMPLE_COMM_VI_GetFrameRateBySensor(SAMPLE_SNS_TYPE_E enMode, HI_U32 *pu32FrameRate)
1963 {
1964 HI_S32 s32Ret = HI_FAILURE;
1965
1966 if (pu32FrameRate == HI_NULL) {
1967 return s32Ret;
1968 }
1969
1970 switch (enMode) {
1971 case SONY_IMX335_MIPI_5M_30FPS_12BIT:
1972 case SONY_IMX335_MIPI_5M_30FPS_10BIT_WDR2TO1:
1973 case SONY_IMX335_MIPI_4M_30FPS_12BIT:
1974 case SONY_IMX335_MIPI_4M_30FPS_10BIT_WDR2TO1:
1975 *pu32FrameRate = FPS_30;
1976 break;
1977
1978 default:
1979 *pu32FrameRate = FPS_30;
1980 break;
1981 }
1982
1983 return HI_SUCCESS;
1984 }
1985
SAMPLE_COMM_VI_GetSensorInfo(SAMPLE_VI_CONFIG_S * pstViConfig)1986 HI_VOID SAMPLE_COMM_VI_GetSensorInfo(SAMPLE_VI_CONFIG_S *pstViConfig)
1987 {
1988 HI_S32 i;
1989
1990 for (i = 0; i < VI_MAX_DEV_NUM; i++) {
1991 pstViConfig->astViInfo[i].stSnsInfo.s32SnsId = i;
1992 pstViConfig->astViInfo[i].stSnsInfo.s32BusId = i;
1993 pstViConfig->astViInfo[i].stSnsInfo.MipiDev = i;
1994 (hi_void)
1995 memset_s(&pstViConfig->astViInfo[i].stSnapInfo, sizeof(SAMPLE_SNAP_INFO_S), 0, sizeof(SAMPLE_SNAP_INFO_S));
1996 pstViConfig->astViInfo[i].stPipeInfo.bMultiPipe = HI_FALSE;
1997 pstViConfig->astViInfo[i].stPipeInfo.bVcNumCfged = HI_FALSE;
1998 }
1999
2000 pstViConfig->astViInfo[0].stSnsInfo.enSnsType = SENSOR0_TYPE;
2001 pstViConfig->astViInfo[1].stSnsInfo.enSnsType = SENSOR1_TYPE;
2002 }
2003
SAMPLE_COMM_VI_GetComboDevBySensor(SAMPLE_SNS_TYPE_E enMode,HI_S32 s32SnsIdx)2004 combo_dev_t SAMPLE_COMM_VI_GetComboDevBySensor(SAMPLE_SNS_TYPE_E enMode, HI_S32 s32SnsIdx)
2005 {
2006 combo_dev_t dev = 0;
2007
2008 switch (enMode) {
2009 case SONY_IMX335_MIPI_5M_30FPS_12BIT:
2010 case SONY_IMX335_MIPI_5M_30FPS_10BIT_WDR2TO1:
2011 case SONY_IMX335_MIPI_4M_30FPS_12BIT:
2012 case SONY_IMX335_MIPI_4M_30FPS_10BIT_WDR2TO1:
2013 dev = s32SnsIdx; /* sensor_id {0, 1} equal to dev_id {0, 1} when LANE_DIVIDE_MODE_1 */
2014 break;
2015
2016 default:
2017 break;
2018 }
2019
2020 return dev;
2021 }
2022
PRINT_FPNTYPE(ISP_FPN_TYPE_E enFpnType)2023 static HI_CHAR *PRINT_FPNTYPE(ISP_FPN_TYPE_E enFpnType)
2024 {
2025 if (ISP_FPN_TYPE_FRAME == enFpnType) {
2026 return "Frame";
2027 } else if (ISP_FPN_TYPE_LINE == enFpnType) {
2028 return "Line";
2029 } else {
2030 return "NA";
2031 }
2032 }
2033
SAMPLE_VI_PixelFormat2BitWidth(PIXEL_FORMAT_E enPixelFormat)2034 static HI_U32 SAMPLE_VI_PixelFormat2BitWidth(PIXEL_FORMAT_E enPixelFormat)
2035 {
2036 HI_U32 bitWidth;
2037
2038 switch (enPixelFormat) {
2039 case PIXEL_FORMAT_RGB_BAYER_8BPP:
2040 bitWidth = 8; /* RAW_8PP is 8bit width */
2041 break;
2042
2043 case PIXEL_FORMAT_RGB_BAYER_10BPP:
2044 bitWidth = 10; /* RAW_10PP is 10bit width */
2045 break;
2046
2047 case PIXEL_FORMAT_RGB_BAYER_12BPP:
2048 bitWidth = 12; /* RAW_12PP is 12bit width */
2049 break;
2050
2051 case PIXEL_FORMAT_RGB_BAYER_14BPP:
2052 bitWidth = 14; /* RAW_14PP is 14bit width */
2053 break;
2054
2055 case PIXEL_FORMAT_RGB_BAYER_16BPP:
2056 bitWidth = 16; /* RAW_16PP is 16bit width */
2057 break;
2058
2059 default:
2060 bitWidth = 8; /* default 8bit width */
2061 break;
2062 }
2063
2064 return bitWidth;
2065 }
2066
SAMPLE_VI_GetValidAlign(HI_U32 u32ByteAlign)2067 static HI_U32 SAMPLE_VI_GetValidAlign(HI_U32 u32ByteAlign)
2068 {
2069 if (u32ByteAlign == 0) {
2070 return DEFAULT_ALIGN;
2071 } else if (u32ByteAlign > MAX_ALIGN) {
2072 return MAX_ALIGN;
2073 } else {
2074 return (HI_ALIGN_UP(u32ByteAlign, DEFAULT_ALIGN));
2075 }
2076 }
2077
SAMPLE_VI_GetRawStride(PIXEL_FORMAT_E enPixelFormat,HI_U32 u32Width,HI_U32 u32ByteAlign)2078 static HI_U32 SAMPLE_VI_GetRawStride(PIXEL_FORMAT_E enPixelFormat, HI_U32 u32Width, HI_U32 u32ByteAlign)
2079 {
2080 HI_U32 u32Stride;
2081 HI_U32 u32BitWidth;
2082
2083 u32BitWidth = SAMPLE_VI_PixelFormat2BitWidth(enPixelFormat);
2084
2085 u32ByteAlign = SAMPLE_VI_GetValidAlign(u32ByteAlign);
2086
2087 u32Stride = HI_ALIGN_UP(HI_ALIGN_UP(u32Width * u32BitWidth, 8) / 8, u32ByteAlign); /* 8 align */
2088
2089 return u32Stride;
2090 }
2091
SAMPLE_VI_GetFrameBlkInfo(SAMPLE_VI_FRAME_CONFIG_S * pstFrmCfg,HI_S32 s32FrmCnt,SAMPLE_VI_FRAME_INFO_S * pastViFrameInfo)2092 static HI_S32 SAMPLE_VI_GetFrameBlkInfo(SAMPLE_VI_FRAME_CONFIG_S *pstFrmCfg, HI_S32 s32FrmCnt,
2093 SAMPLE_VI_FRAME_INFO_S *pastViFrameInfo)
2094 {
2095 HI_S32 i;
2096 HI_U32 u32Stride;
2097 HI_U32 u32LStride;
2098 HI_U32 u32CStride;
2099 HI_U32 u32LumaSize = 0;
2100 HI_U32 u32ChrmSize = 0;
2101 HI_U32 u32Size;
2102 HI_U64 u64PhyAddr;
2103 HI_U8 *pVirAddr = HI_NULL;
2104 VB_POOL u32PoolId;
2105 VB_BLK VbBlk;
2106 PIXEL_FORMAT_E enPixelFormat;
2107 VB_POOL_CONFIG_S stVbPoolCfg;
2108
2109 enPixelFormat = pstFrmCfg->enPixelFormat;
2110 if (enPixelFormat == PIXEL_FORMAT_YVU_SEMIPLANAR_422) {
2111 u32Stride = HI_ALIGN_UP((pstFrmCfg->u32Width * 8 + 8 - 1) / 8, DEFAULT_ALIGN); /* 8 align */
2112 u32Size = u32Stride * pstFrmCfg->u32Height * 2; /* YUV422 size is 2 * stride * h */
2113 u32LumaSize = u32Stride * pstFrmCfg->u32Height;
2114 u32ChrmSize = u32Stride * pstFrmCfg->u32Height / 2; /* one chroma size is (size / 2 / 2). */
2115 } else if (enPixelFormat == PIXEL_FORMAT_YVU_SEMIPLANAR_420) {
2116 u32Stride = HI_ALIGN_UP((pstFrmCfg->u32Width * 8 + 8 - 1) / 8, DEFAULT_ALIGN); /* 8 align */
2117 u32Size = u32Stride * pstFrmCfg->u32Height * 3 / 2; /* YUV420 size is stride * h * 3 / 2 */
2118 u32LumaSize = u32Stride * pstFrmCfg->u32Height;
2119 u32ChrmSize = u32Stride * pstFrmCfg->u32Height / 4; /* one chroma size is (stride * h / 4). */
2120 } else if (enPixelFormat == PIXEL_FORMAT_YUV_400) {
2121 u32Stride = HI_ALIGN_UP((pstFrmCfg->u32Width * 8 + 8 - 1) / 8, DEFAULT_ALIGN); /* 8 align */
2122 u32Size = u32Stride * pstFrmCfg->u32Height;
2123 u32LumaSize = u32Size;
2124 u32ChrmSize = 0;
2125 } else { /* RAW8 ~ RAW16 */
2126 u32Stride = SAMPLE_VI_GetRawStride(enPixelFormat, pstFrmCfg->u32Width, pstFrmCfg->u32ByteAlign);
2127 u32Size = u32Stride * pstFrmCfg->u32Height;
2128 }
2129 u32LStride = u32Stride;
2130 u32CStride = u32Stride;
2131
2132 (hi_void)memset_s(&stVbPoolCfg, sizeof(VB_POOL_CONFIG_S), 0, sizeof(VB_POOL_CONFIG_S));
2133 stVbPoolCfg.u64BlkSize = u32Size;
2134 stVbPoolCfg.u32BlkCnt = s32FrmCnt;
2135 stVbPoolCfg.enRemapMode = VB_REMAP_MODE_NONE;
2136 u32PoolId = HI_MPI_VB_CreatePool(&stVbPoolCfg);
2137 if (u32PoolId == VB_INVALID_POOLID) {
2138 SAMPLE_PRT("HI_MPI_VB_CreatePool failed!\n");
2139 return HI_FAILURE;
2140 }
2141
2142 for (i = 0; i < s32FrmCnt; i++) {
2143 VbBlk = HI_MPI_VB_GetBlock(u32PoolId, u32Size, HI_NULL);
2144 if (VbBlk == VB_INVALID_HANDLE) {
2145 SAMPLE_PRT("HI_MPI_VB_GetBlock err! size:%d\n", u32Size);
2146 return HI_FAILURE;
2147 }
2148
2149 u64PhyAddr = HI_MPI_VB_Handle2PhysAddr(VbBlk);
2150 if (u64PhyAddr == 0) {
2151 SAMPLE_PRT("HI_MPI_VB_Handle2PhysAddr err!\n");
2152 return HI_FAILURE;
2153 }
2154
2155 pVirAddr = (HI_U8 *)HI_MPI_SYS_Mmap(u64PhyAddr, u32Size);
2156 if (pVirAddr == HI_NULL) {
2157 SAMPLE_PRT("HI_MPI_SYS_Mmap err!\n");
2158 return HI_FAILURE;
2159 }
2160
2161 /* PhyAddr[0] -- luma addr, PhyAddr[1] -- chroma_U addr, PhyAddr[2] -- chroma_V addr */
2162 pastViFrameInfo[i].stVideoFrameInfo.u32PoolId = u32PoolId;
2163 pastViFrameInfo[i].stVideoFrameInfo.enModId = HI_ID_VI;
2164 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64PhyAddr[0] = u64PhyAddr;
2165 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64PhyAddr[1] =
2166 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64PhyAddr[0] + u32LumaSize;
2167 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64PhyAddr[2] = /* PhyAddr[2] -- chroma_V phy_addr */
2168 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64PhyAddr[1] + u32ChrmSize;
2169
2170 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64VirAddr[0] = (HI_U64)(HI_UINTPTR_T)pVirAddr;
2171 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64VirAddr[1] =
2172 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64VirAddr[0] + u32LumaSize;
2173 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64VirAddr[2] = /* VirAddr[2] -- chroma_V vir_addr */
2174 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64VirAddr[1] + u32ChrmSize;
2175
2176 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u32Stride[0] = u32LStride;
2177 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u32Stride[1] = u32CStride;
2178 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u32Stride[2] = u32CStride; /* Stride[2] -- chroma_V stride */
2179 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u32Width = pstFrmCfg->u32Width;
2180 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u32Height = pstFrmCfg->u32Height;
2181 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.enPixelFormat = pstFrmCfg->enPixelFormat;
2182 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.enVideoFormat = pstFrmCfg->enVideoFormat;
2183 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.enCompressMode = pstFrmCfg->enCompressMode;
2184 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.enDynamicRange = pstFrmCfg->enDynamicRange;
2185 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.enField = VIDEO_FIELD_FRAME;
2186 pastViFrameInfo[i].stVideoFrameInfo.stVFrame.enColorGamut = COLOR_GAMUT_BT709;
2187 pastViFrameInfo[i].VbBlk = VbBlk;
2188 pastViFrameInfo[i].u32Size = u32Size;
2189 }
2190
2191 return HI_SUCCESS;
2192 }
2193
SAMPLE_VI_COMM_ReleaseFrameBlkInfo(HI_S32 s32FrmCnt,SAMPLE_VI_FRAME_INFO_S * pastViFrameInfo)2194 static HI_VOID SAMPLE_VI_COMM_ReleaseFrameBlkInfo(HI_S32 s32FrmCnt, SAMPLE_VI_FRAME_INFO_S *pastViFrameInfo)
2195 {
2196 HI_S32 s32Ret;
2197 HI_S32 i;
2198 VB_POOL u32PoolId;
2199 VB_BLK VbBlk;
2200 HI_U32 u32Size;
2201
2202 if (pastViFrameInfo == NULL) {
2203 SAMPLE_PRT("null pointer\n");
2204 return;
2205 }
2206
2207 for (i = 0; i < s32FrmCnt; i++) {
2208 VbBlk = pastViFrameInfo[i].VbBlk;
2209 s32Ret = HI_MPI_VB_ReleaseBlock(VbBlk);
2210 if (s32Ret != HI_SUCCESS) {
2211 SAMPLE_PRT("HI_MPI_VB_ReleaseBlock block 0x%x failure\n", VbBlk);
2212 }
2213
2214 u32Size = pastViFrameInfo[i].u32Size;
2215 s32Ret = HI_MPI_SYS_Munmap((HI_VOID *)(HI_UINTPTR_T)pastViFrameInfo[i].stVideoFrameInfo.stVFrame.u64VirAddr[0],
2216 u32Size);
2217 if (s32Ret != HI_SUCCESS) {
2218 SAMPLE_PRT("HI_MPI_SYS_Munmap failure!\n");
2219 }
2220 }
2221
2222 u32PoolId = pastViFrameInfo[0].stVideoFrameInfo.u32PoolId;
2223 HI_MPI_VB_DestroyPool(u32PoolId);
2224
2225 return;
2226 }
2227
SAMPLE_COMM_VI_SaveFpnFile(ISP_FPN_FRAME_INFO_S * pVBuf,FILE * pfd)2228 static HI_VOID SAMPLE_COMM_VI_SaveFpnFile(ISP_FPN_FRAME_INFO_S *pVBuf, FILE *pfd)
2229 {
2230 HI_U8 *pU8VBufVirt_Y = HI_NULL;
2231 HI_U32 u32FpnHeight;
2232 HI_U32 i;
2233
2234 u32FpnHeight = pVBuf->stFpnFrame.stVFrame.u32Height;
2235 pU8VBufVirt_Y = (HI_U8 *)(HI_UINTPTR_T)pVBuf->stFpnFrame.stVFrame.u64VirAddr[0];
2236
2237 /* save Y ---------------------------------------------------------------- */
2238 (HI_VOID)fprintf(stderr, "FPN: saving......Raw data......u32Stride[0]: %d, width: %d, height: %d\n",
2239 pVBuf->stFpnFrame.stVFrame.u32Stride[0], pVBuf->stFpnFrame.stVFrame.u32Width, u32FpnHeight);
2240 (HI_VOID)fprintf(stderr, "phy Addr: 0x%llx\n", pVBuf->stFpnFrame.stVFrame.u64PhyAddr[0]);
2241 (HI_VOID)fprintf(stderr, "Please wait a moment to save data.\n");
2242 (HI_VOID)fflush(stderr);
2243
2244 (HI_VOID)fwrite(pU8VBufVirt_Y, pVBuf->u32FrmSize, 1, pfd);
2245
2246 /* save offset */
2247 for (i = 0; i < VI_MAX_SPLIT_NODE_NUM; i++) {
2248 (HI_VOID)fwrite(&pVBuf->u32Offset[i], 4, 1, pfd); /* write 4 bytes data(offset[i]) to pfd. */
2249 }
2250
2251 /* save compress mode */
2252 (HI_VOID)fwrite(&pVBuf->stFpnFrame.stVFrame.enCompressMode, 4, 1, pfd); /* write 4 bytes data(cmpMode) to pfd. */
2253
2254 /* save fpn frame size */
2255 (HI_VOID)fwrite(&pVBuf->u32FrmSize, 4, 1, pfd); /* write 4 bytes data(frmSize) to pfd. */
2256
2257 /* save ISO */
2258 (HI_VOID)fwrite(&pVBuf->u32Iso, 4, 1, pfd); /* write 4 bytes data(u32Iso) to pfd. */
2259 (HI_VOID)fflush(pfd);
2260 }
2261
SAMPLE_COMM_VI_ReadFpnFile(ISP_FPN_FRAME_INFO_S * pstFpnFrmInfo,FILE * pfd)2262 static HI_VOID SAMPLE_COMM_VI_ReadFpnFile(ISP_FPN_FRAME_INFO_S *pstFpnFrmInfo, FILE *pfd)
2263 {
2264 HI_U32 i;
2265 VIDEO_FRAME_INFO_S *pstFpnFrame = HI_NULL;
2266
2267 SAMPLE_PRT("u32FrmSize: %d!!\n", pstFpnFrmInfo->u32FrmSize);
2268
2269 pstFpnFrame = &pstFpnFrmInfo->stFpnFrame;
2270 (HI_VOID)fread((HI_U8 *)(HI_UINTPTR_T)pstFpnFrame->stVFrame.u64VirAddr[0], pstFpnFrmInfo->u32FrmSize, 1, pfd);
2271 for (i = 0; i < VI_MAX_SPLIT_NODE_NUM; i++) {
2272 (HI_VOID)fread((HI_U8 *)&pstFpnFrmInfo->u32Offset[i], 4, 1, pfd); /* read 4 bytes once. */
2273 }
2274 (HI_VOID)fread((HI_U8 *)&pstFpnFrame->stVFrame.enCompressMode, 4, 1, pfd); /* read 4 bytes once. */
2275 (HI_VOID)fread((HI_U8 *)&pstFpnFrmInfo->u32FrmSize, 4, 1, pfd); /* read 4 bytes once. */
2276 (HI_VOID)fread((HI_U8 *)&pstFpnFrmInfo->u32Iso, 4, 1, pfd); /* read 4 bytes once. */
2277 }
2278
SAMPLE_COMM_VI_FpnCalibrateConfig(VI_PIPE ViPipe,SAMPLE_VI_FPN_CALIBRATE_INFO_S * pstViFpnCalibrateInfo)2279 HI_S32 SAMPLE_COMM_VI_FpnCalibrateConfig(VI_PIPE ViPipe, SAMPLE_VI_FPN_CALIBRATE_INFO_S *pstViFpnCalibrateInfo)
2280 {
2281 HI_S32 s32Ret;
2282 ISP_PUB_ATTR_S stPubAttr;
2283 HI_U32 i;
2284 FILE *pfd = HI_NULL;
2285 VI_CHN ViChn = 0;
2286 HI_CHAR FpnFileName[FILE_NAME_LEN];
2287 SAMPLE_VI_FRAME_CONFIG_S stFrmCfg;
2288 SAMPLE_VI_FRAME_INFO_S stViFrameInfo;
2289 ISP_FPN_CALIBRATE_ATTR_S stCalibrateAttr;
2290
2291 if (pstViFpnCalibrateInfo == NULL) {
2292 SAMPLE_PRT("null pointer\n");
2293 return HI_FAILURE;
2294 }
2295 s32Ret = HI_MPI_ISP_GetPubAttr(ViPipe, &stPubAttr);
2296 if (s32Ret != HI_SUCCESS) {
2297 SAMPLE_PRT("get isp pub attr failed!\n");
2298 return s32Ret;
2299 }
2300
2301 stFrmCfg.u32Width = stPubAttr.stWndRect.u32Width;
2302 if (pstViFpnCalibrateInfo->enFpnType == ISP_FPN_TYPE_LINE) {
2303 stFrmCfg.u32Height = 1;
2304 } else {
2305 stFrmCfg.u32Height = stPubAttr.stWndRect.u32Height;
2306 }
2307
2308 stFrmCfg.u32ByteAlign = 0;
2309 stFrmCfg.enPixelFormat = pstViFpnCalibrateInfo->enPixelFormat;
2310 stFrmCfg.enCompressMode = pstViFpnCalibrateInfo->enCompressMode;
2311 stFrmCfg.enVideoFormat = VIDEO_FORMAT_LINEAR;
2312 stFrmCfg.enDynamicRange = DYNAMIC_RANGE_SDR8;
2313 s32Ret = SAMPLE_VI_GetFrameBlkInfo(&stFrmCfg, 1, &stViFrameInfo);
2314 if (s32Ret != HI_SUCCESS) {
2315 SAMPLE_PRT("SAMPLE_VI_GetFrameBlkInfo failed!\n");
2316 return s32Ret;
2317 }
2318
2319 printf("Pipe %d Width=%d, Height=%d.\n", ViPipe, stFrmCfg.u32Width, stFrmCfg.u32Height);
2320 printf("Please turn off camera aperture to start calibrate!\n");
2321 printf("Please hit Enter key, start calibrate!\n");
2322 (hi_void)getchar();
2323
2324 s32Ret = HI_MPI_VI_DisableChn(ViPipe, ViChn);
2325 if (s32Ret != HI_SUCCESS) {
2326 SAMPLE_PRT("disable vi chn %d failed!", ViChn);
2327 SAMPLE_VI_COMM_ReleaseFrameBlkInfo(1, &stViFrameInfo);
2328 return s32Ret;
2329 }
2330
2331 stCalibrateAttr.enFpnType = pstViFpnCalibrateInfo->enFpnType;
2332 stCalibrateAttr.u32FrameNum = pstViFpnCalibrateInfo->u32FrameNum;
2333 stCalibrateAttr.u32Threshold = pstViFpnCalibrateInfo->u32Threshold;
2334 stCalibrateAttr.stFpnCaliFrame.u32Iso = 0;
2335 for (i = 0; i < VI_MAX_SPLIT_NODE_NUM; i++) {
2336 stCalibrateAttr.stFpnCaliFrame.u32Offset[i] = 0;
2337 }
2338 stCalibrateAttr.stFpnCaliFrame.u32FrmSize = stViFrameInfo.u32Size;
2339 (hi_void)memcpy_s(&stCalibrateAttr.stFpnCaliFrame.stFpnFrame, sizeof(VIDEO_FRAME_INFO_S),
2340 &stViFrameInfo.stVideoFrameInfo, sizeof(VIDEO_FRAME_INFO_S));
2341
2342 s32Ret = HI_MPI_ISP_FPNCalibrate(ViPipe, &stCalibrateAttr);
2343 if (s32Ret != HI_SUCCESS) {
2344 SAMPLE_PRT("HI_MPI_ISP_FPNCalibrate err: 0x%x\n", s32Ret);
2345 HI_MPI_VI_EnableChn(ViPipe, ViChn);
2346 SAMPLE_VI_COMM_ReleaseFrameBlkInfo(1, &stViFrameInfo);
2347 return s32Ret;
2348 }
2349
2350 /* save FPN raw data */
2351 s32Ret = snprintf_s(FpnFileName, FILE_NAME_LEN, FILE_NAME_LEN - 1, VI_DATA_PATH "/FPN_%s_w%d_h%d_%dbit.raw",
2352 PRINT_FPNTYPE(stCalibrateAttr.enFpnType), stPubAttr.stWndRect.u32Width, stPubAttr.stWndRect.u32Height,
2353 SAMPLE_VI_PixelFormat2BitWidth(stViFrameInfo.stVideoFrameInfo.stVFrame.enPixelFormat));
2354 if (s32Ret < 0) {
2355 SAMPLE_PRT("snprintf_s FpnFileName fail.\n");
2356 HI_MPI_VI_EnableChn(ViPipe, ViChn);
2357 SAMPLE_VI_COMM_ReleaseFrameBlkInfo(1, &stViFrameInfo);
2358 return s32Ret;
2359 }
2360
2361 printf("\nafter calibrate ");
2362 for (i = 0; i < VI_MAX_SPLIT_NODE_NUM; i++) {
2363 printf("offset[%d] = 0x%x, ", i, stCalibrateAttr.stFpnCaliFrame.u32Offset[i]);
2364 }
2365 printf("u32FrmSize = %d\n", stCalibrateAttr.stFpnCaliFrame.u32FrmSize);
2366 printf("ISO = %d\n", stCalibrateAttr.stFpnCaliFrame.u32Iso);
2367 printf("save dark frame file: %s!\n", FpnFileName);
2368
2369 pfd = fopen(FpnFileName, "wb");
2370 if (pfd == HI_NULL) {
2371 SAMPLE_PRT("open file %s err!\n", FpnFileName);
2372 HI_MPI_VI_EnableChn(ViPipe, ViChn);
2373 SAMPLE_VI_COMM_ReleaseFrameBlkInfo(1, &stViFrameInfo);
2374 return HI_FAILURE;
2375 }
2376
2377 SAMPLE_COMM_VI_SaveFpnFile(&stCalibrateAttr.stFpnCaliFrame, pfd);
2378
2379 (HI_VOID)fclose(pfd);
2380
2381 s32Ret = HI_MPI_VI_EnableChn(ViPipe, ViChn);
2382 if (s32Ret != HI_SUCCESS) {
2383 SAMPLE_PRT("enable vi chn %d failed. ret 0x%x!", ViChn, s32Ret);
2384 }
2385
2386 SAMPLE_VI_COMM_ReleaseFrameBlkInfo(1, &stViFrameInfo);
2387 return s32Ret;
2388 }
2389
SAMPLE_COMM_VI_FpnCorrectionConfig(VI_PIPE ViPipe,SAMPLE_VI_FPN_CORRECTION_INFO_S * pstViFpnCorrectionInfo)2390 HI_S32 SAMPLE_COMM_VI_FpnCorrectionConfig(VI_PIPE ViPipe, SAMPLE_VI_FPN_CORRECTION_INFO_S *pstViFpnCorrectionInfo)
2391 {
2392 HI_S32 s32Ret;
2393 SAMPLE_VI_FRAME_CONFIG_S stFrmCfg;
2394 SAMPLE_VI_FRAME_INFO_S *pstViFrameInfo = HI_NULL;
2395 ISP_FPN_ATTR_S stFPNAttr;
2396 ISP_PUB_ATTR_S stPubAttr;
2397 FILE *pfd = HI_NULL;
2398 HI_U32 i;
2399 HI_CHAR FpnFileName[FILE_NAME_LEN];
2400 HI_CHAR *RealPath = HI_NULL;
2401
2402 s32Ret = HI_MPI_ISP_GetPubAttr(ViPipe, &stPubAttr);
2403 if (s32Ret != HI_SUCCESS) {
2404 SAMPLE_PRT("get isp pub attr failed!\n");
2405 return s32Ret;
2406 }
2407
2408 if (pstViFpnCorrectionInfo == NULL) {
2409 SAMPLE_PRT("pstViFpnCorrectionInfo is null!\n");
2410 return HI_FAILURE;
2411 }
2412 if (pstViFpnCorrectionInfo->enFpnType == ISP_FPN_TYPE_LINE) {
2413 stFrmCfg.u32Height = 1;
2414 } else {
2415 stFrmCfg.u32Height = stPubAttr.stWndRect.u32Height;
2416 }
2417 stFrmCfg.u32Width = stPubAttr.stWndRect.u32Width;
2418 stFrmCfg.u32ByteAlign = 0;
2419 stFrmCfg.enPixelFormat = pstViFpnCorrectionInfo->enPixelFormat;
2420 stFrmCfg.enCompressMode = pstViFpnCorrectionInfo->enCompressMode;
2421 stFrmCfg.enVideoFormat = VIDEO_FORMAT_LINEAR;
2422 stFrmCfg.enDynamicRange = DYNAMIC_RANGE_SDR8;
2423 pstViFrameInfo = &pstViFpnCorrectionInfo->stViFrameInfo;
2424 s32Ret = SAMPLE_VI_GetFrameBlkInfo(&stFrmCfg, 1, pstViFrameInfo);
2425 if (s32Ret != HI_SUCCESS) {
2426 SAMPLE_PRT("VI_MST_COMM_GetFrameBlkInfo failed!\n");
2427 return s32Ret;
2428 }
2429
2430 stFPNAttr.stFpnFrmInfo.u32FrmSize = pstViFrameInfo->u32Size;
2431 (hi_void)memcpy_s(&stFPNAttr.stFpnFrmInfo.stFpnFrame, sizeof(VIDEO_FRAME_INFO_S), &pstViFrameInfo->stVideoFrameInfo,
2432 sizeof(VIDEO_FRAME_INFO_S));
2433
2434 /* save FPN raw data */
2435 s32Ret = snprintf_s(FpnFileName, FILE_NAME_LEN, FILE_NAME_LEN - 1, VI_DATA_PATH "/FPN_%s_w%d_h%d_%dbit.raw",
2436 PRINT_FPNTYPE(pstViFpnCorrectionInfo->enFpnType), stPubAttr.stWndRect.u32Width, stPubAttr.stWndRect.u32Height,
2437 SAMPLE_VI_PixelFormat2BitWidth(pstViFrameInfo->stVideoFrameInfo.stVFrame.enPixelFormat));
2438 if (s32Ret < 0) {
2439 SAMPLE_PRT("snprintf_s FpnFileName fail.\n");
2440 goto EXIT0;
2441 }
2442
2443 RealPath = realpath(FpnFileName, HI_NULL);
2444 if (RealPath == HI_NULL) {
2445 SAMPLE_PRT("file %s realpath error!\n", FpnFileName);
2446 s32Ret = HI_FAILURE;
2447 goto EXIT0;
2448 }
2449
2450 SAMPLE_PRT("====to open Fpn raw file: %s. \n", RealPath);
2451 pfd = fopen(RealPath, "rb");
2452 if (pfd == HI_NULL) {
2453 SAMPLE_PRT("open file %s err!\n", RealPath);
2454 s32Ret = HI_FAILURE;
2455 goto EXIT0;
2456 }
2457
2458 SAMPLE_COMM_VI_ReadFpnFile(&stFPNAttr.stFpnFrmInfo, pfd);
2459
2460 (HI_VOID)fclose(pfd);
2461
2462 stFPNAttr.bEnable = HI_TRUE;
2463 stFPNAttr.enOpType = pstViFpnCorrectionInfo->enOpType;
2464 stFPNAttr.enFpnType = pstViFpnCorrectionInfo->enFpnType;
2465 stFPNAttr.stManual.u32Strength = pstViFpnCorrectionInfo->u32Strength;
2466
2467 for (i = 0; i < VI_MAX_SPLIT_NODE_NUM; i++) {
2468 printf("offset[%d] = 0x%x; ", i, stFPNAttr.stFpnFrmInfo.u32Offset[i]);
2469 }
2470 printf("\n");
2471 printf("u32FrmSize = %d.\n", stFPNAttr.stFpnFrmInfo.u32FrmSize);
2472 printf("ISO = %d.\n", stFPNAttr.stFpnFrmInfo.u32Iso);
2473 printf("\nstFPNAttr: u32Width = %d, u32Height = %d\n", stFPNAttr.stFpnFrmInfo.stFpnFrame.stVFrame.u32Width,
2474 stFPNAttr.stFpnFrmInfo.stFpnFrame.stVFrame.u32Height);
2475 printf("FrmSize: %d, stride: %d, compress mode: %d\n", stFPNAttr.stFpnFrmInfo.u32FrmSize,
2476 stFPNAttr.stFpnFrmInfo.stFpnFrame.stVFrame.u32Stride[0],
2477 stFPNAttr.stFpnFrmInfo.stFpnFrame.stVFrame.enCompressMode);
2478
2479 s32Ret = HI_MPI_ISP_SetFPNAttr(ViPipe, &stFPNAttr);
2480 if (s32Ret != HI_SUCCESS) {
2481 SAMPLE_PRT("fpn correction fail 0x%x\n", s32Ret);
2482 goto EXIT0;
2483 }
2484
2485 free(RealPath);
2486 RealPath = HI_NULL;
2487 return HI_SUCCESS;
2488
2489 EXIT0:
2490 /* Fpn Correction create vb pool, must destroy. */
2491 SAMPLE_VI_COMM_ReleaseFrameBlkInfo(1, pstViFrameInfo);
2492 if (RealPath != HI_NULL) {
2493 free(RealPath);
2494 RealPath = HI_NULL;
2495 }
2496
2497 return s32Ret;
2498 }
2499
SAMPLE_COMM_VI_DisableFpnCorrection(VI_PIPE ViPipe,SAMPLE_VI_FPN_CORRECTION_INFO_S * pstViFpnCorrectionInfo)2500 HI_S32 SAMPLE_COMM_VI_DisableFpnCorrection(VI_PIPE ViPipe, SAMPLE_VI_FPN_CORRECTION_INFO_S *pstViFpnCorrectionInfo)
2501 {
2502 ISP_FPN_ATTR_S stFPNAttr;
2503 HI_S32 s32Ret;
2504
2505 if (pstViFpnCorrectionInfo == NULL) {
2506 SAMPLE_PRT("null pointer\n");
2507 return HI_FAILURE;
2508 }
2509 s32Ret = HI_MPI_ISP_GetFPNAttr(ViPipe, &stFPNAttr);
2510 if (s32Ret != HI_SUCCESS) {
2511 SAMPLE_PRT("get fpn correction fail, ret 0x%x\n", s32Ret);
2512 goto END;
2513 }
2514
2515 stFPNAttr.bEnable = HI_FALSE;
2516 s32Ret = HI_MPI_ISP_SetFPNAttr(ViPipe, &stFPNAttr);
2517 if (s32Ret != HI_SUCCESS) {
2518 SAMPLE_PRT("set fpn correction fail, ret 0x%x\n", s32Ret);
2519 goto END;
2520 }
2521
2522 END:
2523 /* Fpn Correction create vb pool, must destroy. */
2524 SAMPLE_VI_COMM_ReleaseFrameBlkInfo(1, &pstViFpnCorrectionInfo->stViFrameInfo);
2525
2526 return s32Ret;
2527 }
2528
2529 #ifdef __cplusplus
2530 #if __cplusplus
2531 }
2532 #endif
2533 #endif /* End of #ifdef __cplusplus */
2534