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 <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <sys/mman.h>
21 #include <sys/stat.h>
22 #include <sys/types.h>
23 #include <unistd.h>
24 #include <signal.h>
25
26 #include "hi_common.h"
27 #include "hi_comm_video.h"
28 #include "hi_comm_sys.h"
29 #include "hi_comm_vgs.h"
30 #include "hi_comm_vi.h"
31 #include "hi_comm_vo.h"
32 #include "mpi_vb.h"
33 #include "mpi_sys.h"
34 #include "mpi_vi.h"
35 #include "mpi_vo.h"
36 #include "mpi_vgs.h"
37
38 #include "sample_comm_ive.h"
39
40 static HI_BOOL bMpiInit = HI_FALSE;
41
SAMPLE_COMM_IVE_CalcStride(HI_U32 u32Width,HI_U8 u8Align)42 HI_U16 SAMPLE_COMM_IVE_CalcStride(HI_U32 u32Width, HI_U8 u8Align)
43 {
44 return (u32Width + (u8Align - u32Width % u8Align) % u8Align);
45 }
46
SAMPLE_IVE_MPI_Init(HI_VOID)47 static HI_S32 SAMPLE_IVE_MPI_Init(HI_VOID)
48 {
49 HI_S32 s32Ret;
50
51 HI_MPI_SYS_Exit();
52
53 s32Ret = HI_MPI_SYS_Init();
54 if (s32Ret != HI_SUCCESS) {
55 SAMPLE_PRT("HI_MPI_SYS_Init fail,Error(%#x)\n", s32Ret);
56 return s32Ret;
57 }
58
59 return HI_SUCCESS;
60 }
61
SAMPLE_COMM_IVE_CheckIveMpiInit(HI_VOID)62 HI_VOID SAMPLE_COMM_IVE_CheckIveMpiInit(HI_VOID)
63 {
64 if (bMpiInit == HI_FALSE) {
65 if (SAMPLE_IVE_MPI_Init()) {
66 SAMPLE_PRT("Ive mpi init failed!\n");
67 bMpiInit = HI_FALSE;
68 return;
69 }
70 bMpiInit = HI_TRUE;
71 }
72 }
73
SAMPLE_COMM_IVE_IveMpiExit(HI_VOID)74 HI_S32 SAMPLE_COMM_IVE_IveMpiExit(HI_VOID)
75 {
76 bMpiInit = HI_FALSE;
77 if (HI_MPI_SYS_Exit()) {
78 SAMPLE_PRT("Sys exit failed!\n");
79 return HI_FAILURE;
80 }
81
82 return HI_SUCCESS;
83 }
84
SAMPLE_COMM_VGS_FillRect(VIDEO_FRAME_INFO_S * pstFrmInfo,SAMPLE_RECT_ARRAY_S * pstRect,HI_U32 u32Color)85 HI_S32 SAMPLE_COMM_VGS_FillRect(VIDEO_FRAME_INFO_S *pstFrmInfo, SAMPLE_RECT_ARRAY_S *pstRect, HI_U32 u32Color)
86 {
87 VGS_HANDLE VgsHandle = -1;
88 HI_S32 s32Ret = HI_SUCCESS;
89 HI_U16 i;
90 VGS_TASK_ATTR_S stVgsTask;
91 VGS_ADD_COVER_S stVgsAddCover;
92
93 CHECK_NULL_PTR(pstFrmInfo);
94 CHECK_NULL_PTR(pstRect);
95 if (pstRect->u16Num == 0) {
96 return s32Ret;
97 }
98 s32Ret = HI_MPI_VGS_BeginJob(&VgsHandle);
99 if (s32Ret != HI_SUCCESS) {
100 SAMPLE_PRT("Vgs begin job fail,Error(%#x)\n", s32Ret);
101 return s32Ret;
102 }
103
104 (HI_VOID)memcpy_s(&stVgsTask.stImgIn, sizeof(VIDEO_FRAME_INFO_S), pstFrmInfo, sizeof(VIDEO_FRAME_INFO_S));
105 (HI_VOID)memcpy_s(&stVgsTask.stImgOut, sizeof(VIDEO_FRAME_INFO_S), pstFrmInfo, sizeof(VIDEO_FRAME_INFO_S));
106
107 stVgsAddCover.enCoverType = COVER_QUAD_RANGLE;
108 stVgsAddCover.u32Color = u32Color;
109 for (i = 0; i < pstRect->u16Num; i++) {
110 stVgsAddCover.stQuadRangle.bSolid = HI_FALSE;
111 stVgsAddCover.stQuadRangle.u32Thick = 2; /* thick value: 2 */
112 (HI_VOID)memcpy_s(stVgsAddCover.stQuadRangle.stPoint, sizeof(pstRect->astRect[i].astPoint),
113 pstRect->astRect[i].astPoint, sizeof(pstRect->astRect[i].astPoint));
114 s32Ret = HI_MPI_VGS_AddCoverTask(VgsHandle, &stVgsTask, &stVgsAddCover);
115 if (s32Ret != HI_SUCCESS) {
116 SAMPLE_PRT("HI_MPI_VGS_AddCoverTask fail,Error(%#x)\n", s32Ret);
117 HI_MPI_VGS_CancelJob(VgsHandle);
118 return s32Ret;
119 }
120 }
121
122 s32Ret = HI_MPI_VGS_EndJob(VgsHandle);
123 if (s32Ret != HI_SUCCESS) {
124 SAMPLE_PRT("HI_MPI_VGS_EndJob fail,Error(%#x)\n", s32Ret);
125 HI_MPI_VGS_CancelJob(VgsHandle);
126 return s32Ret;
127 }
128
129 return s32Ret;
130 }
131
SAMPLE_COMM_IVE_ReadFile(IVE_IMAGE_S * pstImg,FILE * pFp)132 HI_S32 SAMPLE_COMM_IVE_ReadFile(IVE_IMAGE_S *pstImg, FILE *pFp)
133 {
134 HI_U16 y;
135 HI_U8 *pU8 = NULL;
136 HI_U16 height;
137 HI_U16 width;
138 HI_U16 loop;
139 HI_S32 s32Ret;
140
141 CHECK_NULL_PTR(pstImg);
142 CHECK_NULL_PTR(pFp);
143 (HI_VOID)fgetc(pFp);
144 if (feof(pFp)) {
145 SAMPLE_PRT("end of file!\n");
146 s32Ret = fseek(pFp, 0, SEEK_SET);
147 if (s32Ret != HI_SUCCESS) {
148 SAMPLE_PRT("fseek failed!\n");
149 return s32Ret;
150 }
151 } else {
152 s32Ret = fseek(pFp, -1, SEEK_CUR);
153 if (s32Ret != HI_SUCCESS) {
154 SAMPLE_PRT("fseek failed!\n");
155 return s32Ret;
156 }
157 }
158
159 height = pstImg->u32Height;
160 width = pstImg->u32Width;
161 switch (pstImg->enType) {
162 case IVE_IMAGE_TYPE_U8C1: {
163 pU8 = (HI_U8 *)(HI_UINTPTR_T)pstImg->au64VirAddr[0];
164 for (y = 0; y < height; y++) {
165 if (fread(pU8, width, 1, pFp) != 1) {
166 SAMPLE_PRT("Read file fail\n");
167 return HI_FAILURE;
168 }
169
170 pU8 += pstImg->au32Stride[0];
171 }
172 break;
173 }
174 case IVE_IMAGE_TYPE_YUV420SP: {
175 pU8 = (HI_U8 *)(HI_UINTPTR_T)pstImg->au64VirAddr[0];
176 for (y = 0; y < height; y++) {
177 if (fread(pU8, width, 1, pFp) != 1) {
178 SAMPLE_PRT("Read file fail\n");
179 return HI_FAILURE;
180 }
181
182 pU8 += pstImg->au32Stride[0];
183 }
184
185 pU8 = (HI_U8 *)(HI_UINTPTR_T)pstImg->au64VirAddr[1];
186 for (y = 0; y < height / 2; y++) { /* y shuold be less than height/2 */
187 if (fread(pU8, width, 1, pFp) != 1) {
188 SAMPLE_PRT("Read file fail\n");
189 return HI_FAILURE;
190 }
191
192 pU8 += pstImg->au32Stride[1];
193 }
194 break;
195 }
196 case IVE_IMAGE_TYPE_YUV422SP: {
197 pU8 = (HI_U8 *)(HI_UINTPTR_T)pstImg->au64VirAddr[0];
198 for (y = 0; y < height; y++) {
199 if (fread(pU8, width, 1, pFp) != 1) {
200 SAMPLE_PRT("Read file fail\n");
201 return HI_FAILURE;
202 }
203
204 pU8 += pstImg->au32Stride[0];
205 }
206
207 pU8 = (HI_U8 *)(HI_UINTPTR_T)pstImg->au64VirAddr[1];
208 for (y = 0; y < height; y++) {
209 if (fread(pU8, width, 1, pFp) != 1) {
210 SAMPLE_PRT("Read file fail\n");
211 return HI_FAILURE;
212 }
213
214 pU8 += pstImg->au32Stride[1];
215 }
216 break;
217 }
218 case IVE_IMAGE_TYPE_U8C3_PACKAGE: {
219 pU8 = (HI_U8 *)(HI_UINTPTR_T)pstImg->au64VirAddr[0];
220 for (y = 0; y < height; y++) {
221 if (fread(pU8, width * 3, 1, pFp) != 1) { /* width * 3 bytes of each element to read */
222 SAMPLE_PRT("Read file fail\n");
223 return HI_FAILURE;
224 }
225
226 pU8 += pstImg->au32Stride[0] * 3; /* next fread addr: pstImg->au32Stride[0] * 3 */
227 }
228 break;
229 }
230 case IVE_IMAGE_TYPE_U8C3_PLANAR: {
231 for (loop = 0; loop < 3; loop++) { /* loop times: 3 */
232 pU8 = (HI_U8 *)(HI_UINTPTR_T)pstImg->au64VirAddr[loop];
233 for (y = 0; y < height; y++) {
234 if (fread(pU8, width, 1, pFp) != 1) {
235 SAMPLE_PRT("Read file fail\n");
236 return HI_FAILURE;
237 }
238
239 pU8 += pstImg->au32Stride[loop];
240 }
241 }
242 break;
243 }
244 case IVE_IMAGE_TYPE_S16C1:
245 case IVE_IMAGE_TYPE_U16C1: {
246 pU8 = (HI_U8 *)(HI_UINTPTR_T)pstImg->au64VirAddr[0];
247 for (y = 0; y < height; y++) {
248 if (sizeof(HI_U16) != fread(pU8, width, sizeof(HI_U16), pFp)) {
249 SAMPLE_PRT("Read file fail\n");
250 return HI_FAILURE;
251 }
252
253 pU8 += pstImg->au32Stride[0] * 2; /* next fread addr: pstImg->au32Stride[0] * 2 */
254 }
255 break;
256 }
257 default:
258 break;
259 }
260
261 return HI_SUCCESS;
262 }
263
SAMPLE_COMM_IVE_WriteFile(IVE_IMAGE_S * pstImg,FILE * pFp)264 HI_S32 SAMPLE_COMM_IVE_WriteFile(IVE_IMAGE_S *pstImg, FILE *pFp)
265 {
266 HI_U16 y;
267 HI_U8 *pU8 = NULL;
268 HI_U16 height;
269 HI_U16 width;
270
271 CHECK_NULL_PTR(pstImg);
272 CHECK_NULL_PTR(pFp);
273 height = pstImg->u32Height;
274 width = pstImg->u32Width;
275
276 switch (pstImg->enType) {
277 case IVE_IMAGE_TYPE_U8C1:
278 case IVE_IMAGE_TYPE_S8C1: {
279 pU8 = SAMPLE_COMM_IVE_CONVERT_64BIT_ADDR(HI_U8, pstImg->au64VirAddr[0]);
280 for (y = 0; y < height; y++) {
281 if (fwrite(pU8, width, 1, pFp) != 1) {
282 SAMPLE_PRT("Write file fail\n");
283 return HI_FAILURE;
284 }
285
286 pU8 += pstImg->au32Stride[0];
287 }
288 break;
289 }
290 case IVE_IMAGE_TYPE_YUV420SP: {
291 pU8 = SAMPLE_COMM_IVE_CONVERT_64BIT_ADDR(HI_U8, pstImg->au64VirAddr[0]);
292 for (y = 0; y < height; y++) {
293 if (width != fwrite(pU8, 1, width, pFp)) {
294 SAMPLE_PRT("Write file fail\n");
295 return HI_FAILURE;
296 }
297
298 pU8 += pstImg->au32Stride[0];
299 }
300
301 pU8 = SAMPLE_COMM_IVE_CONVERT_64BIT_ADDR(HI_U8, pstImg->au64VirAddr[1]);
302 for (y = 0; y < height / 2; y++) { /* y shuold be less than height / 2 */
303 if (width != fwrite(pU8, 1, width, pFp)) {
304 SAMPLE_PRT("Write file fail\n");
305 return HI_FAILURE;
306 }
307
308 pU8 += pstImg->au32Stride[1];
309 }
310 break;
311 }
312 case IVE_IMAGE_TYPE_YUV422SP: {
313 pU8 = SAMPLE_COMM_IVE_CONVERT_64BIT_ADDR(HI_U8, pstImg->au64VirAddr[0]);
314 for (y = 0; y < height; y++) {
315 if (width != fwrite(pU8, 1, width, pFp)) {
316 SAMPLE_PRT("Write file fail\n");
317 return HI_FAILURE;
318 }
319
320 pU8 += pstImg->au32Stride[0];
321 }
322
323 pU8 = SAMPLE_COMM_IVE_CONVERT_64BIT_ADDR(HI_U8, pstImg->au64VirAddr[1]);
324 for (y = 0; y < height; y++) {
325 if (width != fwrite(pU8, 1, width, pFp)) {
326 SAMPLE_PRT("Write file fail\n");
327 return HI_FAILURE;
328 }
329
330 pU8 += pstImg->au32Stride[1];
331 }
332 break;
333 }
334 case IVE_IMAGE_TYPE_S16C1:
335 case IVE_IMAGE_TYPE_U16C1: {
336 pU8 = SAMPLE_COMM_IVE_CONVERT_64BIT_ADDR(HI_U8, pstImg->au64VirAddr[0]);
337 for (y = 0; y < height; y++) {
338 if (sizeof(HI_U16) != fwrite(pU8, width, sizeof(HI_U16), pFp)) {
339 SAMPLE_PRT("Write file fail\n");
340 return HI_FAILURE;
341 }
342
343 pU8 += pstImg->au32Stride[0] * 2; /* next fread addr: pstImg->au32Stride[0] * 2 */
344 }
345 break;
346 }
347 case IVE_IMAGE_TYPE_U32C1: {
348 pU8 = SAMPLE_COMM_IVE_CONVERT_64BIT_ADDR(HI_U8, pstImg->au64VirAddr[0]);
349 for (y = 0; y < height; y++) {
350 if (width != fwrite(pU8, sizeof(HI_U32), width, pFp)) {
351 SAMPLE_PRT("Write file fail\n");
352 return HI_FAILURE;
353 }
354
355 pU8 += pstImg->au32Stride[0] * 4; /* next fread addr: pstImg->au32Stride[0] * 4 */
356 }
357 break;
358 }
359 default:
360 break;
361 }
362
363 return HI_SUCCESS;
364 }
365
SAMPLE_COMM_IVE_BlobToRect(IVE_CCBLOB_S * pstBlob,SAMPLE_RECT_ARRAY_S * pstRect,HI_U16 u16RectMaxNum,HI_U16 u16AreaThrStep,HI_U32 u32SrcWidth,HI_U32 u32SrcHeight,HI_U32 u32DstWidth,HI_U32 u32DstHeight)366 HI_VOID SAMPLE_COMM_IVE_BlobToRect(IVE_CCBLOB_S *pstBlob, SAMPLE_RECT_ARRAY_S *pstRect, HI_U16 u16RectMaxNum,
367 HI_U16 u16AreaThrStep, HI_U32 u32SrcWidth, HI_U32 u32SrcHeight, HI_U32 u32DstWidth, HI_U32 u32DstHeight)
368 {
369 HI_U16 u16Num;
370 HI_U16 i, j, k;
371 HI_U16 u16Thr = 0;
372 HI_BOOL bValid = HI_FALSE;
373
374 if (pstBlob->u8RegionNum > u16RectMaxNum) {
375 u16Thr = pstBlob->u16CurAreaThr;
376 do {
377 u16Num = 0;
378 u16Thr += u16AreaThrStep;
379 for (i = 0; i < 254; i++) { /* max region index: 254 */
380 if (pstBlob->astRegion[i].u32Area > u16Thr) {
381 u16Num++;
382 }
383 }
384 } while (u16Num > u16RectMaxNum);
385 }
386
387 u16Num = 0;
388
389 for (i = 0; i < 254; i++) { /* max region index: 254 */
390 if (pstBlob->astRegion[i].u32Area > u16Thr) {
391 pstRect->astRect[u16Num].astPoint[0].s32X =
392 (HI_U32)((HI_FLOAT)pstBlob->astRegion[i].u16Left / (HI_FLOAT)u32SrcWidth * (HI_FLOAT)u32DstWidth) &
393 (~1);
394 pstRect->astRect[u16Num].astPoint[0].s32Y =
395 (HI_U32)((HI_FLOAT)pstBlob->astRegion[i].u16Top / (HI_FLOAT)u32SrcHeight * (HI_FLOAT)u32DstHeight) &
396 (~1);
397 /* point index: 1 */
398 pstRect->astRect[u16Num].astPoint[1].s32X =
399 (HI_U32)((HI_FLOAT)pstBlob->astRegion[i].u16Right / (HI_FLOAT)u32SrcWidth * (HI_FLOAT)u32DstWidth) &
400 (~1);
401 /* point index: 1 */
402 pstRect->astRect[u16Num].astPoint[1].s32Y =
403 (HI_U32)((HI_FLOAT)pstBlob->astRegion[i].u16Top / (HI_FLOAT)u32SrcHeight * (HI_FLOAT)u32DstHeight) &
404 (~1);
405 /* point index: 2 */
406 pstRect->astRect[u16Num].astPoint[2].s32X =
407 (HI_U32)((HI_FLOAT)pstBlob->astRegion[i].u16Right / (HI_FLOAT)u32SrcWidth * (HI_FLOAT)u32DstWidth) &
408 (~1);
409 /* point index: 2 */
410 pstRect->astRect[u16Num].astPoint[2].s32Y =
411 (HI_U32)((HI_FLOAT)pstBlob->astRegion[i].u16Bottom / (HI_FLOAT)u32SrcHeight * (HI_FLOAT)u32DstHeight) &
412 (~1);
413 /* point index: 3 */
414 pstRect->astRect[u16Num].astPoint[3].s32X =
415 (HI_U32)((HI_FLOAT)pstBlob->astRegion[i].u16Left / (HI_FLOAT)u32SrcWidth * (HI_FLOAT)u32DstWidth) &
416 (~1);
417 /* point index: 3 */
418 pstRect->astRect[u16Num].astPoint[3].s32Y =
419 (HI_U32)((HI_FLOAT)pstBlob->astRegion[i].u16Bottom / (HI_FLOAT)u32SrcHeight * (HI_FLOAT)u32DstHeight) &
420 (~1);
421
422 bValid = HI_TRUE;
423 for (j = 0; j < 3; j++) { /* max j value: 3 */
424 for (k = j + 1; k < 4; k++) { /* max k value: 4 */
425 if ((pstRect->astRect[u16Num].astPoint[j].s32X == pstRect->astRect[u16Num].astPoint[k].s32X) &&
426 (pstRect->astRect[u16Num].astPoint[j].s32Y == pstRect->astRect[u16Num].astPoint[k].s32Y)) {
427 bValid = HI_FALSE;
428 break;
429 }
430 }
431 }
432 if (bValid == HI_TRUE) {
433 u16Num++;
434 }
435 }
436 }
437
438 pstRect->u16Num = u16Num;
439 }
440
SAMPLE_COMM_IVE_CreateImage(IVE_IMAGE_S * pstImg,IVE_IMAGE_TYPE_E enType,HI_U32 u32Width,HI_U32 u32Height)441 HI_S32 SAMPLE_COMM_IVE_CreateImage(IVE_IMAGE_S *pstImg, IVE_IMAGE_TYPE_E enType, HI_U32 u32Width, HI_U32 u32Height)
442 {
443 HI_U32 u32Size = 0;
444 HI_S32 s32Ret;
445 if (pstImg == NULL) {
446 SAMPLE_PRT("pstImg is null\n");
447 return HI_FAILURE;
448 }
449
450 pstImg->enType = enType;
451 pstImg->u32Width = u32Width;
452 pstImg->u32Height = u32Height;
453 pstImg->au32Stride[0] = SAMPLE_COMM_IVE_CalcStride(pstImg->u32Width, IVE_ALIGN);
454
455 switch (enType) {
456 case IVE_IMAGE_TYPE_U8C1:
457 case IVE_IMAGE_TYPE_S8C1: {
458 u32Size = pstImg->au32Stride[0] * pstImg->u32Height;
459 s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL, HI_NULL,
460 u32Size);
461 if (s32Ret != HI_SUCCESS) {
462 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
463 return s32Ret;
464 }
465 break;
466 }
467 case IVE_IMAGE_TYPE_YUV420SP: {
468 u32Size = pstImg->au32Stride[0] * pstImg->u32Height * 3 / 2; /* YUV420SP size: stride * height * 3 / 2 */
469 s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL, HI_NULL,
470 u32Size);
471 if (s32Ret != HI_SUCCESS) {
472 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
473 return s32Ret;
474 }
475 pstImg->au32Stride[1] = pstImg->au32Stride[0];
476 pstImg->au64PhyAddr[1] = pstImg->au64PhyAddr[0] + pstImg->au32Stride[0] * pstImg->u32Height;
477 pstImg->au64VirAddr[1] = pstImg->au64VirAddr[0] + pstImg->au32Stride[0] * pstImg->u32Height;
478 break;
479 }
480 case IVE_IMAGE_TYPE_YUV422SP: {
481 u32Size = pstImg->au32Stride[0] * pstImg->u32Height * 2; /* YUV422SP size: stride * height * 2 */
482 s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL, HI_NULL,
483 u32Size);
484 if (s32Ret != HI_SUCCESS) {
485 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
486 return s32Ret;
487 }
488 pstImg->au32Stride[1] = pstImg->au32Stride[0];
489 pstImg->au64PhyAddr[1] = pstImg->au64PhyAddr[0] + pstImg->au32Stride[0] * pstImg->u32Height;
490 pstImg->au64VirAddr[1] = pstImg->au64VirAddr[0] + pstImg->au32Stride[0] * pstImg->u32Height;
491 break;
492 }
493 case IVE_IMAGE_TYPE_YUV420P:
494 break;
495 case IVE_IMAGE_TYPE_YUV422P:
496 break;
497 case IVE_IMAGE_TYPE_S8C2_PACKAGE:
498 break;
499 case IVE_IMAGE_TYPE_S8C2_PLANAR:
500 break;
501 case IVE_IMAGE_TYPE_S16C1:
502 case IVE_IMAGE_TYPE_U16C1: {
503 u32Size = pstImg->au32Stride[0] * pstImg->u32Height * sizeof(HI_U16);
504 s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL, HI_NULL,
505 u32Size);
506 if (s32Ret != HI_SUCCESS) {
507 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
508 return s32Ret;
509 }
510 break;
511 }
512 case IVE_IMAGE_TYPE_U8C3_PACKAGE: {
513 u32Size = pstImg->au32Stride[0] * pstImg->u32Height * 3; /* YUV422SP size: stride * height * 3 */
514 s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL, HI_NULL,
515 u32Size);
516 if (s32Ret != HI_SUCCESS) {
517 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
518 return s32Ret;
519 }
520 pstImg->au64VirAddr[1] = pstImg->au64VirAddr[0] + 1; /* virAddr index : 1 */
521 pstImg->au64VirAddr[2] = pstImg->au64VirAddr[1] + 1; /* virAddr index : 2 */
522 pstImg->au64PhyAddr[1] = pstImg->au64PhyAddr[0] + 1; /* phyAddr index : 1 */
523 pstImg->au64PhyAddr[2] = pstImg->au64PhyAddr[1] + 1; /* phyAddr index : 2 */
524 pstImg->au32Stride[1] = pstImg->au32Stride[0]; /* stride index : 1 */
525 pstImg->au32Stride[2] = pstImg->au32Stride[0]; /* stride index : 2 */
526 break;
527 }
528 case IVE_IMAGE_TYPE_U8C3_PLANAR:
529 break;
530 case IVE_IMAGE_TYPE_S32C1:
531 case IVE_IMAGE_TYPE_U32C1: {
532 u32Size = pstImg->au32Stride[0] * pstImg->u32Height * sizeof(HI_U32);
533 s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL, HI_NULL,
534 u32Size);
535 if (s32Ret != HI_SUCCESS) {
536 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
537 return s32Ret;
538 }
539 break;
540 }
541 case IVE_IMAGE_TYPE_S64C1:
542 case IVE_IMAGE_TYPE_U64C1: {
543 u32Size = pstImg->au32Stride[0] * pstImg->u32Height * sizeof(HI_U64);
544 s32Ret = HI_MPI_SYS_MmzAlloc(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL, HI_NULL,
545 u32Size);
546 if (s32Ret != HI_SUCCESS) {
547 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
548 return s32Ret;
549 }
550 break;
551 }
552 default:
553 break;
554 }
555
556 return HI_SUCCESS;
557 }
558
SAMPLE_COMM_IVE_CreateMemInfo(IVE_MEM_INFO_S * pstMemInfo,HI_U32 u32Size)559 HI_S32 SAMPLE_COMM_IVE_CreateMemInfo(IVE_MEM_INFO_S *pstMemInfo, HI_U32 u32Size)
560 {
561 HI_S32 s32Ret;
562
563 if (pstMemInfo == NULL) {
564 SAMPLE_PRT("pstMemInfo is null\n");
565 return HI_FAILURE;
566 }
567 pstMemInfo->u32Size = u32Size;
568 s32Ret = HI_MPI_SYS_MmzAlloc(&pstMemInfo->u64PhyAddr, (HI_VOID **)&pstMemInfo->u64VirAddr, NULL, HI_NULL, u32Size);
569 if (s32Ret != HI_SUCCESS) {
570 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
571 return HI_FAILURE;
572 }
573
574 return HI_SUCCESS;
575 }
576
SAMPLE_COMM_IVE_CreateImageByCached(IVE_IMAGE_S * pstImg,IVE_IMAGE_TYPE_E enType,HI_U32 u32Width,HI_U32 u32Height)577 HI_S32 SAMPLE_COMM_IVE_CreateImageByCached(IVE_IMAGE_S *pstImg, IVE_IMAGE_TYPE_E enType, HI_U32 u32Width,
578 HI_U32 u32Height)
579 {
580 HI_U32 u32Size;
581 HI_S32 s32Ret;
582
583 if (pstImg == NULL) {
584 SAMPLE_PRT("pstImg is null\n");
585 return HI_FAILURE;
586 }
587
588 pstImg->enType = enType;
589 pstImg->u32Width = u32Width;
590 pstImg->u32Height = u32Height;
591 pstImg->au32Stride[0] = SAMPLE_COMM_IVE_CalcStride(pstImg->u32Width, IVE_ALIGN);
592
593 switch (enType) {
594 case IVE_IMAGE_TYPE_U8C1:
595 case IVE_IMAGE_TYPE_S8C1: {
596 u32Size = pstImg->au32Stride[0] * pstImg->u32Height;
597 s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL,
598 HI_NULL, u32Size);
599 if (s32Ret != HI_SUCCESS) {
600 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
601 return s32Ret;
602 }
603 break;
604 }
605 case IVE_IMAGE_TYPE_YUV420SP:
606 break;
607 case IVE_IMAGE_TYPE_YUV422SP:
608 break;
609 case IVE_IMAGE_TYPE_YUV420P:
610 break;
611 case IVE_IMAGE_TYPE_YUV422P:
612 break;
613 case IVE_IMAGE_TYPE_S8C2_PACKAGE:
614 break;
615 case IVE_IMAGE_TYPE_S8C2_PLANAR:
616 break;
617 case IVE_IMAGE_TYPE_S16C1:
618 case IVE_IMAGE_TYPE_U16C1: {
619 u32Size = pstImg->au32Stride[0] * pstImg->u32Height * sizeof(HI_U16);
620 s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL,
621 HI_NULL, u32Size);
622 if (s32Ret != HI_SUCCESS) {
623 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
624 return s32Ret;
625 }
626 break;
627 }
628 case IVE_IMAGE_TYPE_U8C3_PACKAGE:
629 break;
630 case IVE_IMAGE_TYPE_U8C3_PLANAR:
631 break;
632 case IVE_IMAGE_TYPE_S32C1:
633 case IVE_IMAGE_TYPE_U32C1: {
634 u32Size = pstImg->au32Stride[0] * pstImg->u32Height * sizeof(HI_U32);
635 s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL,
636 HI_NULL, u32Size);
637 if (s32Ret != HI_SUCCESS) {
638 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
639 return s32Ret;
640 }
641 break;
642 }
643 case IVE_IMAGE_TYPE_S64C1:
644 case IVE_IMAGE_TYPE_U64C1: {
645 u32Size = pstImg->au32Stride[0] * pstImg->u32Height * sizeof(HI_U64);
646 s32Ret = HI_MPI_SYS_MmzAlloc_Cached(&pstImg->au64PhyAddr[0], (HI_VOID **)&pstImg->au64VirAddr[0], NULL,
647 HI_NULL, u32Size);
648 if (s32Ret != HI_SUCCESS) {
649 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
650 return s32Ret;
651 }
652 break;
653 }
654 default:
655 break;
656 }
657
658 return HI_SUCCESS;
659 }
660
SAMPLE_COMM_IVE_CreateData(IVE_DATA_S * pstData,HI_U32 u32Width,HI_U32 u32Height)661 HI_S32 SAMPLE_COMM_IVE_CreateData(IVE_DATA_S *pstData, HI_U32 u32Width, HI_U32 u32Height)
662 {
663 HI_S32 s32Ret;
664 HI_U32 u32Size;
665
666 if (pstData == NULL) {
667 SAMPLE_PRT("pstData is null\n");
668 return HI_FAILURE;
669 }
670 pstData->u32Width = u32Width;
671 pstData->u32Height = u32Height;
672 pstData->u32Stride = SAMPLE_COMM_IVE_CalcStride(pstData->u32Width, IVE_ALIGN);
673 u32Size = pstData->u32Stride * pstData->u32Height;
674 s32Ret = HI_MPI_SYS_MmzAlloc(&pstData->u64PhyAddr, (HI_VOID **)&pstData->u64VirAddr, NULL, HI_NULL, u32Size);
675 if (s32Ret != HI_SUCCESS) {
676 SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32Ret);
677 return HI_FAILURE;
678 }
679
680 return HI_SUCCESS;
681 }
682
SAMPLE_COMM_IVE_VbInit(PIC_SIZE_E * paenSize,SIZE_S * pastSize,HI_U32 u32VpssChnNum)683 HI_S32 SAMPLE_COMM_IVE_VbInit(PIC_SIZE_E *paenSize, SIZE_S *pastSize, HI_U32 u32VpssChnNum)
684 {
685 HI_S32 s32Ret;
686 HI_U32 i;
687 HI_U64 u64BlkSize;
688 VB_CONFIG_S stVbConf;
689
690 CHECK_NULL_PTR(paenSize);
691 CHECK_NULL_PTR(pastSize);
692 (HI_VOID)memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
693 stVbConf.u32MaxPoolCnt = 128; /* max pool count: 128 */
694
695 for (i = 0; i < u32VpssChnNum; i++) {
696 s32Ret = SAMPLE_COMM_SYS_GetPicSize(paenSize[i], &pastSize[i]);
697 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, VB_FAIL_0, "SAMPLE_COMM_SYS_GetPicSize failed,Error(%#x)!\n",
698 s32Ret);
699
700 u64BlkSize = COMMON_GetPicBufferSize(pastSize[i].u32Width, pastSize[i].u32Height, SAMPLE_PIXEL_FORMAT,
701 DATA_BITWIDTH_8, COMPRESS_MODE_NONE, DEFAULT_ALIGN);
702 /* comm video buffer */
703 stVbConf.astCommPool[i].u64BlkSize = u64BlkSize;
704 stVbConf.astCommPool[i].u32BlkCnt = 16; /* vb block size: 16 */
705 }
706
707 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
708 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, VB_FAIL_1, "SAMPLE_COMM_SYS_Init failed,Error(%#x)!\n", s32Ret);
709
710 return s32Ret;
711 VB_FAIL_1:
712 SAMPLE_COMM_SYS_Exit();
713 VB_FAIL_0:
714
715 return s32Ret;
716 }
717
718 /* function : Dma frame info to ive image */
SAMPLE_COMM_IVE_DmaImage(VIDEO_FRAME_INFO_S * pstFrameInfo,IVE_DST_IMAGE_S * pstDst,HI_BOOL bInstant)719 HI_S32 SAMPLE_COMM_IVE_DmaImage(VIDEO_FRAME_INFO_S *pstFrameInfo, IVE_DST_IMAGE_S *pstDst, HI_BOOL bInstant)
720 {
721 HI_S32 s32Ret;
722 IVE_HANDLE hIveHandle;
723 IVE_SRC_DATA_S stSrcData;
724 IVE_DST_DATA_S stDstData;
725 IVE_DMA_CTRL_S stCtrl = { IVE_DMA_MODE_DIRECT_COPY, 0, 0, 0, 0 };
726 HI_BOOL bFinish = HI_FALSE;
727 HI_BOOL bBlock = HI_TRUE;
728
729 CHECK_NULL_PTR(pstFrameInfo);
730 CHECK_NULL_PTR(pstDst);
731 // fill src
732 stSrcData.u64PhyAddr = pstFrameInfo->stVFrame.u64PhyAddr[0];
733 stSrcData.u32Width = pstFrameInfo->stVFrame.u32Width;
734 stSrcData.u32Height = pstFrameInfo->stVFrame.u32Height;
735 stSrcData.u32Stride = pstFrameInfo->stVFrame.u32Stride[0];
736
737 // fill dst
738 stDstData.u64PhyAddr = pstDst->au64PhyAddr[0];
739 stDstData.u32Width = pstDst->u32Width;
740 stDstData.u32Height = pstDst->u32Height;
741 stDstData.u32Stride = pstDst->au32Stride[0];
742
743 s32Ret = HI_MPI_IVE_DMA(&hIveHandle, &stSrcData, &stDstData, &stCtrl, bInstant);
744 SAMPLE_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, "Error(%#x),HI_MPI_IVE_DMA failed!\n", s32Ret);
745
746 if (HI_TRUE == bInstant) {
747 s32Ret = HI_MPI_IVE_Query(hIveHandle, &bFinish, bBlock);
748 while (s32Ret == HI_ERR_IVE_QUERY_TIMEOUT) {
749 usleep(100); /* sleep 100 us */
750 s32Ret = HI_MPI_IVE_Query(hIveHandle, &bFinish, bBlock);
751 }
752 SAMPLE_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, "Error(%#x),HI_MPI_IVE_Query failed!\n", s32Ret);
753 }
754
755 return HI_SUCCESS;
756 }
757
SAMPLE_COMM_IVE_StartVpss(SIZE_S * pastSize,HI_U32 u32VpssChnNum)758 HI_S32 SAMPLE_COMM_IVE_StartVpss(SIZE_S *pastSize, HI_U32 u32VpssChnNum)
759 {
760 HI_U32 i;
761 VPSS_CHN_ATTR_S astVpssChnAttr[VPSS_MAX_CHN_NUM];
762 VPSS_GRP_ATTR_S stVpssGrpAttr = { 0 };
763 HI_BOOL abChnEnable[VPSS_MAX_CHN_NUM] = {HI_FALSE, HI_FALSE, HI_FALSE, HI_FALSE};
764 VPSS_GRP VpssGrp = 0;
765
766 CHECK_NULL_PTR(pastSize);
767 stVpssGrpAttr.u32MaxW = IMG_2M_WIDTH;
768 stVpssGrpAttr.u32MaxH = IMG_2M_HEIGHT;
769 stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1;
770 stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1;
771 stVpssGrpAttr.enDynamicRange = DYNAMIC_RANGE_SDR8;
772 stVpssGrpAttr.enPixelFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
773 stVpssGrpAttr.bNrEn = HI_FALSE;
774
775 for (i = 0; i < u32VpssChnNum; i++) {
776 abChnEnable[i] = HI_TRUE;
777 }
778
779 for (i = 0; i < VPSS_MAX_CHN_NUM; i++) {
780 astVpssChnAttr[i].u32Width = pastSize[i].u32Width;
781 astVpssChnAttr[i].u32Height = pastSize[i].u32Height;
782 astVpssChnAttr[i].enChnMode = VPSS_CHN_MODE_USER;
783 astVpssChnAttr[i].enCompressMode = COMPRESS_MODE_NONE;
784 astVpssChnAttr[i].enDynamicRange = DYNAMIC_RANGE_SDR8;
785 astVpssChnAttr[i].enVideoFormat = VIDEO_FORMAT_LINEAR;
786 astVpssChnAttr[i].enPixelFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
787 astVpssChnAttr[i].stFrameRate.s32SrcFrameRate = -1;
788 astVpssChnAttr[i].stFrameRate.s32DstFrameRate = -1;
789 astVpssChnAttr[i].u32Depth = 1;
790 astVpssChnAttr[i].bMirror = HI_FALSE;
791 astVpssChnAttr[i].bFlip = HI_FALSE;
792 astVpssChnAttr[i].stAspectRatio.enMode = ASPECT_RATIO_NONE;
793 }
794
795 return SAMPLE_COMM_VPSS_Start(VpssGrp, abChnEnable, &stVpssGrpAttr, &astVpssChnAttr[0]);
796 }
797
SAMPLE_COMM_IVE_StopVpss(HI_U32 u32VpssChnNum)798 HI_VOID SAMPLE_COMM_IVE_StopVpss(HI_U32 u32VpssChnNum)
799 {
800 VPSS_GRP VpssGrp = 0;
801 HI_BOOL abChnEnable[VPSS_MAX_CHN_NUM] = {HI_FALSE, HI_FALSE, HI_FALSE, HI_FALSE};
802 HI_U32 i = 0;
803
804 for (i = 0; i < u32VpssChnNum; i++) {
805 abChnEnable[i] = HI_TRUE;
806 }
807
808 (HI_VOID)SAMPLE_COMM_VPSS_Stop(VpssGrp, abChnEnable);
809
810 return;
811 }
812
SAMPLE_COMM_IVE_StartVo(HI_VOID)813 HI_S32 SAMPLE_COMM_IVE_StartVo(HI_VOID)
814 {
815 HI_S32 s32Ret;
816 VO_DEV VoDev = SAMPLE_VO_DEV_DHD0;
817 VO_LAYER VoLayer = 0;
818 VO_PUB_ATTR_S stVoPubAttr;
819 VO_VIDEO_LAYER_ATTR_S stLayerAttr;
820 SAMPLE_VO_MODE_E enVoMode = VO_MODE_1MUX;
821 HI_U32 u32DisBufLen = 3;
822
823 stVoPubAttr.enIntfSync = VO_OUTPUT_1080P30;
824 stVoPubAttr.enIntfType = VO_INTF_HDMI;
825 stVoPubAttr.u32BgColor = COLOR_RGB_BLUE;
826 s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stVoPubAttr);
827 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, VO_FAIL_0, "SAMPLE_COMM_VO_StartDev failed,Error(%#x)!\n", s32Ret);
828
829 s32Ret = SAMPLE_COMM_VO_HdmiStart(stVoPubAttr.enIntfSync);
830 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, VO_FAIL_1, "SAMPLE_COMM_VO_HdmiStart failed,Error(%#x)!\n", s32Ret);
831
832 s32Ret = SAMPLE_COMM_VO_GetWH(stVoPubAttr.enIntfSync, &stLayerAttr.stDispRect.u32Width,
833 &stLayerAttr.stDispRect.u32Height, &stLayerAttr.u32DispFrmRt);
834 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, VO_FAIL_2, "SAMPLE_COMM_VO_GetWH failed,Error(%#x)!\n", s32Ret);
835
836 s32Ret = HI_MPI_VO_SetDisplayBufLen(VoLayer, u32DisBufLen);
837 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, VO_FAIL_2, "HI_MPI_VO_SetDisplayBufLen failed,Error(%#x)!\n", s32Ret);
838
839 stLayerAttr.stDispRect.s32X = 0;
840 stLayerAttr.stDispRect.s32Y = 0;
841 stLayerAttr.stImageSize.u32Width = stLayerAttr.stDispRect.u32Width;
842 stLayerAttr.stImageSize.u32Height = stLayerAttr.stDispRect.u32Height;
843 stLayerAttr.bDoubleFrame = HI_FALSE;
844 stLayerAttr.bClusterMode = HI_FALSE;
845 stLayerAttr.enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
846 stLayerAttr.enDstDynamicRange = DYNAMIC_RANGE_SDR8;
847
848 s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr);
849 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, VO_FAIL_2, "SAMPLE_COMM_VO_StartLayer failed,Error(%#x)!\n", s32Ret);
850
851 s32Ret = SAMPLE_COMM_VO_StartChn(VoLayer, enVoMode);
852 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, VO_FAIL_3, "SAMPLE_COMM_VO_StartChn failed,Error(%#x)!\n", s32Ret);
853
854 return s32Ret;
855 VO_FAIL_3:
856 SAMPLE_COMM_VO_StopLayer(VoLayer);
857 VO_FAIL_2:
858 SAMPLE_COMM_VO_HdmiStop();
859 VO_FAIL_1:
860 SAMPLE_COMM_VO_StopDev(VoDev);
861 VO_FAIL_0:
862 return s32Ret;
863 }
864
SAMPLE_COMM_IVE_StopVo(HI_VOID)865 HI_VOID SAMPLE_COMM_IVE_StopVo(HI_VOID)
866 {
867 VO_DEV VoDev = SAMPLE_VO_DEV_DHD0;
868 VO_LAYER VoLayer = 0;
869 SAMPLE_VO_MODE_E enVoMode = VO_MODE_1MUX;
870
871 (HI_VOID)SAMPLE_COMM_VO_StopChn(VoDev, enVoMode);
872 (HI_VOID)SAMPLE_COMM_VO_StopLayer(VoLayer);
873 SAMPLE_COMM_VO_HdmiStop();
874 (HI_VOID)SAMPLE_COMM_VO_StopDev(VoDev);
875 }
876
877 /* function : Start Vi/Vpss/Venc/Vo */
SAMPLE_COMM_IVE_StartViVpssVencVo(SAMPLE_VI_CONFIG_S * pstViConfig,SAMPLE_IVE_SWITCH_S * pstSwitch,PIC_SIZE_E * penExtPicSize)878 HI_S32 SAMPLE_COMM_IVE_StartViVpssVencVo(SAMPLE_VI_CONFIG_S *pstViConfig, SAMPLE_IVE_SWITCH_S *pstSwitch,
879 PIC_SIZE_E *penExtPicSize)
880 {
881 SIZE_S astSize[VPSS_CHN_NUM];
882 PIC_SIZE_E aenSize[VPSS_CHN_NUM];
883 VI_CHN_ATTR_S stViChnAttr;
884 SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;
885 PAYLOAD_TYPE_E enStreamType = PT_H264;
886 HI_BOOL bRcnRefShareBuf = HI_FALSE;
887 VENC_GOP_ATTR_S stGopAttr;
888 VI_DEV ViDev0 = 0;
889 VI_PIPE ViPipe0 = 0;
890 VI_CHN ViChn = 0;
891 HI_S32 s32ViCnt = 1;
892 HI_S32 s32WorkSnsId = 0;
893 VPSS_GRP VpssGrp = 0;
894 HI_S32 s32Ret = HI_SUCCESS;
895 VENC_CHN VeH264Chn = 0;
896 WDR_MODE_E enWDRMode = WDR_MODE_NONE;
897 DYNAMIC_RANGE_E enDynamicRange = DYNAMIC_RANGE_SDR8;
898 PIXEL_FORMAT_E enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
899 VIDEO_FORMAT_E enVideoFormat = VIDEO_FORMAT_LINEAR;
900 COMPRESS_MODE_E enCompressMode = COMPRESS_MODE_NONE;
901 VI_VPSS_MODE_E enMastPipeMode = VI_ONLINE_VPSS_OFFLINE;
902
903 CHECK_NULL_PTR(pstViConfig);
904 CHECK_NULL_PTR(pstSwitch);
905 CHECK_NULL_PTR(penExtPicSize);
906 (HI_VOID)memset_s(pstViConfig, sizeof(*pstViConfig), 0, sizeof(*pstViConfig));
907
908 SAMPLE_COMM_VI_GetSensorInfo(pstViConfig);
909 pstViConfig->s32WorkingViNum = s32ViCnt;
910
911 pstViConfig->as32WorkingViId[0] = 0;
912 pstViConfig->astViInfo[0].stSnsInfo.MipiDev =
913 SAMPLE_COMM_VI_GetComboDevBySensor(pstViConfig->astViInfo[0].stSnsInfo.enSnsType, 0);
914 pstViConfig->astViInfo[0].stSnsInfo.s32BusId = 0;
915
916 pstViConfig->astViInfo[0].stDevInfo.ViDev = ViDev0;
917 pstViConfig->astViInfo[0].stDevInfo.enWDRMode = enWDRMode;
918
919 pstViConfig->astViInfo[0].stPipeInfo.enMastPipeMode = enMastPipeMode;
920 pstViConfig->astViInfo[0].stPipeInfo.aPipe[0] = ViPipe0;
921 pstViConfig->astViInfo[0].stPipeInfo.aPipe[1] = -1; /* pipe index: 1 */
922 pstViConfig->astViInfo[0].stPipeInfo.aPipe[2] = -1; /* pipe index: 2 */
923 pstViConfig->astViInfo[0].stPipeInfo.aPipe[3] = -1; /* pipe index: 3 */
924
925 pstViConfig->astViInfo[0].stChnInfo.ViChn = ViChn;
926 pstViConfig->astViInfo[0].stChnInfo.enPixFormat = enPixFormat;
927 pstViConfig->astViInfo[0].stChnInfo.enDynamicRange = enDynamicRange;
928 pstViConfig->astViInfo[0].stChnInfo.enVideoFormat = enVideoFormat;
929 pstViConfig->astViInfo[0].stChnInfo.enCompressMode = enCompressMode;
930
931 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(pstViConfig->astViInfo[s32WorkSnsId].stSnsInfo.enSnsType, &aenSize[0]);
932 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_0, "Error(%#x),SAMPLE_COMM_VI_GetSizeBySensor failed!\n",
933 s32Ret);
934 aenSize[1] = *penExtPicSize;
935
936 /* step 1: Init vb */
937 s32Ret = SAMPLE_COMM_IVE_VbInit(aenSize, astSize, VPSS_CHN_NUM);
938 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_0, "Error(%#x),SAMPLE_COMM_IVE_VbInit failed!\n", s32Ret);
939 /* step 2: Start vi */
940 s32Ret = SAMPLE_COMM_VI_SetParam(pstViConfig);
941 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_1, "Error(%#x),SAMPLE_COMM_VI_SetParam failed!\n", s32Ret);
942
943 s32Ret = SAMPLE_COMM_VI_StartVi(pstViConfig);
944 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_1, "Error(%#x),SAMPLE_COMM_VI_StartVi failed!\n", s32Ret);
945 /* step 3: Start vpss */
946 s32Ret = SAMPLE_COMM_IVE_StartVpss(astSize, VPSS_CHN_NUM);
947 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_2, "Error(%#x),SAMPLE_IVS_StartVpss failed!\n", s32Ret);
948 /* step 4: Bind vpss to vi */
949 s32Ret = SAMPLE_COMM_VI_Bind_VPSS(ViPipe0, ViChn, VpssGrp);
950 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_3, "Error(%#x),SAMPLE_COMM_VI_BindVpss failed!\n", s32Ret);
951 // Set vi frame
952 s32Ret = HI_MPI_VI_GetChnAttr(ViPipe0, ViChn, &stViChnAttr);
953 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_4, "Error(%#x),HI_MPI_VI_GetChnAttr failed!\n", s32Ret);
954
955 s32Ret = HI_MPI_VI_SetChnAttr(ViPipe0, ViChn, &stViChnAttr);
956 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_4, "Error(%#x),HI_MPI_VI_SetChnAttr failed!\n", s32Ret);
957 /* step 5: Start Vo */
958 if (pstSwitch->bVo == HI_TRUE) {
959 s32Ret = SAMPLE_COMM_IVE_StartVo();
960 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_4, "Error(%#x),SAMPLE_COMM_IVE_StartVo failed!\n",
961 s32Ret);
962 }
963 /* step 6: Start Venc */
964 if (pstSwitch->bVenc == HI_TRUE) {
965 s32Ret = SAMPLE_COMM_VENC_GetGopAttr(VENC_GOPMODE_NORMALP, &stGopAttr);
966 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_5, "Error(%#x),SAMPLE_COMM_VENC_GetGopAttr failed!\n",
967 s32Ret);
968 s32Ret = SAMPLE_COMM_VENC_Start(VeH264Chn, enStreamType, aenSize[0], enRcMode, 0, bRcnRefShareBuf, &stGopAttr);
969 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_5, "Error(%#x),SAMPLE_COMM_VENC_Start failed!\n", s32Ret);
970 s32Ret = SAMPLE_COMM_VENC_StartGetStream(&VeH264Chn, 1);
971 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, END_INIT_6, "Error(%#x),SAMPLE_COMM_VENC_StartGetStream failed!\n",
972 s32Ret);
973 }
974
975 return HI_SUCCESS;
976
977 END_INIT_6:
978 if (pstSwitch->bVenc == HI_TRUE) {
979 SAMPLE_COMM_VENC_Stop(VeH264Chn);
980 }
981 END_INIT_5:
982 if (pstSwitch->bVo == HI_TRUE) {
983 SAMPLE_COMM_IVE_StopVo();
984 }
985 END_INIT_4:
986 SAMPLE_COMM_VI_UnBind_VPSS(ViPipe0, ViChn, VpssGrp);
987 END_INIT_3:
988 SAMPLE_COMM_IVE_StopVpss(VPSS_CHN_NUM);
989 END_INIT_2:
990 SAMPLE_COMM_VI_StopVi(pstViConfig);
991 END_INIT_1:
992 SAMPLE_COMM_SYS_Exit();
993 (HI_VOID)memset_s(pstViConfig, sizeof(*pstViConfig), 0, sizeof(*pstViConfig));
994 END_INIT_0:
995
996 return s32Ret;
997 }
998
999 /* function : Stop Vi/Vpss/Venc/Vo */
SAMPLE_COMM_IVE_StopViVpssVencVo(SAMPLE_VI_CONFIG_S * pstViConfig,SAMPLE_IVE_SWITCH_S * pstSwitch)1000 HI_VOID SAMPLE_COMM_IVE_StopViVpssVencVo(SAMPLE_VI_CONFIG_S *pstViConfig, SAMPLE_IVE_SWITCH_S *pstSwitch)
1001 {
1002 if (pstSwitch->bVenc == HI_TRUE) {
1003 SAMPLE_COMM_VENC_StopGetStream();
1004 SAMPLE_COMM_VENC_Stop(0);
1005 }
1006 if (pstSwitch->bVo == HI_TRUE) {
1007 SAMPLE_COMM_IVE_StopVo();
1008 }
1009
1010 SAMPLE_COMM_VI_UnBind_VPSS(pstViConfig->astViInfo[0].stPipeInfo.aPipe[0], pstViConfig->astViInfo[0].stChnInfo.ViChn,
1011 0);
1012 SAMPLE_COMM_IVE_StopVpss(VPSS_CHN_NUM);
1013 SAMPLE_COMM_VI_StopVi(pstViConfig);
1014 SAMPLE_COMM_SYS_Exit();
1015
1016 (HI_VOID)memset_s(pstViConfig, sizeof(*pstViConfig), 0, sizeof(*pstViConfig));
1017 }
1018