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 <sys/types.h>
19 #include <sys/stat.h>
20 #include <sys/ioctl.h>
21 #include <poll.h>
22 #include <sys/time.h>
23 #include <sys/select.h>
24 #include <fcntl.h>
25 #include <errno.h>
26 #include <pthread.h>
27 #include <math.h>
28 #include <unistd.h>
29 #include <signal.h>
30 #include <sys/prctl.h>
31 #include <limits.h>
32 #include "sample_comm.h"
33 #include "autoconf.h"
34
35 #ifdef __cplusplus
36 #if __cplusplus
37 extern "C" {
38 #endif
39 #endif /* End of #ifdef __cplusplus */
40
41 #define TEMP_BUF_LEN 8
42 #define PER_UNIT 1024
43 #define MAX_THM_SIZE (64 * 1024)
44
45 static pthread_t gs_VencPid;
46 static pthread_t gs_VencQpmapPid;
47 static SAMPLE_VENC_GETSTREAM_PARA_S gs_stPara;
48 static SAMPLE_VENC_QPMAP_SENDFRAME_PARA_S stQpMapSendFramePara;
49 static HI_S32 gs_s32SnapCnt = 0;
50 HI_CHAR *DstBuf = NULL;
51
FileTrans_GetThmFromJpg(const HI_CHAR * JPGPath,HI_S32 * DstSize)52 static HI_S32 FileTrans_GetThmFromJpg(const HI_CHAR *JPGPath, HI_S32 *DstSize)
53 {
54 HI_S32 bufpos = 0;
55 HI_CHAR temp_read = 0;
56 HI_CHAR preflag = 0xff;
57 HI_CHAR startflag = 0xd8;
58 HI_CHAR endflag = 0xd9;
59 HI_S32 startpos = 0;
60 HI_S32 endpos = 0;
61 HI_S32 dcf_len = 0;
62 HI_BOOL startflag_match = HI_FALSE;
63 HI_CHAR real_path[PATH_MAX] = {0};
64
65 HI_S32 fd = 0;
66 struct stat stStat = { 0 };
67 FILE *fpJpg = NULL;
68
69 if (realpath(JPGPath, real_path) == HI_NULL) {
70 printf("file %s error!\n", real_path);
71 return HI_FAILURE;
72 }
73
74 fd = open(real_path, O_RDONLY, S_IRUSR | S_IWUSR);
75 if (fd < 0) {
76 printf("file %s not exist!\n", real_path);
77 return HI_FAILURE;
78 } else {
79 fpJpg = fdopen(fd, "rb");
80 if (fpJpg == HI_NULL) {
81 close(fd);
82 printf("fdopen fail!\n");
83 return HI_FAILURE;
84 }
85 fstat(fd, &stStat);
86 while (feof(fpJpg) == 0) {
87 if (temp_read == preflag) {
88 temp_read = getc(fpJpg);
89 if (temp_read == startflag) {
90 startpos = ftell(fpJpg) - 2; /* 2 byte */
91 if (startpos < 0) {
92 startpos = 0;
93 }
94 startflag_match = HI_TRUE;
95 }
96 if (temp_read == endflag) {
97 endpos = ftell(fpJpg);
98 if (startflag_match == HI_TRUE) {
99 break;
100 }
101 }
102 } else {
103 temp_read = getc(fpJpg);
104 }
105 bufpos++;
106 }
107 }
108
109 if (startflag_match != HI_TRUE) {
110 printf("%s, %d: no start flag, get .thm fail!\n", __FUNCTION__, __LINE__);
111 (HI_VOID)fclose(fpJpg);
112 return HI_FAILURE;
113 }
114
115 dcf_len = endpos - startpos;
116 if (dcf_len <= 0 || dcf_len > MAX_THM_SIZE || dcf_len >= stStat.st_size) {
117 printf("%s, %d: length is %d, get .thm fail!\n", __FUNCTION__, __LINE__, endpos - startpos);
118 (HI_VOID)fclose(fpJpg);
119 return HI_FAILURE;
120 }
121
122 HI_CHAR *cDstBuf = (HI_CHAR *)malloc(endpos - startpos);
123 if (cDstBuf == NULL) {
124 printf("memory malloc fail!\n");
125 (HI_VOID)fclose(fpJpg);
126 return HI_FAILURE;
127 }
128
129 (HI_VOID)fseek(fpJpg, (long)startpos, SEEK_SET);
130 *DstSize = fread(cDstBuf, 1, endpos - startpos, fpJpg);
131 if (*DstSize != (endpos - startpos)) {
132 free(cDstBuf);
133 printf("fread fail!\n");
134 (HI_VOID)fclose(fpJpg);
135 return HI_FAILURE;
136 }
137
138 DstBuf = cDstBuf;
139 (HI_VOID)fclose(fpJpg);
140
141 return HI_SUCCESS;
142 }
143
SAMPLE_COMM_VENC_MemConfig(HI_VOID)144 HI_S32 SAMPLE_COMM_VENC_MemConfig(HI_VOID)
145 {
146 HI_S32 i = 0;
147 HI_S32 s32Ret;
148 HI_CHAR *pcMmzName = HI_NULL;
149 MPP_CHN_S stMppChnVENC;
150
151 for (i = 0; i < 64; i++) { /* group, venc max chn is 64 */
152 stMppChnVENC.enModId = HI_ID_VENC;
153 stMppChnVENC.s32DevId = 0;
154 stMppChnVENC.s32ChnId = i;
155 pcMmzName = NULL;
156
157 s32Ret = HI_MPI_SYS_SetMemConfig(&stMppChnVENC, pcMmzName);
158 if (s32Ret != HI_SUCCESS) {
159 SAMPLE_PRT("HI_MPI_SYS_SetMemConfig with %#x!\n", s32Ret);
160 return HI_FAILURE;
161 }
162 }
163 return HI_SUCCESS;
164 }
165
SAMPLE_COMM_VENC_GetFilePostfix(PAYLOAD_TYPE_E enPayload,HI_CHAR * szFilePostfix,HI_U8 len)166 static HI_S32 SAMPLE_COMM_VENC_GetFilePostfix(PAYLOAD_TYPE_E enPayload, HI_CHAR *szFilePostfix, HI_U8 len)
167 {
168 if (szFilePostfix == NULL) {
169 SAMPLE_PRT("null pointer\n");
170 return HI_FAILURE;
171 }
172
173 if (PT_H264 == enPayload) {
174 if (strcpy_s(szFilePostfix, len, ".h264") != EOK) {
175 return HI_FAILURE;
176 }
177 } else if (PT_H265 == enPayload) {
178 if (strcpy_s(szFilePostfix, len, ".h265") != EOK) {
179 return HI_FAILURE;
180 }
181 } else if (PT_JPEG == enPayload) {
182 if (strcpy_s(szFilePostfix, len, ".jpg") != EOK) {
183 return HI_FAILURE;
184 }
185 } else if (PT_MJPEG == enPayload) {
186 if (strcpy_s(szFilePostfix, len, ".mjp") != EOK) {
187 return HI_FAILURE;
188 }
189 } else {
190 SAMPLE_PRT("payload type err!\n");
191 return HI_FAILURE;
192 }
193 return HI_SUCCESS;
194 }
195
SAMPLE_COMM_VENC_GetGopAttr(VENC_GOP_MODE_E enGopMode,VENC_GOP_ATTR_S * pstGopAttr)196 HI_S32 SAMPLE_COMM_VENC_GetGopAttr(VENC_GOP_MODE_E enGopMode, VENC_GOP_ATTR_S *pstGopAttr)
197 {
198 if (pstGopAttr == NULL) {
199 SAMPLE_PRT("null pointer\n");
200 return HI_FAILURE;
201 }
202 switch (enGopMode) {
203 case VENC_GOPMODE_NORMALP:
204 pstGopAttr->enGopMode = VENC_GOPMODE_NORMALP;
205 pstGopAttr->stNormalP.s32IPQpDelta = 2; /* set 2 */
206 break;
207 case VENC_GOPMODE_SMARTP:
208 pstGopAttr->enGopMode = VENC_GOPMODE_SMARTP;
209 pstGopAttr->stSmartP.s32BgQpDelta = 4; /* set 4 */
210 pstGopAttr->stSmartP.s32ViQpDelta = 2; /* set 2 */
211 pstGopAttr->stSmartP.u32BgInterval = 90; /* set 90 */
212 break;
213
214 case VENC_GOPMODE_DUALP:
215 pstGopAttr->enGopMode = VENC_GOPMODE_DUALP;
216 pstGopAttr->stDualP.s32IPQpDelta = 4; /* set 4 */
217 pstGopAttr->stDualP.s32SPQpDelta = 2; /* set 2 */
218 pstGopAttr->stDualP.u32SPInterval = 3; /* set 3 */
219 break;
220
221 case VENC_GOPMODE_BIPREDB:
222 pstGopAttr->enGopMode = VENC_GOPMODE_BIPREDB;
223 pstGopAttr->stBipredB.s32BQpDelta = -2; /* set -2 */
224 pstGopAttr->stBipredB.s32IPQpDelta = 3; /* set 3 */
225 pstGopAttr->stBipredB.u32BFrmNum = 2; /* set 2 */
226 break;
227
228 default:
229 SAMPLE_PRT("not support the gop mode !\n");
230 return HI_FAILURE;
231 break;
232 }
233 return HI_SUCCESS;
234 }
235
SAMPLE_COMM_VENC_Getdcfinfo(const char * SrcJpgPath,const char * DstThmPath)236 static HI_S32 SAMPLE_COMM_VENC_Getdcfinfo(const char *SrcJpgPath, const char *DstThmPath)
237 {
238 HI_S32 s32RtnVal = HI_SUCCESS;
239 HI_CHAR JPGSrcPath[FILE_NAME_LEN] = {0};
240 HI_CHAR JPGDesPath[FILE_NAME_LEN] = {0};
241 HI_S32 DstSize = 0;
242 HI_S32 fd = -1;
243 HI_S32 u32WritenSize = 0;
244
245 if (snprintf_s(JPGSrcPath, sizeof(JPGSrcPath), sizeof(JPGSrcPath) - 1, "%s", SrcJpgPath) < 0) {
246 return HI_FAILURE;
247 }
248 if (snprintf_s(JPGDesPath, sizeof(JPGDesPath), sizeof(JPGDesPath) - 1, "%s", DstThmPath) < 0) {
249 return HI_FAILURE;
250 }
251
252 s32RtnVal = FileTrans_GetThmFromJpg(JPGSrcPath, &DstSize);
253 if ((HI_SUCCESS != s32RtnVal) || (DstSize == 0)) {
254 printf("fail to get thm\n");
255 return HI_FAILURE;
256 }
257
258 fd = open(JPGDesPath, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
259 if (fd < 0) {
260 printf("file to create file %s\n", JPGDesPath);
261 return HI_FAILURE;
262 }
263
264 FILE *fpTHM = fdopen(fd, "w");
265 if (fpTHM == HI_NULL) {
266 printf("fdopen fail!\n");
267 close(fd);
268 return HI_FAILURE;
269 }
270
271 while (u32WritenSize < DstSize) {
272 s32RtnVal = fwrite(DstBuf + u32WritenSize, 1, DstSize, fpTHM);
273 if (s32RtnVal <= 0) {
274 printf("fail to write file, rtn=%d\n", s32RtnVal);
275 break;
276 }
277
278 u32WritenSize += s32RtnVal;
279 }
280
281 if (fpTHM != HI_NULL) {
282 (HI_VOID)fclose(fpTHM);
283 fpTHM = 0;
284 }
285
286 if (DstBuf != NULL) {
287 free(DstBuf);
288 DstBuf = NULL;
289 }
290
291 return 0;
292 }
293
SAMPLE_COMM_VENC_SaveStream(FILE * pFd,VENC_STREAM_S * pstStream)294 HI_S32 SAMPLE_COMM_VENC_SaveStream(FILE *pFd, VENC_STREAM_S *pstStream)
295 {
296 HI_U32 i;
297
298 if ((pFd == NULL) || (pstStream == NULL)) {
299 SAMPLE_PRT("null pointer\n");
300 return HI_FAILURE;
301 }
302 for (i = 0; i < pstStream->u32PackCount; i++) {
303 (HI_VOID)fwrite(pstStream->pstPack[i].pu8Addr + pstStream->pstPack[i].u32Offset,
304 pstStream->pstPack[i].u32Len - pstStream->pstPack[i].u32Offset, 1, pFd);
305
306 (HI_VOID)fflush(pFd);
307 }
308
309 return HI_SUCCESS;
310 }
311
SAMPLE_COMM_VENC_CloseReEncode(VENC_CHN VencChn)312 static HI_S32 SAMPLE_COMM_VENC_CloseReEncode(VENC_CHN VencChn)
313 {
314 HI_S32 s32Ret;
315 VENC_RC_PARAM_S stRcParam;
316 VENC_CHN_ATTR_S stChnAttr;
317
318 s32Ret = HI_MPI_VENC_GetChnAttr(VencChn, &stChnAttr);
319 if (s32Ret != HI_SUCCESS) {
320 SAMPLE_PRT("GetChnAttr failed!\n");
321 return HI_FAILURE;
322 }
323
324 s32Ret = HI_MPI_VENC_GetRcParam(VencChn, &stRcParam);
325 if (s32Ret != HI_SUCCESS) {
326 SAMPLE_PRT("GetRcParam failed!\n");
327 return HI_FAILURE;
328 }
329
330 if (VENC_RC_MODE_H264CBR == stChnAttr.stRcAttr.enRcMode) {
331 stRcParam.stParamH264Cbr.s32MaxReEncodeTimes = 0;
332 } else if (VENC_RC_MODE_H264VBR == stChnAttr.stRcAttr.enRcMode) {
333 stRcParam.stParamH264Vbr.s32MaxReEncodeTimes = 0;
334 } else if (VENC_RC_MODE_H265CBR == stChnAttr.stRcAttr.enRcMode) {
335 stRcParam.stParamH265Cbr.s32MaxReEncodeTimes = 0;
336 } else if (VENC_RC_MODE_H265VBR == stChnAttr.stRcAttr.enRcMode) {
337 stRcParam.stParamH265Vbr.s32MaxReEncodeTimes = 0;
338 } else {
339 return HI_SUCCESS;
340 }
341 s32Ret = HI_MPI_VENC_SetRcParam(VencChn, &stRcParam);
342 if (s32Ret != HI_SUCCESS) {
343 SAMPLE_PRT("SetRcParam failed!\n");
344 return HI_FAILURE;
345 }
346 return HI_SUCCESS;
347 }
348
SAMPLE_COMM_VENC_Create(VENC_CHN VencChn,PAYLOAD_TYPE_E enType,PIC_SIZE_E enSize,SAMPLE_RC_E enRcMode,HI_U32 u32Profile,HI_BOOL bRcnRefShareBuf,VENC_GOP_ATTR_S * pstGopAttr)349 HI_S32 SAMPLE_COMM_VENC_Create(VENC_CHN VencChn, PAYLOAD_TYPE_E enType, PIC_SIZE_E enSize, SAMPLE_RC_E enRcMode,
350 HI_U32 u32Profile, HI_BOOL bRcnRefShareBuf, VENC_GOP_ATTR_S *pstGopAttr)
351 {
352 HI_S32 s32Ret;
353 SIZE_S stPicSize;
354 VENC_CHN_ATTR_S stVencChnAttr;
355 VENC_ATTR_JPEG_S stJpegAttr;
356 SAMPLE_VI_CONFIG_S stViConfig;
357 HI_U32 u32FrameRate;
358 HI_U32 u32StatTime;
359 HI_U32 u32Gop = 30; /* default set 30 */
360
361 if (pstGopAttr == NULL) {
362 SAMPLE_PRT("pstGopAttr is null!\n");
363 return HI_FAILURE;
364 }
365
366 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSize, &stPicSize);
367 if (s32Ret != HI_SUCCESS) {
368 SAMPLE_PRT("Get picture size failed!\n");
369 return HI_FAILURE;
370 }
371
372 SAMPLE_COMM_VI_GetSensorInfo(&stViConfig);
373 if (stViConfig.astViInfo[0].stSnsInfo.enSnsType == SAMPLE_SNS_TYPE_BUTT) {
374 SAMPLE_PRT("Not set SENSOR%d_TYPE !\n", 0);
375 return HI_FAILURE;
376 }
377 s32Ret = SAMPLE_COMM_VI_GetFrameRateBySensor(stViConfig.astViInfo[0].stSnsInfo.enSnsType, &u32FrameRate);
378 if (s32Ret != HI_SUCCESS) {
379 SAMPLE_PRT("SAMPLE_COMM_VI_GetFrameRateBySensor failed!\n");
380 return s32Ret;
381 }
382
383 /* step 1: Create Venc Channel */
384 stVencChnAttr.stVencAttr.enType = enType;
385 stVencChnAttr.stVencAttr.u32MaxPicWidth = stPicSize.u32Width;
386 stVencChnAttr.stVencAttr.u32MaxPicHeight = stPicSize.u32Height;
387 stVencChnAttr.stVencAttr.u32PicWidth = stPicSize.u32Width; /* the picture width */
388 stVencChnAttr.stVencAttr.u32PicHeight = stPicSize.u32Height; /* the picture height */
389
390 if (enType == PT_MJPEG || enType == PT_JPEG) {
391 stVencChnAttr.stVencAttr.u32BufSize =
392 HI_ALIGN_UP(stPicSize.u32Width, 16) * HI_ALIGN_UP(stPicSize.u32Height, 16); /* 16 align */
393 } else {
394 stVencChnAttr.stVencAttr.u32BufSize =
395 HI_ALIGN_UP(stPicSize.u32Width * stPicSize.u32Height * 3 / 4, 64); /* * 3 / 4, 64 align */
396 }
397 stVencChnAttr.stVencAttr.u32Profile = u32Profile;
398 stVencChnAttr.stVencAttr.bByFrame = HI_TRUE; /* get stream mode is slice mode or frame mode? */
399
400 if (pstGopAttr->enGopMode == VENC_GOPMODE_SMARTP) {
401 u32StatTime = pstGopAttr->stSmartP.u32BgInterval / u32Gop;
402 } else {
403 u32StatTime = 1;
404 }
405
406 switch (enType) {
407 case PT_H265: {
408 if (enRcMode == SAMPLE_RC_CBR) {
409 VENC_H265_CBR_S stH265Cbr;
410
411 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H265CBR;
412 stH265Cbr.u32Gop = u32Gop;
413 stH265Cbr.u32StatTime = u32StatTime; /* stream rate statics time(s) */
414 stH265Cbr.u32SrcFrameRate = u32FrameRate; /* input (vi) frame rate */
415 stH265Cbr.fr32DstFrameRate = u32FrameRate; /* target frame rate */
416 switch (enSize) {
417 case PIC_720P:
418 stH265Cbr.u32BitRate = PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
419 break;
420 case PIC_1080P:
421 stH265Cbr.u32BitRate = PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
422 break;
423 case PIC_2592x1944:
424 stH265Cbr.u32BitRate = PER_UNIT * 3 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 3M + 3M */
425 break;
426 case PIC_3840x2160:
427 stH265Cbr.u32BitRate = PER_UNIT * 5 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 5M + 5M */
428 break;
429 default:
430 stH265Cbr.u32BitRate = PER_UNIT * 15 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 15M + 2M */
431 break;
432 }
433 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH265Cbr, sizeof(VENC_H265_CBR_S), &stH265Cbr,
434 sizeof(VENC_H265_CBR_S));
435 } else if (enRcMode == SAMPLE_RC_FIXQP) {
436 VENC_H265_FIXQP_S stH265FixQp;
437
438 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H265FIXQP;
439 stH265FixQp.u32Gop = u32Gop;
440 stH265FixQp.u32SrcFrameRate = u32FrameRate;
441 stH265FixQp.fr32DstFrameRate = u32FrameRate;
442 stH265FixQp.u32IQp = 25; /* set 25 */
443 stH265FixQp.u32PQp = 30; /* set 30 */
444 stH265FixQp.u32BQp = 32; /* set 32 */
445 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH265FixQp, sizeof(VENC_H265_FIXQP_S), &stH265FixQp,
446 sizeof(VENC_H265_FIXQP_S));
447 } else if (enRcMode == SAMPLE_RC_VBR) {
448 VENC_H265_VBR_S stH265Vbr;
449
450 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H265VBR;
451 stH265Vbr.u32Gop = u32Gop;
452 stH265Vbr.u32StatTime = u32StatTime;
453 stH265Vbr.u32SrcFrameRate = u32FrameRate;
454 stH265Vbr.fr32DstFrameRate = u32FrameRate;
455 switch (enSize) {
456 case PIC_720P:
457 stH265Vbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
458 break;
459 case PIC_1080P:
460 stH265Vbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
461 break;
462 case PIC_2592x1944:
463 stH265Vbr.u32MaxBitRate = PER_UNIT * 3 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 3M + 3M */
464 break;
465 case PIC_3840x2160:
466 stH265Vbr.u32MaxBitRate = PER_UNIT * 5 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 5M + 5M */
467 break;
468 default:
469 stH265Vbr.u32MaxBitRate = PER_UNIT * 15 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 15M + 2M */
470 break;
471 }
472 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH265Vbr, sizeof(VENC_H265_VBR_S), &stH265Vbr,
473 sizeof(VENC_H265_VBR_S));
474 } else if (enRcMode == SAMPLE_RC_AVBR) {
475 VENC_H265_AVBR_S stH265AVbr;
476
477 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H265AVBR;
478 stH265AVbr.u32Gop = u32Gop;
479 stH265AVbr.u32StatTime = u32StatTime;
480 stH265AVbr.u32SrcFrameRate = u32FrameRate;
481 stH265AVbr.fr32DstFrameRate = u32FrameRate;
482 switch (enSize) {
483 case PIC_720P:
484 stH265AVbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
485 break;
486 case PIC_1080P:
487 stH265AVbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
488 break;
489 case PIC_2592x1944:
490 stH265AVbr.u32MaxBitRate = PER_UNIT * 3 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 3M + 3M */
491 break;
492 case PIC_3840x2160:
493 stH265AVbr.u32MaxBitRate = PER_UNIT * 5 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 5M + 5M */
494 break;
495 default:
496 stH265AVbr.u32MaxBitRate = PER_UNIT * 15 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 15M + 2M */
497 break;
498 }
499 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH265AVbr, sizeof(VENC_H265_AVBR_S), &stH265AVbr,
500 sizeof(VENC_H265_AVBR_S));
501 } else if (enRcMode == SAMPLE_RC_QVBR) {
502 VENC_H265_QVBR_S stH265QVbr;
503
504 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H265QVBR;
505 stH265QVbr.u32Gop = u32Gop;
506 stH265QVbr.u32StatTime = u32StatTime;
507 stH265QVbr.u32SrcFrameRate = u32FrameRate;
508 stH265QVbr.fr32DstFrameRate = u32FrameRate;
509 switch (enSize) {
510 case PIC_720P:
511 stH265QVbr.u32TargetBitRate =
512 PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
513 break;
514 case PIC_1080P:
515 stH265QVbr.u32TargetBitRate =
516 PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
517 break;
518 case PIC_2592x1944:
519 stH265QVbr.u32TargetBitRate =
520 PER_UNIT * 3 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 3M + 3M */
521 break;
522 case PIC_3840x2160:
523 stH265QVbr.u32TargetBitRate =
524 PER_UNIT * 5 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 5M + 5M */
525 break;
526 default:
527 stH265QVbr.u32TargetBitRate =
528 PER_UNIT * 15 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 15M + 2M */
529 break;
530 }
531 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH265QVbr, sizeof(VENC_H265_QVBR_S), &stH265QVbr,
532 sizeof(VENC_H265_QVBR_S));
533 } else if (enRcMode == SAMPLE_RC_CVBR) {
534 VENC_H265_CVBR_S stH265CVbr;
535
536 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H265CVBR;
537 stH265CVbr.u32Gop = u32Gop;
538 stH265CVbr.u32StatTime = u32StatTime;
539 stH265CVbr.u32SrcFrameRate = u32FrameRate;
540 stH265CVbr.fr32DstFrameRate = u32FrameRate;
541 stH265CVbr.u32LongTermStatTime = 1;
542 stH265CVbr.u32ShortTermStatTime = u32StatTime;
543 switch (enSize) {
544 case PIC_720P:
545 stH265CVbr.u32MaxBitRate = PER_UNIT * 3 + PER_UNIT * u32FrameRate / FPS_30; /* 3M + 1M */
546 stH265CVbr.u32LongTermMaxBitrate =
547 PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
548 stH265CVbr.u32LongTermMinBitrate = 512; /* 512kbps */
549 break;
550 case PIC_1080P:
551 stH265CVbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
552 stH265CVbr.u32LongTermMaxBitrate =
553 PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
554 stH265CVbr.u32LongTermMinBitrate = PER_UNIT;
555 break;
556 case PIC_2592x1944:
557 stH265CVbr.u32MaxBitRate = PER_UNIT * 4 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 4M + 3M */
558 stH265CVbr.u32LongTermMaxBitrate =
559 PER_UNIT * 3 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 3M + 3M */
560 stH265CVbr.u32LongTermMinBitrate = PER_UNIT * 2; /* 2M */
561 break;
562 case PIC_3840x2160:
563 stH265CVbr.u32MaxBitRate = PER_UNIT * 8 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 8M + 5M */
564 stH265CVbr.u32LongTermMaxBitrate =
565 PER_UNIT * 5 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 5M + 5M */
566 stH265CVbr.u32LongTermMinBitrate = PER_UNIT * 3; /* 3M */
567 break;
568 default:
569 stH265CVbr.u32MaxBitRate = PER_UNIT * 24 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 24M + 5M */
570 stH265CVbr.u32LongTermMaxBitrate =
571 PER_UNIT * 15 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 15M + 2M */
572 stH265CVbr.u32LongTermMinBitrate = PER_UNIT * 5; /* 5M */
573 break;
574 }
575 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH265CVbr, sizeof(VENC_H265_CVBR_S), &stH265CVbr,
576 sizeof(VENC_H265_CVBR_S));
577 } else if (enRcMode == SAMPLE_RC_QPMAP) {
578 VENC_H265_QPMAP_S stH265QpMap;
579
580 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H265QPMAP;
581 stH265QpMap.u32Gop = u32Gop;
582 stH265QpMap.u32StatTime = u32StatTime;
583 stH265QpMap.u32SrcFrameRate = u32FrameRate;
584 stH265QpMap.fr32DstFrameRate = u32FrameRate;
585 stH265QpMap.enQpMapMode = VENC_RC_QPMAP_MODE_MEANQP;
586 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH265QpMap, sizeof(VENC_H265_QPMAP_S), &stH265QpMap,
587 sizeof(VENC_H265_QPMAP_S));
588 } else {
589 SAMPLE_PRT("%s,%d,enRcMode(%d) not support\n", __FUNCTION__, __LINE__, enRcMode);
590 return HI_FAILURE;
591 }
592 stVencChnAttr.stVencAttr.stAttrH265e.bRcnRefShareBuf = bRcnRefShareBuf;
593 break;
594 }
595 case PT_H264: {
596 if (enRcMode == SAMPLE_RC_CBR) {
597 VENC_H264_CBR_S stH264Cbr;
598
599 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264CBR;
600 stH264Cbr.u32Gop = u32Gop; /* the interval of IFrame */
601 stH264Cbr.u32StatTime = u32StatTime; /* stream rate statics time(s) */
602 stH264Cbr.u32SrcFrameRate = u32FrameRate; /* input (vi) frame rate */
603 stH264Cbr.fr32DstFrameRate = u32FrameRate; /* target frame rate */
604 switch (enSize) {
605 case PIC_720P:
606 stH264Cbr.u32BitRate = PER_UNIT * 3 + PER_UNIT * u32FrameRate / FPS_30; /* 3M + 1M */
607 break;
608 case PIC_1080P:
609 stH264Cbr.u32BitRate = PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
610 break;
611 case PIC_2592x1944:
612 stH264Cbr.u32BitRate = PER_UNIT * 4 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 4M + 3M */
613 break;
614 case PIC_3840x2160:
615 stH264Cbr.u32BitRate = PER_UNIT * 8 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 8M + 5M */
616 break;
617 default:
618 stH264Cbr.u32BitRate = PER_UNIT * 24 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 24M + 5M */
619 break;
620 }
621
622 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH264Cbr, sizeof(VENC_H264_CBR_S), &stH264Cbr,
623 sizeof(VENC_H264_CBR_S));
624 } else if (enRcMode == SAMPLE_RC_FIXQP) {
625 VENC_H264_FIXQP_S stH264FixQp;
626
627 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264FIXQP;
628 stH264FixQp.u32Gop = u32Gop;
629 stH264FixQp.u32SrcFrameRate = u32FrameRate;
630 stH264FixQp.fr32DstFrameRate = u32FrameRate;
631 stH264FixQp.u32IQp = 25; /* set 25 */
632 stH264FixQp.u32PQp = 30; /* set 30 */
633 stH264FixQp.u32BQp = 32; /* set 32 */
634 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH264FixQp, sizeof(VENC_H264_FIXQP_S), &stH264FixQp,
635 sizeof(VENC_H264_FIXQP_S));
636 } else if (enRcMode == SAMPLE_RC_VBR) {
637 VENC_H264_VBR_S stH264Vbr;
638
639 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264VBR;
640 stH264Vbr.u32Gop = u32Gop;
641 stH264Vbr.u32StatTime = u32StatTime;
642 stH264Vbr.u32SrcFrameRate = u32FrameRate;
643 stH264Vbr.fr32DstFrameRate = u32FrameRate;
644 switch (enSize) {
645 case PIC_360P:
646 stH264Vbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
647 break;
648 case PIC_720P:
649 stH264Vbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
650 break;
651 case PIC_1080P:
652 stH264Vbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
653 break;
654 case PIC_2592x1944:
655 stH264Vbr.u32MaxBitRate = PER_UNIT * 3 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 3M + 3M */
656 break;
657 case PIC_3840x2160:
658 stH264Vbr.u32MaxBitRate = PER_UNIT * 5 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 5M + 5M */
659 break;
660 default:
661 stH264Vbr.u32MaxBitRate = PER_UNIT * 15 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 15M + 2M */
662 break;
663 }
664 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH264Vbr, sizeof(VENC_H264_VBR_S), &stH264Vbr,
665 sizeof(VENC_H264_VBR_S));
666 } else if (enRcMode == SAMPLE_RC_AVBR) {
667 VENC_H264_VBR_S stH264AVbr;
668
669 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264AVBR;
670 stH264AVbr.u32Gop = u32Gop;
671 stH264AVbr.u32StatTime = u32StatTime;
672 stH264AVbr.u32SrcFrameRate = u32FrameRate;
673 stH264AVbr.fr32DstFrameRate = u32FrameRate;
674 switch (enSize) {
675 case PIC_360P:
676 stH264AVbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
677 break;
678 case PIC_720P:
679 stH264AVbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
680 break;
681 case PIC_1080P:
682 stH264AVbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
683 break;
684 case PIC_2592x1944:
685 stH264AVbr.u32MaxBitRate = PER_UNIT * 3 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 3M + 3M */
686 break;
687 case PIC_3840x2160:
688 stH264AVbr.u32MaxBitRate = PER_UNIT * 5 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 5M + 5M */
689 break;
690 default:
691 stH264AVbr.u32MaxBitRate = PER_UNIT * 15 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 15M + 2M */
692 break;
693 }
694 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH264AVbr, sizeof(VENC_H264_AVBR_S), &stH264AVbr,
695 sizeof(VENC_H264_AVBR_S));
696 } else if (enRcMode == SAMPLE_RC_QVBR) {
697 VENC_H264_QVBR_S stH264QVbr;
698
699 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264QVBR;
700 stH264QVbr.u32Gop = u32Gop;
701 stH264QVbr.u32StatTime = u32StatTime;
702 stH264QVbr.u32SrcFrameRate = u32FrameRate;
703 stH264QVbr.fr32DstFrameRate = u32FrameRate;
704 switch (enSize) {
705 case PIC_360P:
706 stH264QVbr.u32TargetBitRate =
707 PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
708 break;
709 case PIC_720P:
710 stH264QVbr.u32TargetBitRate =
711 PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30; /* 2M + 1M */
712 break;
713 case PIC_1080P:
714 stH264QVbr.u32TargetBitRate =
715 PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
716 break;
717 case PIC_2592x1944:
718 stH264QVbr.u32TargetBitRate =
719 PER_UNIT * 3 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 3M + 3M */
720 break;
721 case PIC_3840x2160:
722 stH264QVbr.u32TargetBitRate =
723 PER_UNIT * 5 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 5M + 5M */
724 break;
725 default:
726 stH264QVbr.u32TargetBitRate =
727 PER_UNIT * 15 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 15M + 2M */
728 break;
729 }
730 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH264QVbr, sizeof(VENC_H264_QVBR_S), &stH264QVbr,
731 sizeof(VENC_H264_QVBR_S));
732 } else if (enRcMode == SAMPLE_RC_CVBR) {
733 VENC_H264_CVBR_S stH264CVbr;
734
735 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264CVBR;
736 stH264CVbr.u32Gop = u32Gop;
737 stH264CVbr.u32StatTime = u32StatTime;
738 stH264CVbr.u32SrcFrameRate = u32FrameRate;
739 stH264CVbr.fr32DstFrameRate = u32FrameRate;
740 stH264CVbr.u32LongTermStatTime = 1;
741 stH264CVbr.u32ShortTermStatTime = u32StatTime;
742 switch (enSize) {
743 case PIC_720P:
744 stH264CVbr.u32MaxBitRate = PER_UNIT * 3 + PER_UNIT * u32FrameRate / FPS_30; /* 3M + 2M */
745 stH264CVbr.u32LongTermMaxBitrate = PER_UNIT * 2 + PER_UNIT * u32FrameRate / FPS_30;
746 stH264CVbr.u32LongTermMinBitrate = 512; /* 512kbps */
747 break;
748 case PIC_1080P:
749 stH264CVbr.u32MaxBitRate = PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 2M + 2M */
750 stH264CVbr.u32LongTermMaxBitrate = PER_UNIT * 2 + PER_UNIT * 2 * u32FrameRate / FPS_30;
751 stH264CVbr.u32LongTermMinBitrate = PER_UNIT;
752 break;
753 case PIC_2592x1944:
754 stH264CVbr.u32MaxBitRate = PER_UNIT * 4 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 4M + 3M */
755 stH264CVbr.u32LongTermMaxBitrate = PER_UNIT * 3 + PER_UNIT * 3 * u32FrameRate / FPS_30;
756 stH264CVbr.u32LongTermMinBitrate = PER_UNIT * 2; /* 2M */
757 break;
758 case PIC_3840x2160:
759 stH264CVbr.u32MaxBitRate = PER_UNIT * 8 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 8M + 5M */
760 stH264CVbr.u32LongTermMaxBitrate = PER_UNIT * 5 + PER_UNIT * 5 * u32FrameRate / FPS_30;
761 stH264CVbr.u32LongTermMinBitrate = PER_UNIT * 3; /* 3M */
762 break;
763 default:
764 stH264CVbr.u32MaxBitRate = PER_UNIT * 24 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 24M + 5M */
765 stH264CVbr.u32LongTermMaxBitrate =
766 PER_UNIT * 15 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 15M + 2M */
767 stH264CVbr.u32LongTermMinBitrate = PER_UNIT * 5; /* 5M */
768 break;
769 }
770 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH264CVbr, sizeof(VENC_H264_CVBR_S), &stH264CVbr,
771 sizeof(VENC_H264_CVBR_S));
772 } else if (enRcMode == SAMPLE_RC_QPMAP) {
773 VENC_H264_QPMAP_S stH264QpMap;
774
775 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_H264QPMAP;
776 stH264QpMap.u32Gop = u32Gop;
777 stH264QpMap.u32StatTime = u32StatTime;
778 stH264QpMap.u32SrcFrameRate = u32FrameRate;
779 stH264QpMap.fr32DstFrameRate = u32FrameRate;
780 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stH264QpMap, sizeof(VENC_H264_QPMAP_S), &stH264QpMap,
781 sizeof(VENC_H264_QPMAP_S));
782 } else {
783 SAMPLE_PRT("%s,%d,enRcMode(%d) not support\n", __FUNCTION__, __LINE__, enRcMode);
784 return HI_FAILURE;
785 }
786 stVencChnAttr.stVencAttr.stAttrH264e.bRcnRefShareBuf = bRcnRefShareBuf;
787 break;
788 }
789 case PT_MJPEG: {
790 if (enRcMode == SAMPLE_RC_FIXQP) {
791 VENC_MJPEG_FIXQP_S stMjpegeFixQp;
792
793 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_MJPEGFIXQP;
794 stMjpegeFixQp.u32Qfactor = 95; /* set 95 */
795 stMjpegeFixQp.u32SrcFrameRate = u32FrameRate;
796 stMjpegeFixQp.fr32DstFrameRate = u32FrameRate;
797
798 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stMjpegFixQp, sizeof(VENC_MJPEG_FIXQP_S), &stMjpegeFixQp,
799 sizeof(VENC_MJPEG_FIXQP_S));
800 } else if (enRcMode == SAMPLE_RC_CBR) {
801 VENC_MJPEG_CBR_S stMjpegeCbr;
802
803 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_MJPEGCBR;
804 stMjpegeCbr.u32StatTime = u32StatTime;
805 stMjpegeCbr.u32SrcFrameRate = u32FrameRate;
806 stMjpegeCbr.fr32DstFrameRate = u32FrameRate;
807 switch (enSize) {
808 case PIC_360P:
809 stMjpegeCbr.u32BitRate = PER_UNIT * 3 + PER_UNIT * u32FrameRate / FPS_30; /* 3M + 1M */
810 break;
811 case PIC_720P:
812 stMjpegeCbr.u32BitRate = PER_UNIT * 5 + PER_UNIT * u32FrameRate / FPS_30; /* 5M + 1M */
813 break;
814 case PIC_1080P:
815 stMjpegeCbr.u32BitRate = PER_UNIT * 8 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 8M + 2M */
816 break;
817 case PIC_2592x1944:
818 stMjpegeCbr.u32BitRate = PER_UNIT * 20 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 20M + 3M */
819 break;
820 case PIC_3840x2160:
821 stMjpegeCbr.u32BitRate = PER_UNIT * 25 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 25M + 5M */
822 break;
823 default:
824 stMjpegeCbr.u32BitRate = PER_UNIT * 20 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 20M + 2M */
825 break;
826 }
827
828 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stMjpegCbr, sizeof(VENC_MJPEG_CBR_S), &stMjpegeCbr,
829 sizeof(VENC_MJPEG_CBR_S));
830 } else if ((enRcMode == SAMPLE_RC_VBR) || (enRcMode == SAMPLE_RC_AVBR) || (enRcMode == SAMPLE_RC_QVBR) ||
831 (enRcMode == SAMPLE_RC_CVBR)) {
832 VENC_MJPEG_VBR_S stMjpegVbr;
833
834 if (enRcMode == SAMPLE_RC_AVBR) {
835 SAMPLE_PRT("Mjpege not support AVBR, so change rcmode to VBR!\n");
836 }
837
838 stVencChnAttr.stRcAttr.enRcMode = VENC_RC_MODE_MJPEGVBR;
839 stMjpegVbr.u32StatTime = u32StatTime;
840 stMjpegVbr.u32SrcFrameRate = u32FrameRate;
841 stMjpegVbr.fr32DstFrameRate = 5; /* output 5fps */
842
843 switch (enSize) {
844 case PIC_360P:
845 stMjpegVbr.u32MaxBitRate = PER_UNIT * 3 + PER_UNIT * u32FrameRate / FPS_30; /* 3M + 1M */
846 break;
847 case PIC_720P:
848 stMjpegVbr.u32MaxBitRate = PER_UNIT * 5 + PER_UNIT * u32FrameRate / FPS_30; /* 5M + 1M */
849 break;
850 case PIC_1080P:
851 stMjpegVbr.u32MaxBitRate = PER_UNIT * 8 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 8M + 2M */
852 break;
853 case PIC_2592x1944:
854 stMjpegVbr.u32MaxBitRate = PER_UNIT * 20 + PER_UNIT * 3 * u32FrameRate / FPS_30; /* 20M + 3M */
855 break;
856 case PIC_3840x2160:
857 stMjpegVbr.u32MaxBitRate = PER_UNIT * 25 + PER_UNIT * 5 * u32FrameRate / FPS_30; /* 25M + 5M */
858 break;
859 default:
860 stMjpegVbr.u32MaxBitRate = PER_UNIT * 20 + PER_UNIT * 2 * u32FrameRate / FPS_30; /* 20M + 2M */
861 break;
862 }
863
864 (hi_void)memcpy_s(&stVencChnAttr.stRcAttr.stMjpegVbr, sizeof(VENC_MJPEG_VBR_S), &stMjpegVbr,
865 sizeof(VENC_MJPEG_VBR_S));
866 } else {
867 SAMPLE_PRT("can't support other mode(%d) in this version!\n", enRcMode);
868 return HI_FAILURE;
869 }
870 break;
871 }
872 case PT_JPEG:
873 stJpegAttr.bSupportDCF = HI_FALSE;
874 stJpegAttr.stMPFCfg.u8LargeThumbNailNum = 0;
875 stJpegAttr.enReceiveMode = VENC_PIC_RECEIVE_SINGLE;
876 (hi_void)memcpy_s(&stVencChnAttr.stVencAttr.stAttrJpege, sizeof(VENC_ATTR_JPEG_S), &stJpegAttr,
877 sizeof(VENC_ATTR_JPEG_S));
878 break;
879 default:
880 SAMPLE_PRT("can't support this enType (%d) in this version!\n", enType);
881 return HI_ERR_VENC_NOT_SUPPORT;
882 }
883
884 if (enType == PT_MJPEG || enType == PT_JPEG) {
885 stVencChnAttr.stGopAttr.enGopMode = VENC_GOPMODE_NORMALP;
886 stVencChnAttr.stGopAttr.stNormalP.s32IPQpDelta = 0;
887 } else {
888 (hi_void)memcpy_s(&stVencChnAttr.stGopAttr, sizeof(VENC_GOP_ATTR_S), pstGopAttr, sizeof(VENC_GOP_ATTR_S));
889 if ((pstGopAttr->enGopMode == VENC_GOPMODE_BIPREDB) && (enType == PT_H264)) {
890 if (stVencChnAttr.stVencAttr.u32Profile == 0) {
891 stVencChnAttr.stVencAttr.u32Profile = 1;
892 SAMPLE_PRT("H.264 base profile not support BIPREDB, so change profile to main profile!\n");
893 }
894 }
895
896 if ((stVencChnAttr.stRcAttr.enRcMode == VENC_RC_MODE_H264QPMAP) ||
897 (stVencChnAttr.stRcAttr.enRcMode == VENC_RC_MODE_H265QPMAP)) {
898 if (pstGopAttr->enGopMode == VENC_GOPMODE_ADVSMARTP) {
899 stVencChnAttr.stGopAttr.enGopMode = VENC_GOPMODE_SMARTP;
900 SAMPLE_PRT("advsmartp not support QPMAP, so change gopmode to smartp!\n");
901 }
902 }
903 }
904
905 s32Ret = HI_MPI_VENC_CreateChn(VencChn, &stVencChnAttr);
906 if (s32Ret != HI_SUCCESS) {
907 SAMPLE_PRT("HI_MPI_VENC_CreateChn [%d] failed with %#x! ===\n", VencChn, s32Ret);
908 return s32Ret;
909 }
910
911 s32Ret = SAMPLE_COMM_VENC_CloseReEncode(VencChn);
912 if (s32Ret != HI_SUCCESS) {
913 HI_MPI_VENC_DestroyChn(VencChn);
914 return s32Ret;
915 }
916
917 return HI_SUCCESS;
918 }
919
SAMPLE_COMM_VENC_Start(VENC_CHN VencChn,PAYLOAD_TYPE_E enType,PIC_SIZE_E enSize,SAMPLE_RC_E enRcMode,HI_U32 u32Profile,HI_BOOL bRcnRefShareBuf,VENC_GOP_ATTR_S * pstGopAttr)920 HI_S32 SAMPLE_COMM_VENC_Start(VENC_CHN VencChn, PAYLOAD_TYPE_E enType, PIC_SIZE_E enSize, SAMPLE_RC_E enRcMode,
921 HI_U32 u32Profile, HI_BOOL bRcnRefShareBuf, VENC_GOP_ATTR_S *pstGopAttr)
922 {
923 HI_S32 s32Ret;
924 VENC_RECV_PIC_PARAM_S stRecvParam;
925
926 s32Ret = SAMPLE_COMM_VENC_Create(VencChn, enType, enSize, enRcMode, u32Profile, bRcnRefShareBuf, pstGopAttr);
927 if (s32Ret != HI_SUCCESS) {
928 SAMPLE_PRT("SAMPLE_COMM_VENC_Create failed with%#x! \n", s32Ret);
929 return HI_FAILURE;
930 }
931
932 stRecvParam.s32RecvPicNum = -1;
933 s32Ret = HI_MPI_VENC_StartRecvFrame(VencChn, &stRecvParam);
934 if (s32Ret != HI_SUCCESS) {
935 SAMPLE_PRT("HI_MPI_VENC_StartRecvPic failed with%#x! \n", s32Ret);
936 return HI_FAILURE;
937 }
938 return HI_SUCCESS;
939 }
940
SAMPLE_COMM_VENC_Stop(VENC_CHN VencChn)941 HI_S32 SAMPLE_COMM_VENC_Stop(VENC_CHN VencChn)
942 {
943 HI_S32 s32Ret;
944
945 s32Ret = HI_MPI_VENC_StopRecvFrame(VencChn);
946 if (s32Ret != HI_SUCCESS) {
947 SAMPLE_PRT("HI_MPI_VENC_StopRecvPic vechn[%d] failed with %#x!\n", VencChn, s32Ret);
948 return HI_FAILURE;
949 }
950
951 s32Ret = HI_MPI_VENC_DestroyChn(VencChn);
952 if (s32Ret != HI_SUCCESS) {
953 SAMPLE_PRT("HI_MPI_VENC_DestroyChn vechn[%d] failed with %#x!\n", VencChn, s32Ret);
954 return HI_FAILURE;
955 }
956 return HI_SUCCESS;
957 }
958
SAMPLE_COMM_VENC_SnapStart(VENC_CHN VencChn,SIZE_S * pstSize,HI_BOOL bSupportDCF)959 HI_S32 SAMPLE_COMM_VENC_SnapStart(VENC_CHN VencChn, SIZE_S *pstSize, HI_BOOL bSupportDCF)
960 {
961 HI_S32 s32Ret;
962 VENC_CHN_ATTR_S stVencChnAttr;
963
964 if (pstSize == NULL) {
965 SAMPLE_PRT("null pointer\n");
966 return HI_FAILURE;
967 }
968 stVencChnAttr.stVencAttr.enType = PT_JPEG;
969 stVencChnAttr.stVencAttr.u32Profile = 0;
970 stVencChnAttr.stVencAttr.u32MaxPicWidth = pstSize->u32Width;
971 stVencChnAttr.stVencAttr.u32MaxPicHeight = pstSize->u32Height;
972 stVencChnAttr.stVencAttr.u32PicWidth = pstSize->u32Width;
973 stVencChnAttr.stVencAttr.u32PicHeight = pstSize->u32Height;
974 stVencChnAttr.stVencAttr.u32BufSize =
975 HI_ALIGN_UP(pstSize->u32Width, 16) * HI_ALIGN_UP(pstSize->u32Height, 16); /* 16 align */
976 stVencChnAttr.stVencAttr.bByFrame = HI_TRUE; /* get stream mode is field mode or frame mode */
977 stVencChnAttr.stVencAttr.stAttrJpege.bSupportDCF = bSupportDCF;
978 stVencChnAttr.stVencAttr.stAttrJpege.stMPFCfg.u8LargeThumbNailNum = 0;
979 stVencChnAttr.stVencAttr.stAttrJpege.enReceiveMode = VENC_PIC_RECEIVE_SINGLE;
980 s32Ret = HI_MPI_VENC_CreateChn(VencChn, &stVencChnAttr);
981 if (s32Ret != HI_SUCCESS) {
982 SAMPLE_PRT("HI_MPI_VENC_CreateChn [%d] failed with %#x!\n", VencChn, s32Ret);
983 return s32Ret;
984 }
985 return HI_SUCCESS;
986 }
987
SAMPLE_COMM_VENC_SnapStop(VENC_CHN VencChn)988 HI_S32 SAMPLE_COMM_VENC_SnapStop(VENC_CHN VencChn)
989 {
990 HI_S32 s32Ret;
991 s32Ret = HI_MPI_VENC_StopRecvFrame(VencChn);
992 if (s32Ret != HI_SUCCESS) {
993 SAMPLE_PRT("HI_MPI_VENC_StopRecvPic vechn[%d] failed with %#x!\n", VencChn, s32Ret);
994 return HI_FAILURE;
995 }
996 s32Ret = HI_MPI_VENC_DestroyChn(VencChn);
997 if (s32Ret != HI_SUCCESS) {
998 SAMPLE_PRT("HI_MPI_VENC_DestroyChn vechn[%d] failed with %#x!\n", VencChn, s32Ret);
999 return HI_FAILURE;
1000 }
1001 return HI_SUCCESS;
1002 }
1003
SAMPLE_COMM_VENC_SnapProcess(VENC_CHN VencChn,HI_U32 SnapCnt,HI_BOOL bSaveJpg,HI_BOOL bSaveThm)1004 HI_S32 SAMPLE_COMM_VENC_SnapProcess(VENC_CHN VencChn, HI_U32 SnapCnt, HI_BOOL bSaveJpg, HI_BOOL bSaveThm)
1005 {
1006 struct timeval TimeoutVal;
1007 fd_set read_fds;
1008 HI_S32 s32VencFd;
1009 HI_S32 fd = -1;
1010 VENC_CHN_STATUS_S stStat;
1011 VENC_STREAM_S stStream;
1012 HI_S32 s32Ret;
1013 VENC_RECV_PIC_PARAM_S stRecvParam;
1014 HI_U32 i;
1015 #if defined(__HuaweiLite__) && (!defined(__OHOS__))
1016 VENC_STREAM_BUF_INFO_S stStreamBufInfo;
1017 #endif
1018
1019 stRecvParam.s32RecvPicNum = SnapCnt;
1020 s32Ret = HI_MPI_VENC_StartRecvFrame(VencChn, &stRecvParam);
1021 if (s32Ret != HI_SUCCESS) {
1022 SAMPLE_PRT("HI_MPI_VENC_StartRecvPic failed with%#x!\n", s32Ret);
1023 return HI_FAILURE;
1024 }
1025
1026 s32VencFd = HI_MPI_VENC_GetFd(VencChn);
1027 if (s32VencFd < 0) {
1028 SAMPLE_PRT("HI_MPI_VENC_GetFd failed with%#x!\n", s32VencFd);
1029 return HI_FAILURE;
1030 }
1031
1032 for (i = 0; i < SnapCnt; i++) {
1033 FD_ZERO(&read_fds);
1034 FD_SET(s32VencFd, &read_fds);
1035 TimeoutVal.tv_sec = 10; /* 10 s */
1036 TimeoutVal.tv_usec = 0;
1037 s32Ret = select(s32VencFd + 1, &read_fds, NULL, NULL, &TimeoutVal);
1038 if (s32Ret < 0) {
1039 SAMPLE_PRT("snap select failed!\n");
1040 return HI_FAILURE;
1041 } else if (s32Ret == 0) {
1042 SAMPLE_PRT("snap time out!\n");
1043 return HI_FAILURE;
1044 } else {
1045 if (FD_ISSET(s32VencFd, &read_fds)) {
1046 s32Ret = HI_MPI_VENC_QueryStatus(VencChn, &stStat);
1047 if (s32Ret != HI_SUCCESS) {
1048 SAMPLE_PRT("HI_MPI_VENC_QueryStatus failed with %#x!\n", s32Ret);
1049 return HI_FAILURE;
1050 }
1051 if (stStat.u32CurPacks == 0) {
1052 SAMPLE_PRT("NOTE: Current frame is NULL!\n");
1053 return HI_SUCCESS;
1054 }
1055 stStream.pstPack = (VENC_PACK_S *)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
1056 if (stStream.pstPack == NULL) {
1057 SAMPLE_PRT("malloc memory failed!\n");
1058 return HI_FAILURE;
1059 }
1060 stStream.u32PackCount = stStat.u32CurPacks;
1061 s32Ret = HI_MPI_VENC_GetStream(VencChn, &stStream, -1);
1062 if (s32Ret != HI_SUCCESS) {
1063 SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", s32Ret);
1064
1065 free(stStream.pstPack);
1066 stStream.pstPack = NULL;
1067 return HI_FAILURE;
1068 }
1069 if (bSaveJpg || bSaveThm) {
1070 char acFile[FILE_NAME_LEN] = {0};
1071 FILE *pFile = HI_NULL;
1072
1073 if (snprintf_s(acFile, FILE_NAME_LEN, FILE_NAME_LEN - 1, "snap_%d.jpg", gs_s32SnapCnt) < 0) {
1074 free(stStream.pstPack);
1075 stStream.pstPack = NULL;
1076 return HI_FAILURE;
1077 }
1078 fd = open(acFile, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
1079 if (fd < 0) {
1080 SAMPLE_PRT("open file err\n");
1081 free(stStream.pstPack);
1082 stStream.pstPack = NULL;
1083 return HI_FAILURE;
1084 }
1085
1086 pFile = fdopen(fd, "wb");
1087 if (pFile == NULL) {
1088 SAMPLE_PRT("fdopen err\n");
1089 free(stStream.pstPack);
1090 stStream.pstPack = NULL;
1091 close(fd);
1092 return HI_FAILURE;
1093 }
1094 s32Ret = SAMPLE_COMM_VENC_SaveStream(pFile, &stStream);
1095 if (s32Ret != HI_SUCCESS) {
1096 SAMPLE_PRT("save snap picture failed!\n");
1097
1098 free(stStream.pstPack);
1099 stStream.pstPack = NULL;
1100
1101 (HI_VOID)fclose(pFile);
1102 pFile = HI_NULL;
1103 return HI_FAILURE;
1104 }
1105 if (bSaveThm) {
1106 char acFile_dcf[FILE_NAME_LEN] = {0};
1107 if (snprintf_s(acFile_dcf, FILE_NAME_LEN, FILE_NAME_LEN - 1, "snap_thm_%d.jpg", gs_s32SnapCnt) <
1108 0) {
1109 free(stStream.pstPack);
1110 stStream.pstPack = NULL;
1111
1112 (HI_VOID)fclose(pFile);
1113 pFile = HI_NULL;
1114 return HI_FAILURE;
1115 }
1116
1117 s32Ret = SAMPLE_COMM_VENC_Getdcfinfo(acFile, acFile_dcf);
1118 if (s32Ret != HI_SUCCESS) {
1119 SAMPLE_PRT("save thm picture failed!\n");
1120
1121 free(stStream.pstPack);
1122 stStream.pstPack = NULL;
1123
1124 (HI_VOID)fclose(pFile);
1125 pFile = HI_NULL;
1126 return HI_FAILURE;
1127 }
1128 }
1129 (HI_VOID)fclose(pFile);
1130 pFile = HI_NULL;
1131 gs_s32SnapCnt++;
1132 }
1133
1134 s32Ret = HI_MPI_VENC_ReleaseStream(VencChn, &stStream);
1135 if (s32Ret != HI_SUCCESS) {
1136 SAMPLE_PRT("HI_MPI_VENC_ReleaseStream failed with %#x!\n", s32Ret);
1137 free(stStream.pstPack);
1138 stStream.pstPack = NULL;
1139 return HI_FAILURE;
1140 }
1141 free(stStream.pstPack);
1142 stStream.pstPack = NULL;
1143 }
1144 }
1145 }
1146 s32Ret = HI_MPI_VENC_StopRecvFrame(VencChn);
1147 if (s32Ret != HI_SUCCESS) {
1148 SAMPLE_PRT("HI_MPI_VENC_StopRecvPic failed with %#x!\n", s32Ret);
1149 return HI_FAILURE;
1150 }
1151 return HI_SUCCESS;
1152 }
1153
SAMPLE_COMM_VENC_SaveJpeg(VENC_CHN VencChn,HI_U32 SnapCnt)1154 HI_S32 SAMPLE_COMM_VENC_SaveJpeg(VENC_CHN VencChn, HI_U32 SnapCnt)
1155 {
1156 struct timeval TimeoutVal;
1157 fd_set read_fds;
1158 HI_S32 s32VencFd;
1159 HI_S32 fd = -1;
1160 VENC_CHN_STATUS_S stStat;
1161 VENC_STREAM_S stStream;
1162 HI_S32 s32Ret;
1163 HI_U32 i;
1164
1165 #if defined(__HuaweiLite__) && (!defined(__OHOS__))
1166 VENC_STREAM_BUF_INFO_S stStreamBufInfo;
1167 #endif
1168
1169 s32VencFd = HI_MPI_VENC_GetFd(VencChn);
1170 if (s32VencFd < 0) {
1171 SAMPLE_PRT("HI_MPI_VENC_GetFd failed with%#x!\n", s32VencFd);
1172 return HI_FAILURE;
1173 }
1174
1175 for (i = 0; i < SnapCnt; i++) {
1176 FD_ZERO(&read_fds);
1177 FD_SET(s32VencFd, &read_fds);
1178 TimeoutVal.tv_sec = 10; /* 10 s */
1179 TimeoutVal.tv_usec = 0;
1180 s32Ret = select(s32VencFd + 1, &read_fds, NULL, NULL, &TimeoutVal);
1181 if (s32Ret < 0) {
1182 SAMPLE_PRT("snap select failed!\n");
1183 return HI_FAILURE;
1184 } else if (s32Ret == 0) {
1185 SAMPLE_PRT("snap time out!\n");
1186 return HI_FAILURE;
1187 } else {
1188 if (FD_ISSET(s32VencFd, &read_fds)) {
1189 s32Ret = HI_MPI_VENC_QueryStatus(VencChn, &stStat);
1190 if (s32Ret != HI_SUCCESS) {
1191 SAMPLE_PRT("HI_MPI_VENC_QueryStatus failed with %#x!\n", s32Ret);
1192 return HI_FAILURE;
1193 }
1194 if (stStat.u32CurPacks == 0) {
1195 SAMPLE_PRT("NOTE: Current frame is NULL!\n");
1196 return HI_SUCCESS;
1197 }
1198 stStream.pstPack = (VENC_PACK_S *)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
1199 if (stStream.pstPack == NULL) {
1200 SAMPLE_PRT("malloc memory failed!\n");
1201 return HI_FAILURE;
1202 }
1203 stStream.u32PackCount = stStat.u32CurPacks;
1204 s32Ret = HI_MPI_VENC_GetStream(VencChn, &stStream, -1);
1205 if (s32Ret != HI_SUCCESS) {
1206 SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", s32Ret);
1207
1208 free(stStream.pstPack);
1209 stStream.pstPack = NULL;
1210 return HI_FAILURE;
1211 }
1212 if (1) {
1213 char acFile[FILE_NAME_LEN] = {0};
1214 FILE *pFile;
1215
1216 if (snprintf_s(acFile, FILE_NAME_LEN, FILE_NAME_LEN - 1, "snap_%d.jpg", gs_s32SnapCnt) < 0) {
1217 free(stStream.pstPack);
1218 stStream.pstPack = NULL;
1219 return HI_FAILURE;
1220 }
1221
1222 fd = open(acFile, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
1223 if (fd < 0) {
1224 SAMPLE_PRT("open file err\n");
1225 free(stStream.pstPack);
1226 stStream.pstPack = NULL;
1227 return HI_FAILURE;
1228 }
1229 pFile = fdopen(fd, "wb");
1230 if (pFile == NULL) {
1231 SAMPLE_PRT("fdopen err\n");
1232 free(stStream.pstPack);
1233 stStream.pstPack = NULL;
1234 close(fd);
1235 return HI_FAILURE;
1236 }
1237 #if (!defined(__HuaweiLite__)) || defined(__OHOS__)
1238 s32Ret = SAMPLE_COMM_VENC_SaveStream(pFile, &stStream);
1239 if (s32Ret != HI_SUCCESS) {
1240 SAMPLE_PRT("save snap picture failed!\n");
1241 free(stStream.pstPack);
1242 stStream.pstPack = NULL;
1243 (HI_VOID)fclose(pFile);
1244 return HI_FAILURE;
1245 }
1246
1247 #else
1248 s32Ret = HI_MPI_VENC_GetStreamBufInfo(VencChn, &stStreamBufInfo);
1249 if (s32Ret != HI_SUCCESS) {
1250 SAMPLE_PRT("HI_MPI_VENC_GetStreamBufInfo failed with %#x!\n", s32Ret);
1251 free(stStream.pstPack);
1252 stStream.pstPack = NULL;
1253 (HI_VOID)fclose(pFile);
1254 return HI_FAILURE;
1255 }
1256
1257 s32Ret = SAMPLE_COMM_VENC_SaveStream_PhyAddr(pFile, &stStreamBufInfo, &stStream);
1258 if (s32Ret != HI_SUCCESS) {
1259 SAMPLE_PRT("save snap picture failed!\n");
1260 free(stStream.pstPack);
1261 stStream.pstPack = NULL;
1262 (HI_VOID)fclose(pFile);
1263 return HI_FAILURE;
1264 }
1265 #endif
1266
1267 (HI_VOID)fclose(pFile);
1268 gs_s32SnapCnt++;
1269 }
1270
1271 s32Ret = HI_MPI_VENC_ReleaseStream(VencChn, &stStream);
1272 if (s32Ret != HI_SUCCESS) {
1273 SAMPLE_PRT("HI_MPI_VENC_ReleaseStream failed with %#x!\n", s32Ret);
1274 free(stStream.pstPack);
1275 stStream.pstPack = NULL;
1276 return HI_FAILURE;
1277 }
1278 free(stStream.pstPack);
1279 stStream.pstPack = NULL;
1280 }
1281 }
1282 }
1283 return HI_SUCCESS;
1284 }
1285
1286 #define QpMapBufNum 8
SAMPLE_COMM_QpmapSendFrameProc(HI_VOID * p)1287 static HI_VOID *SAMPLE_COMM_QpmapSendFrameProc(HI_VOID *p)
1288 {
1289 HI_U32 i, j;
1290 HI_S32 s32Ret, VeChnCnt;
1291 VIDEO_FRAME_INFO_S *pstVideoFrame = HI_NULL;
1292 USER_FRAME_INFO_S stFrame[QpMapBufNum];
1293 SAMPLE_VENC_QPMAP_SENDFRAME_PARA_S *pstPara = HI_NULL;
1294
1295 HI_U32 u32QpMapSize;
1296 HI_U64 u64QpMapPhyAddr[QpMapBufNum];
1297 HI_VOID* pQpMapVirAddr[QpMapBufNum] = {HI_NULL};
1298 HI_U32 u32QpMapSizeHeight;
1299 HI_U32 u32QpMapSizeWidth;
1300 HI_U8 *pVirAddr = HI_NULL;
1301 HI_U64 u64PhyAddr;
1302 HI_U8 *pVirAddrTemp = HI_NULL;
1303
1304 HI_U32 u32SkipWeightHeight_H264;
1305 HI_U32 u32SkipWeightWidth_H264;
1306 HI_U32 u32SkipWeightSize_H264;
1307 HI_U64 u64SkipWeightPhyAddr_H264[QpMapBufNum];
1308 HI_VOID* pSkipWeightVirAddr_H264[QpMapBufNum] = {HI_NULL};
1309
1310 HI_U32 u32SkipWeightHeight_H265;
1311 HI_U32 u32SkipWeightWidth_H265;
1312 HI_U32 u32SkipWeightSize_H265;
1313 HI_U64 u64SkipWeightPhyAddr_H265[QpMapBufNum];
1314 HI_VOID* pSkipWeightVirAddr_H265[QpMapBufNum] = {HI_NULL};
1315
1316 VPSS_CHN_ATTR_S stVpssChnAttr;
1317
1318 pstPara = (SAMPLE_VENC_QPMAP_SENDFRAME_PARA_S *)p;
1319
1320 /* qpmap */
1321 u32QpMapSizeWidth = (pstPara->stSize.u32Width + 512 - 1) / 512 * 32; /* 512 align * 32 */
1322 u32QpMapSizeHeight = (pstPara->stSize.u32Height + 16 - 1) / 16; /* 16 align */
1323 u32QpMapSize = u32QpMapSizeWidth * u32QpMapSizeHeight;
1324 s32Ret = HI_MPI_SYS_MmzAlloc(&u64PhyAddr, (void **)&pVirAddr, NULL, HI_NULL, u32QpMapSize * QpMapBufNum);
1325 if (s32Ret != HI_SUCCESS) {
1326 SAMPLE_PRT("HI_MPI_SYS_MmzAlloc err:0x%x", s32Ret);
1327 return NULL;
1328 }
1329
1330 for (i = 0; i < QpMapBufNum; i++) {
1331 u64QpMapPhyAddr[i] = u64PhyAddr + i * u32QpMapSize;
1332 pQpMapVirAddr[i] = pVirAddr + i * u32QpMapSize;
1333 }
1334
1335 /* skipweight h.264 */
1336 u32SkipWeightWidth_H264 = (pstPara->stSize.u32Width + 512 - 1) / 512 * 16; /* 512 align * 16 */
1337 u32SkipWeightHeight_H264 = (pstPara->stSize.u32Height + 16 - 1) / 16; /* 16 align */
1338 u32SkipWeightSize_H264 = u32SkipWeightWidth_H264 * u32SkipWeightHeight_H264;
1339 s32Ret = HI_MPI_SYS_MmzAlloc(&u64PhyAddr, (void **)&pVirAddr, NULL, HI_NULL, u32SkipWeightSize_H264 * QpMapBufNum);
1340 if (s32Ret != HI_SUCCESS) {
1341 SAMPLE_PRT("HI_MPI_SYS_MmzAlloc err:0x%x", s32Ret);
1342 HI_MPI_SYS_MmzFree(u64QpMapPhyAddr[0], pQpMapVirAddr[0]);
1343 return NULL;
1344 }
1345
1346 for (i = 0; i < QpMapBufNum; i++) {
1347 u64SkipWeightPhyAddr_H264[i] = u64PhyAddr + i * u32SkipWeightSize_H264;
1348 pSkipWeightVirAddr_H264[i] = pVirAddr + i * u32SkipWeightSize_H264;
1349 }
1350
1351 /* skipweight h.265 */
1352 u32SkipWeightWidth_H265 = (pstPara->stSize.u32Width + 2048 - 1) / 2048 * 16; /* 2048 align * 16 */
1353 u32SkipWeightHeight_H265 = (pstPara->stSize.u32Height + 64 - 1) / 64; /* 64 align */
1354 u32SkipWeightSize_H265 = u32SkipWeightWidth_H265 * u32SkipWeightHeight_H265;
1355 s32Ret = HI_MPI_SYS_MmzAlloc(&u64PhyAddr, (void **)&pVirAddr, NULL, HI_NULL, u32SkipWeightSize_H265 * QpMapBufNum);
1356 if (s32Ret != HI_SUCCESS) {
1357 SAMPLE_PRT("HI_MPI_SYS_MmzAlloc err:0x%x", s32Ret);
1358 HI_MPI_SYS_MmzFree(u64QpMapPhyAddr[0], pQpMapVirAddr[0]);
1359 HI_MPI_SYS_MmzFree(u64SkipWeightPhyAddr_H264[0], pSkipWeightVirAddr_H264[0]);
1360 return NULL;
1361 }
1362 for (i = 0; i < QpMapBufNum; i++) {
1363 u64SkipWeightPhyAddr_H265[i] = u64PhyAddr + i * u32SkipWeightSize_H265;
1364 pSkipWeightVirAddr_H265[i] = pVirAddr + i * u32SkipWeightSize_H265;
1365 }
1366
1367 s32Ret = HI_MPI_VPSS_GetChnAttr(pstPara->VpssGrp, pstPara->VpssChn, &stVpssChnAttr);
1368 if (s32Ret != HI_SUCCESS) {
1369 SAMPLE_PRT("HI_MPI_VPSS_GetChnAttr err:0x%x", s32Ret);
1370
1371 return NULL;
1372 }
1373
1374 stVpssChnAttr.u32Depth = 3; /* set depth 3 */
1375 s32Ret = HI_MPI_VPSS_SetChnAttr(pstPara->VpssGrp, pstPara->VpssChn, &stVpssChnAttr);
1376 if (s32Ret != HI_SUCCESS) {
1377 SAMPLE_PRT("HI_MPI_VPSS_SetChnAttr err:0x%x", s32Ret);
1378
1379 return NULL;
1380 }
1381
1382 i = 0;
1383 while (HI_TRUE == pstPara->bThreadStart) {
1384 pstVideoFrame = &stFrame[i].stUserFrame;
1385 s32Ret = HI_MPI_VPSS_GetChnFrame(pstPara->VpssGrp, pstPara->VpssChn, pstVideoFrame, 1000); /* 1000us timeout */
1386 if (s32Ret != HI_SUCCESS) {
1387 SAMPLE_PRT("HI_MPI_VPSS_GetChnFrame err:0x%x\n", s32Ret);
1388 continue;
1389 }
1390
1391 pVirAddrTemp = (HI_U8 *)pQpMapVirAddr[i];
1392 for (j = 0; j < u32QpMapSize; j++) {
1393 *pVirAddrTemp = 0x5E;
1394 pVirAddrTemp++;
1395 }
1396
1397 pVirAddrTemp = (HI_U8 *)pSkipWeightVirAddr_H264[i];
1398 for (j = 0; j < u32SkipWeightSize_H264; j++) {
1399 *pVirAddrTemp = 0x88;
1400 pVirAddrTemp++;
1401 }
1402
1403 pVirAddrTemp = (HI_U8 *)pSkipWeightVirAddr_H265[i];
1404 for (j = 0; j < u32SkipWeightSize_H265; j++) {
1405 *pVirAddrTemp = 0x88;
1406 pVirAddrTemp++;
1407 }
1408
1409 for (VeChnCnt = 0; VeChnCnt < pstPara->s32Cnt; VeChnCnt++) {
1410 VENC_CHN_ATTR_S stChnAttr;
1411 HI_MPI_VENC_GetChnAttr(pstPara->VeChn[VeChnCnt], &stChnAttr);
1412 if (PT_H264 == stChnAttr.stVencAttr.enType) {
1413 stFrame[i].stUserRcInfo.bSkipWeightValid = 1;
1414 stFrame[i].stUserRcInfo.u64SkipWeightPhyAddr = u64SkipWeightPhyAddr_H264[i];
1415 } else if (PT_H265 == stChnAttr.stVencAttr.enType) {
1416 stFrame[i].stUserRcInfo.bSkipWeightValid = 1;
1417 stFrame[i].stUserRcInfo.u64SkipWeightPhyAddr = u64SkipWeightPhyAddr_H265[i];
1418 } else {
1419 continue;
1420 }
1421
1422 stFrame[i].stUserRcInfo.bQpMapValid = 1;
1423 stFrame[i].stUserRcInfo.u64QpMapPhyAddr = u64QpMapPhyAddr[i];
1424 stFrame[i].stUserRcInfo.u32BlkStartQp = FPS_30;
1425 stFrame[i].stUserRcInfo.enFrameType = VENC_FRAME_TYPE_NONE;
1426
1427 s32Ret = HI_MPI_VENC_SendFrameEx(pstPara->VeChn[VeChnCnt], &stFrame[i], -1);
1428 if (s32Ret != HI_SUCCESS) {
1429 SAMPLE_PRT("HI_MPI_VENC_SendFrame err:0x%x\n", s32Ret);
1430 break;
1431 }
1432 }
1433 if (s32Ret != HI_SUCCESS) {
1434 s32Ret = HI_MPI_VPSS_ReleaseChnFrame(pstPara->VpssGrp, pstPara->VpssChn, pstVideoFrame);
1435 if (s32Ret != HI_SUCCESS) {
1436 SAMPLE_PRT("HI_MPI_VPSS_ReleaseChnFrame err:0x%x", s32Ret);
1437 goto err_out;
1438 }
1439 continue;
1440 }
1441
1442 s32Ret = HI_MPI_VPSS_ReleaseChnFrame(pstPara->VpssGrp, pstPara->VpssChn, pstVideoFrame);
1443 if (s32Ret != HI_SUCCESS) {
1444 SAMPLE_PRT("HI_MPI_VPSS_ReleaseChnFrame err:0x%x", s32Ret);
1445 goto err_out;
1446 }
1447
1448 i++;
1449 if (i >= QpMapBufNum) {
1450 i = 0;
1451 }
1452 }
1453 err_out:
1454 s32Ret = HI_MPI_SYS_MmzFree(u64QpMapPhyAddr[0], pQpMapVirAddr[0]);
1455 if (s32Ret != HI_SUCCESS) {
1456 SAMPLE_PRT("HI_MPI_SYS_MmzFree err:0x%x", s32Ret);
1457 return NULL;
1458 }
1459
1460 s32Ret = HI_MPI_SYS_MmzFree(u64SkipWeightPhyAddr_H264[0], pSkipWeightVirAddr_H264[0]);
1461 if (s32Ret != HI_SUCCESS) {
1462 SAMPLE_PRT("HI_MPI_SYS_MmzFree err:0x%x", s32Ret);
1463 return NULL;
1464 }
1465
1466 s32Ret = HI_MPI_SYS_MmzFree(u64SkipWeightPhyAddr_H265[0], pSkipWeightVirAddr_H265[0]);
1467 if (s32Ret != HI_SUCCESS) {
1468 SAMPLE_PRT("HI_MPI_SYS_MmzFree err:0x%x", s32Ret);
1469 return NULL;
1470 }
1471
1472 return NULL;
1473 }
SAMPLE_COMM_VENC_QpmapSendFrame(VPSS_GRP VpssGrp,VPSS_CHN VpssChn,VENC_CHN VeChn[],HI_S32 s32Cnt,SIZE_S stSize)1474 HI_S32 SAMPLE_COMM_VENC_QpmapSendFrame(VPSS_GRP VpssGrp, VPSS_CHN VpssChn, VENC_CHN VeChn[], HI_S32 s32Cnt,
1475 SIZE_S stSize)
1476 {
1477 HI_S32 i;
1478
1479 CHECK_NULL_PTR(VeChn);
1480 stQpMapSendFramePara.bThreadStart = HI_TRUE;
1481 stQpMapSendFramePara.VpssGrp = VpssGrp;
1482 stQpMapSendFramePara.VpssChn = VpssChn;
1483 stQpMapSendFramePara.s32Cnt = s32Cnt;
1484 stQpMapSendFramePara.stSize = stSize;
1485 for (i = 0; i < s32Cnt; i++) {
1486 stQpMapSendFramePara.VeChn[i] = VeChn[i];
1487 }
1488
1489 return pthread_create(&gs_VencQpmapPid, 0, SAMPLE_COMM_QpmapSendFrameProc, (HI_VOID *)&stQpMapSendFramePara);
1490 }
1491
SAMPLE_COMM_VENC_GetVencStreamProc(HI_VOID * p)1492 static HI_VOID *SAMPLE_COMM_VENC_GetVencStreamProc(HI_VOID *p)
1493 {
1494 HI_S32 i;
1495 HI_S32 s32ChnTotal;
1496 VENC_CHN_ATTR_S stVencChnAttr;
1497 SAMPLE_VENC_GETSTREAM_PARA_S *pstPara = HI_NULL;
1498 HI_S32 maxfd = 0;
1499 struct timeval TimeoutVal;
1500 fd_set read_fds;
1501 HI_U32 u32PictureCnt[VENC_MAX_CHN_NUM] = {0};
1502 HI_S32 VencFd[VENC_MAX_CHN_NUM];
1503 HI_CHAR aszFileName[VENC_MAX_CHN_NUM][FILE_NAME_LEN];
1504 HI_CHAR real_file_name[VENC_MAX_CHN_NUM][PATH_MAX];
1505 FILE* pFile[VENC_MAX_CHN_NUM] = {HI_NULL};
1506 HI_S32 fd[VENC_MAX_CHN_NUM] = {0};
1507 char szFilePostfix[10]; /* length set 10 */
1508 VENC_CHN_STATUS_S stStat;
1509 VENC_STREAM_S stStream;
1510 HI_S32 s32Ret;
1511 VENC_CHN VencChn;
1512 PAYLOAD_TYPE_E enPayLoadType[VENC_MAX_CHN_NUM];
1513 VENC_STREAM_BUF_INFO_S stStreamBufInfo[VENC_MAX_CHN_NUM];
1514
1515 prctl(PR_SET_NAME, "GetVencStream", 0, 0, 0);
1516
1517 pstPara = (SAMPLE_VENC_GETSTREAM_PARA_S *)p;
1518 s32ChnTotal = pstPara->s32Cnt;
1519 if (s32ChnTotal >= VENC_MAX_CHN_NUM) {
1520 SAMPLE_PRT("input count invalid\n");
1521 return NULL;
1522 }
1523 for (i = 0; i < s32ChnTotal; i++) {
1524 /* decide the stream file name, and open file to save stream */
1525 VencChn = pstPara->VeChn[i];
1526 s32Ret = HI_MPI_VENC_GetChnAttr(VencChn, &stVencChnAttr);
1527 if (s32Ret != HI_SUCCESS) {
1528 SAMPLE_PRT("HI_MPI_VENC_GetChnAttr chn[%d] failed with %#x!\n", VencChn, s32Ret);
1529 return NULL;
1530 }
1531 enPayLoadType[i] = stVencChnAttr.stVencAttr.enType;
1532
1533 s32Ret = SAMPLE_COMM_VENC_GetFilePostfix(enPayLoadType[i], szFilePostfix, sizeof(szFilePostfix));
1534 if (s32Ret != HI_SUCCESS) {
1535 SAMPLE_PRT("SAMPLE_COMM_VENC_GetFilePostfix [%d] failed with %#x!\n", stVencChnAttr.stVencAttr.enType,
1536 s32Ret);
1537 return NULL;
1538 }
1539 if (PT_JPEG != enPayLoadType[i]) {
1540 #ifndef OHOS_CONFIG_WITHOUT_SAVE_STREAM
1541 if (snprintf_s(aszFileName[i], FILE_NAME_LEN, FILE_NAME_LEN - 1, "./") < 0) {
1542 return NULL;
1543 }
1544 if (realpath(aszFileName[i], real_file_name[i]) == NULL) {
1545 SAMPLE_PRT("chn %d stream path error\n", VencChn);
1546 }
1547
1548 if (snprintf_s(real_file_name[i], FILE_NAME_LEN, FILE_NAME_LEN - 1, "stream_chn%d%s", i, szFilePostfix) <
1549 0) {
1550 return NULL;
1551 }
1552
1553 fd[i] = open(real_file_name[i], O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
1554 if (fd[i] < 0) {
1555 SAMPLE_PRT("open file[%s] failed!\n", real_file_name[i]);
1556 return NULL;
1557 }
1558
1559 pFile[i] = fdopen(fd[i], "wb");
1560 if (pFile[i] == HI_NULL) {
1561 SAMPLE_PRT("fdopen error!\n");
1562 close(fd[i]);
1563 return NULL;
1564 }
1565 #endif
1566 }
1567 VencFd[i] = HI_MPI_VENC_GetFd(VencChn);
1568 if (VencFd[i] < 0) {
1569 SAMPLE_PRT("HI_MPI_VENC_GetFd failed with %#x!\n", VencFd[i]);
1570 return NULL;
1571 }
1572 if (maxfd <= VencFd[i]) {
1573 maxfd = VencFd[i];
1574 }
1575
1576 s32Ret = HI_MPI_VENC_GetStreamBufInfo(VencChn, &stStreamBufInfo[i]);
1577 if (s32Ret != HI_SUCCESS) {
1578 SAMPLE_PRT("HI_MPI_VENC_GetStreamBufInfo failed with %#x!\n", s32Ret);
1579 return (void *)HI_FAILURE;
1580 }
1581 }
1582
1583 while (HI_TRUE == pstPara->bThreadStart) {
1584 #ifndef CONFIG_USER_SPACE
1585 FD_ZERO(&read_fds);
1586 for (i = 0; i < s32ChnTotal; i++) {
1587 FD_SET(VencFd[i], &read_fds);
1588 }
1589
1590 TimeoutVal.tv_sec = 2; /* 2 s */
1591 TimeoutVal.tv_usec = 0;
1592 s32Ret = select(maxfd + 1, &read_fds, NULL, NULL, &TimeoutVal);
1593 if (s32Ret < 0) {
1594 SAMPLE_PRT("select failed!\n");
1595 break;
1596 } else if (s32Ret == 0) {
1597 SAMPLE_PRT("get venc stream time out, exit thread\n");
1598 continue;
1599 } else {
1600 for (i = 0; i < s32ChnTotal; i++) {
1601 if (FD_ISSET(VencFd[i], &read_fds)) {
1602 #else
1603 for (i = 0; i < s32ChnTotal; i++) {
1604 #endif
1605 (HI_VOID)memset_s(&stStream, sizeof(stStream), 0, sizeof(stStream));
1606
1607 VencChn = pstPara->VeChn[i];
1608
1609 s32Ret = HI_MPI_VENC_QueryStatus(VencChn, &stStat);
1610 if (s32Ret != HI_SUCCESS) {
1611 SAMPLE_PRT("HI_MPI_VENC_QueryStatus chn[%d] failed with %#x!\n", VencChn, s32Ret);
1612 break;
1613 }
1614 if (stStat.u32CurPacks == 0) {
1615 #ifdef CONFIG_USER_SPACE
1616 usleep(10 * 1000);
1617 #endif
1618 continue;
1619 }
1620 stStream.pstPack = (VENC_PACK_S *)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
1621 if (stStream.pstPack == NULL) {
1622 SAMPLE_PRT("malloc stream pack failed!\n");
1623 break;
1624 }
1625
1626 stStream.u32PackCount = stStat.u32CurPacks;
1627 s32Ret = HI_MPI_VENC_GetStream(VencChn, &stStream, HI_TRUE);
1628 if (s32Ret != HI_SUCCESS) {
1629 free(stStream.pstPack);
1630 stStream.pstPack = NULL;
1631 SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", s32Ret);
1632 break;
1633 }
1634 #ifdef OHOS_CONFIG_WITHOUT_SAVE_STREAM
1635 static int once = 0;
1636 if (once == 0) {
1637 printf("get first frame pts:%llu!\n", stStream.pstPack[0].u64PTS);
1638 once = 1;
1639 }
1640 #endif
1641 if (PT_JPEG == enPayLoadType[i]) {
1642 if (strcpy_s(szFilePostfix, sizeof(szFilePostfix), ".jpg") != EOK) {
1643 free(stStream.pstPack);
1644 stStream.pstPack = NULL;
1645 return HI_NULL;
1646 }
1647 if (snprintf_s(aszFileName[i], FILE_NAME_LEN, FILE_NAME_LEN - 1, "./") < 0) {
1648 free(stStream.pstPack);
1649 stStream.pstPack = NULL;
1650 return NULL;
1651 }
1652 if (realpath(aszFileName[i], real_file_name[i]) == NULL) {
1653 SAMPLE_PRT("chn %d stream path error\n", VencChn);
1654 free(stStream.pstPack);
1655 stStream.pstPack = NULL;
1656 return NULL;
1657 }
1658
1659 if (snprintf_s(real_file_name[i], FILE_NAME_LEN, FILE_NAME_LEN - 1, "stream_chn%d_%d%s",
1660 VencChn, u32PictureCnt[i], szFilePostfix) < 0) {
1661 free(stStream.pstPack);
1662 stStream.pstPack = NULL;
1663 return NULL;
1664 }
1665
1666 fd[i] = open(real_file_name[i], O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
1667 if (fd[i] < 0) {
1668 SAMPLE_PRT("open file[%s] failed!\n", real_file_name[i]);
1669 free(stStream.pstPack);
1670 stStream.pstPack = NULL;
1671 return NULL;
1672 }
1673
1674 pFile[i] = fdopen(fd[i], "wb");
1675 if (!pFile[i]) {
1676 free(stStream.pstPack);
1677 stStream.pstPack = NULL;
1678 SAMPLE_PRT("fdopen err!\n");
1679 close(fd[i]);
1680 return NULL;
1681 }
1682 }
1683 #ifndef OHOS_CONFIG_WITHOUT_SAVE_STREAM
1684 #if (!defined(__HuaweiLite__)) || defined(__OHOS__)
1685 s32Ret = SAMPLE_COMM_VENC_SaveStream(pFile[i], &stStream);
1686 #else
1687 s32Ret = SAMPLE_COMM_VENC_SaveStream_PhyAddr(pFile[i], &stStreamBufInfo[i], &stStream);
1688 #endif
1689 if (s32Ret != HI_SUCCESS) {
1690 free(stStream.pstPack);
1691 stStream.pstPack = NULL;
1692 SAMPLE_PRT("save stream failed!\n");
1693 break;
1694 }
1695 #endif
1696 s32Ret = HI_MPI_VENC_ReleaseStream(VencChn, &stStream);
1697 if (s32Ret != HI_SUCCESS) {
1698 SAMPLE_PRT("HI_MPI_VENC_ReleaseStream failed!\n");
1699 free(stStream.pstPack);
1700 stStream.pstPack = NULL;
1701 break;
1702 }
1703
1704 free(stStream.pstPack);
1705 stStream.pstPack = NULL;
1706 u32PictureCnt[i]++;
1707 if (PT_JPEG == enPayLoadType[i]) {
1708 (HI_VOID)fclose(pFile[i]);
1709 }
1710 }
1711 #ifndef CONFIG_USER_SPACE
1712 }
1713 }
1714 #endif
1715 }
1716
1717 #ifndef OHOS_CONFIG_WITHOUT_SAVE_STREAM
1718 for (i = 0; i < s32ChnTotal; i++) {
1719 if (PT_JPEG != enPayLoadType[i]) {
1720 (HI_VOID)fclose(pFile[i]);
1721 }
1722 }
1723 #endif
1724 return NULL;
1725 }
1726
1727 static HI_VOID *SAMPLE_COMM_VENC_GetVencStreamProc_Svc_t(void *p)
1728 {
1729 HI_S32 i = 0;
1730 HI_S32 s32Cnt = 0;
1731 HI_S32 s32ChnTotal;
1732 VENC_CHN_ATTR_S stVencChnAttr;
1733 SAMPLE_VENC_GETSTREAM_PARA_S *pstPara = HI_NULL;
1734 HI_S32 maxfd = 0;
1735 struct timeval TimeoutVal;
1736 fd_set read_fds;
1737 HI_S32 VencFd[VENC_MAX_CHN_NUM];
1738 HI_S32 fd[VENC_MAX_CHN_NUM] = {0};
1739 HI_CHAR aszFileName[VENC_MAX_CHN_NUM][FILE_NAME_LEN];
1740 HI_CHAR real_file_name[VENC_MAX_CHN_NUM][FILE_NAME_LEN];
1741 FILE* pFile[VENC_MAX_CHN_NUM] = {HI_NULL};
1742 char szFilePostfix[10];
1743 VENC_CHN_STATUS_S stStat;
1744 VENC_STREAM_S stStream;
1745 HI_S32 s32Ret;
1746 VENC_CHN VencChn;
1747 PAYLOAD_TYPE_E enPayLoadType[VENC_MAX_CHN_NUM];
1748 VENC_STREAM_BUF_INFO_S stStreamBufInfo[VENC_MAX_CHN_NUM];
1749
1750 pstPara = (SAMPLE_VENC_GETSTREAM_PARA_S *)p;
1751 s32ChnTotal = pstPara->s32Cnt;
1752
1753 if (s32ChnTotal >= VENC_MAX_CHN_NUM) {
1754 SAMPLE_PRT("input count invalid\n");
1755 return NULL;
1756 }
1757 for (i = 0; i < s32ChnTotal; i++) {
1758 /* decide the stream file name, and open file to save stream */
1759 VencChn = i;
1760 s32Ret = HI_MPI_VENC_GetChnAttr(VencChn, &stVencChnAttr);
1761 if (s32Ret != HI_SUCCESS) {
1762 SAMPLE_PRT("HI_MPI_VENC_GetChnAttr chn[%d] failed with %#x!\n", VencChn, s32Ret);
1763 return NULL;
1764 }
1765 enPayLoadType[i] = stVencChnAttr.stVencAttr.enType;
1766
1767 s32Ret = SAMPLE_COMM_VENC_GetFilePostfix(enPayLoadType[i], szFilePostfix, sizeof(szFilePostfix));
1768 if (s32Ret != HI_SUCCESS) {
1769 SAMPLE_PRT("SAMPLE_COMM_VENC_GetFilePostfix [%d] failed with %#x!\n", stVencChnAttr.stVencAttr.enType,
1770 s32Ret);
1771 return NULL;
1772 }
1773
1774 for (s32Cnt = 0; s32Cnt < 3; s32Cnt++) { /* 3 file */
1775 if (snprintf_s(aszFileName[i + s32Cnt], FILE_NAME_LEN, FILE_NAME_LEN - 1, "./") < 0) {
1776 return HI_NULL;
1777 }
1778 if (realpath(aszFileName[i + s32Cnt], real_file_name[i + s32Cnt]) == HI_NULL) {
1779 printf("file path error\n");
1780 return HI_NULL;
1781 }
1782 if (snprintf_s(real_file_name[i + s32Cnt], FILE_NAME_LEN, FILE_NAME_LEN - 1, "Tid%d%s", i + s32Cnt,
1783 szFilePostfix) < 0) {
1784 return HI_NULL;
1785 }
1786
1787 fd[i + s32Cnt] = open(real_file_name[i + s32Cnt], O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
1788 if (fd[i] < 0) {
1789 SAMPLE_PRT("open file[%s] failed!\n", real_file_name[i + s32Cnt]);
1790 return NULL;
1791 }
1792 pFile[i + s32Cnt] = fdopen(fd[i + s32Cnt], "wb");
1793
1794 if (!pFile[i + s32Cnt]) {
1795 SAMPLE_PRT("fdopen error!\n");
1796 close(fd[i + s32Cnt]);
1797 return NULL;
1798 }
1799 }
1800
1801 /* Set Venc Fd. */
1802 VencFd[i] = HI_MPI_VENC_GetFd(i);
1803 if (VencFd[i] < 0) {
1804 SAMPLE_PRT("HI_MPI_VENC_GetFd failed with %#x!\n", VencFd[i]);
1805 return NULL;
1806 }
1807 if (maxfd <= VencFd[i]) {
1808 maxfd = VencFd[i];
1809 }
1810 s32Ret = HI_MPI_VENC_GetStreamBufInfo(i, &stStreamBufInfo[i]);
1811 if (s32Ret != HI_SUCCESS) {
1812 SAMPLE_PRT("HI_MPI_VENC_GetStreamBufInfo failed with %#x!\n", s32Ret);
1813 return NULL;
1814 }
1815 }
1816
1817 while (HI_TRUE == pstPara->bThreadStart) {
1818 FD_ZERO(&read_fds);
1819 for (i = 0; i < s32ChnTotal; i++) {
1820 FD_SET(VencFd[i], &read_fds);
1821 }
1822 TimeoutVal.tv_sec = 2; /* 2 s */
1823 TimeoutVal.tv_usec = 0;
1824 s32Ret = select(maxfd + 1, &read_fds, NULL, NULL, &TimeoutVal);
1825 if (s32Ret < 0) {
1826 SAMPLE_PRT("select failed!\n");
1827 break;
1828 } else if (s32Ret == 0) {
1829 SAMPLE_PRT("get venc stream time out, exit thread\n");
1830 continue;
1831 } else {
1832 for (i = 0; i < s32ChnTotal; i++) {
1833 if (FD_ISSET(VencFd[i], &read_fds)) {
1834 (HI_VOID)memset_s(&stStream, sizeof(stStream), 0, sizeof(stStream));
1835 s32Ret = HI_MPI_VENC_QueryStatus(i, &stStat);
1836 if (s32Ret != HI_SUCCESS) {
1837 SAMPLE_PRT("HI_MPI_VENC_Query chn[%d] failed with %#x!\n", i, s32Ret);
1838 break;
1839 }
1840
1841 if (stStat.u32CurPacks == 0) {
1842 SAMPLE_PRT("NOTE: Current frame is NULL!\n");
1843 continue;
1844 }
1845
1846 stStream.pstPack = (VENC_PACK_S *)malloc(sizeof(VENC_PACK_S) * stStat.u32CurPacks);
1847 if (stStream.pstPack == NULL) {
1848 SAMPLE_PRT("malloc stream pack failed!\n");
1849 break;
1850 }
1851
1852 stStream.u32PackCount = stStat.u32CurPacks;
1853 s32Ret = HI_MPI_VENC_GetStream(i, &stStream, HI_TRUE);
1854 if (s32Ret != HI_SUCCESS) {
1855 free(stStream.pstPack);
1856 stStream.pstPack = NULL;
1857 SAMPLE_PRT("HI_MPI_VENC_GetStream failed with %#x!\n", s32Ret);
1858 break;
1859 }
1860
1861 for (s32Cnt = 0; s32Cnt < 3; s32Cnt++) { /* loop 3 file */
1862 switch (s32Cnt) {
1863 case 0: /* 0: save BASE_PSLICE_REFBYBASE frame */
1864 if (BASE_IDRSLICE == stStream.stH264Info.enRefType ||
1865 BASE_PSLICE_REFBYBASE == stStream.stH264Info.enRefType) {
1866 #if (!defined(__HuaweiLite__)) || defined(__OHOS__)
1867 s32Ret = SAMPLE_COMM_VENC_SaveStream(pFile[i + s32Cnt], &stStream);
1868 #else
1869 s32Ret = SAMPLE_COMM_VENC_SaveStream_PhyAddr(pFile[i + s32Cnt], &stStreamBufInfo[i],
1870 &stStream);
1871 #endif
1872 }
1873 break;
1874 case 1: /* 1: save BASE_PSLICE_REFBYBASE and BASE_PSLICE_REFBYENHANCE frame */
1875 if (BASE_IDRSLICE == stStream.stH264Info.enRefType ||
1876 BASE_PSLICE_REFBYBASE == stStream.stH264Info.enRefType ||
1877 BASE_PSLICE_REFBYENHANCE == stStream.stH264Info.enRefType) {
1878 #if (!defined(__HuaweiLite__)) || defined(__OHOS__)
1879 s32Ret = SAMPLE_COMM_VENC_SaveStream(pFile[i + s32Cnt], &stStream);
1880 #else
1881 s32Ret = SAMPLE_COMM_VENC_SaveStream_PhyAddr(pFile[i + s32Cnt], &stStreamBufInfo[i],
1882 &stStream);
1883 #endif
1884 }
1885 break;
1886 case 2: /* 2: save all frame */
1887 #if (!defined(__HuaweiLite__)) || defined(__OHOS__)
1888 s32Ret = SAMPLE_COMM_VENC_SaveStream(pFile[i + s32Cnt], &stStream);
1889 #else
1890 s32Ret = SAMPLE_COMM_VENC_SaveStream_PhyAddr(pFile[i + s32Cnt], &stStreamBufInfo[i],
1891 &stStream);
1892 #endif
1893 break;
1894 }
1895 if (s32Ret != HI_SUCCESS) {
1896 free(stStream.pstPack);
1897 stStream.pstPack = NULL;
1898 SAMPLE_PRT("save stream failed!\n");
1899 break;
1900 }
1901 }
1902
1903 s32Ret = HI_MPI_VENC_ReleaseStream(i, &stStream);
1904 if (s32Ret != HI_SUCCESS) {
1905 free(stStream.pstPack);
1906 stStream.pstPack = NULL;
1907 break;
1908 }
1909
1910 free(stStream.pstPack);
1911 stStream.pstPack = NULL;
1912 }
1913 }
1914 }
1915 }
1916
1917 for (i = 0; i < s32ChnTotal; i++) {
1918 for (s32Cnt = 0; s32Cnt < 3; s32Cnt++) { /* loop 3 file */
1919 if (pFile[i + s32Cnt]) {
1920 (HI_VOID)fclose(pFile[i + s32Cnt]);
1921 }
1922 }
1923 }
1924 return NULL;
1925 }
1926
1927 HI_S32 SAMPLE_COMM_VENC_StartGetStream(VENC_CHN VeChn[], HI_S32 s32Cnt)
1928 {
1929 HI_S32 i;
1930
1931 if (VeChn == NULL) {
1932 SAMPLE_PRT("null pointer\n");
1933 return HI_FAILURE;
1934 }
1935 gs_stPara.bThreadStart = HI_TRUE;
1936 gs_stPara.s32Cnt = s32Cnt;
1937 for (i = 0; i < s32Cnt && i < VENC_MAX_CHN_NUM; i++) {
1938 gs_stPara.VeChn[i] = VeChn[i];
1939 }
1940 return pthread_create(&gs_VencPid, 0, SAMPLE_COMM_VENC_GetVencStreamProc, (HI_VOID *)&gs_stPara);
1941 }
1942
1943 HI_S32 SAMPLE_COMM_VENC_StartGetStream_Svc_t(HI_S32 s32Cnt)
1944 {
1945 gs_stPara.bThreadStart = HI_TRUE;
1946 gs_stPara.s32Cnt = s32Cnt;
1947 return pthread_create(&gs_VencPid, 0, SAMPLE_COMM_VENC_GetVencStreamProc_Svc_t, (HI_VOID *)&gs_stPara);
1948 }
1949
1950 HI_S32 SAMPLE_COMM_VENC_StopGetStream(void)
1951 {
1952 if (HI_TRUE == gs_stPara.bThreadStart) {
1953 gs_stPara.bThreadStart = HI_FALSE;
1954 pthread_join(gs_VencPid, 0);
1955 }
1956 return HI_SUCCESS;
1957 }
1958
1959 HI_S32 SAMPLE_COMM_VENC_StopSendQpmapFrame(void)
1960 {
1961 if (HI_TRUE == stQpMapSendFramePara.bThreadStart) {
1962 stQpMapSendFramePara.bThreadStart = HI_FALSE;
1963 pthread_join(gs_VencQpmapPid, 0);
1964 }
1965 return HI_SUCCESS;
1966 }
1967
1968 #ifdef __cplusplus
1969 #if __cplusplus
1970 }
1971 #endif
1972 #endif /* End of #ifdef __cplusplus */
1973