1 /*
2 * Copyright (c) 2022 HiSilicon (Shanghai) Technologies CO., LIMITED.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "sample_comm.h"
17 #include "sample_comm_ive.h"
18 #include "sample_store.h"
19
20 #ifdef __cplusplus
21 #if __cplusplus
22 extern "C" {
23 #endif
24 #endif /* End of #ifdef __cplusplus */
25
26 #define PIC_WIDTH 720
27 #define PIC_HEIGHT 576
28
29 SampleStoreInfo g_sampleStoreInfo = {0};
30 static VPSS_CHN VpssChn[2] = {0, 1};
31 static PIC_SIZE_E enSize[2] = {PIC_D1_MIPI, PIC_D1_MIPI};
32 static VENC_CHN VencChn[2] = {0, 1};
33 static PAYLOAD_TYPE_E enPayLoad[2] = {PT_H265, PT_H264};
34 static HI_U32 u32Profile[2] = {0, 0};
35 static HI_BOOL bRcnRefShareBuf = HI_TRUE;
36 static HI_BOOL abChnEnable[VPSS_MAX_PHY_CHN_NUM] = {1, 1, 0};
37 static HI_U32 u32SupplementConfig = HI_FALSE;
38
SAMPLE_VOU_SYS_Exit(void)39 HI_VOID SAMPLE_VOU_SYS_Exit(void)
40 {
41 HI_MPI_SYS_Exit();
42 HI_MPI_VB_Exit();
43 }
44
SAMPLE_VENC_GetGopMode(void)45 VENC_GOP_MODE_E SAMPLE_VENC_GetGopMode(void)
46 {
47 char c;
48 HI_S32 s32Ret = HI_SUCCESS;
49 VENC_GOP_MODE_E enGopMode = 0;
50
51 Begin_Get:
52
53 printf("please input choose gop mode!\n");
54 printf("\t 0) NORMALP.\n");
55 printf("\t 1) DUALP.\n");
56 printf("\t 2) SMARTP.\n");
57
58 while ((c = getchar()) != '\n') {
59 switch (c) {
60 case '0':
61 enGopMode = VENC_GOPMODE_NORMALP;
62 break;
63 case '1':
64 enGopMode = VENC_GOPMODE_DUALP;
65 break;
66 case '2':
67 enGopMode = VENC_GOPMODE_SMARTP;
68 break;
69 default:
70 s32Ret = HI_FAILURE;
71 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, Begin_Get,
72 "input gopmode: %c, is invaild!\n", c);
73 }
74 }
75
76 return enGopMode;
77 }
78
SAMPLE_VENC_GetRcMode(void)79 SAMPLE_RC_E SAMPLE_VENC_GetRcMode(void)
80 {
81 char c;
82 HI_S32 s32Ret = HI_SUCCESS;
83 SAMPLE_RC_E enRcMode = 0;
84
85 Begin_Get:
86
87 printf("please input choose rc mode!\n");
88 printf("\t c) cbr.\n");
89 printf("\t v) vbr.\n");
90 printf("\t a) avbr.\n");
91 printf("\t x) cvbr.\n");
92 printf("\t q) qvbr.\n");
93 printf("\t f) fixQp\n");
94
95 while ((c = getchar()) != '\n') {
96 switch (c) {
97 case 'c':
98 enRcMode = SAMPLE_RC_CBR;
99 break;
100 case 'v':
101 enRcMode = SAMPLE_RC_VBR;
102 break;
103 case 'a':
104 enRcMode = SAMPLE_RC_AVBR;
105 break;
106 case 'q':
107 enRcMode = SAMPLE_RC_QVBR;
108 break;
109 case 'x':
110 enRcMode = SAMPLE_RC_CVBR;
111 break;
112 case 'f':
113 enRcMode = SAMPLE_RC_FIXQP;
114 break;
115 default:
116 s32Ret = HI_FAILURE;
117 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, Begin_Get,
118 "input rcmode: %c, is invaild!\n", c);
119 }
120 }
121
122 return enRcMode;
123 }
124
SAMPLE_VENC_SYS_Init(HI_U32 u32SupplementConfig,SAMPLE_SNS_TYPE_E enSnsType)125 HI_S32 SAMPLE_VENC_SYS_Init(HI_U32 u32SupplementConfig, SAMPLE_SNS_TYPE_E enSnsType)
126 {
127 HI_S32 s32Ret;
128 HI_U64 u64BlkSize;
129 VB_CONFIG_S stVbConf;
130 PIC_SIZE_E enSnsSize;
131 SIZE_S stSnsSize;
132
133 memset_s(&stVbConf, sizeof(VB_CONFIG_S), 0, sizeof(VB_CONFIG_S));
134
135 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(enSnsType, &enSnsSize);
136 if (HI_SUCCESS != s32Ret) {
137 SAMPLE_PRT("SAMPLE_COMM_VI_GetSizeBySensor failed!\n");
138 return s32Ret;
139 }
140
141 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSnsSize, &stSnsSize);
142 if (HI_SUCCESS != s32Ret) {
143 SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
144 return s32Ret;
145 }
146
147 u64BlkSize = COMMON_GetPicBufferSize(stSnsSize.u32Width, stSnsSize.u32Height,
148 PIXEL_FORMAT_YVU_SEMIPLANAR_422, DATA_BITWIDTH_8, COMPRESS_MODE_SEG, DEFAULT_ALIGN);
149 stVbConf.astCommPool[0].u64BlkSize = u64BlkSize;
150 stVbConf.astCommPool[0].u32BlkCnt = 10; // 10: Number of cache blocks per cache pool
151
152 u64BlkSize = COMMON_GetPicBufferSize(PIC_WIDTH, PIC_HEIGHT, PIXEL_FORMAT_YVU_SEMIPLANAR_422,
153 DATA_BITWIDTH_8, COMPRESS_MODE_SEG, DEFAULT_ALIGN);
154 stVbConf.astCommPool[1].u64BlkSize = u64BlkSize;
155 stVbConf.astCommPool[1].u32BlkCnt = 10; // 10: Number of cache blocks per cache pool
156
157 stVbConf.u32MaxPoolCnt = 2; // 2: The number of buffer pools that can be accommodated in the entire system
158
159 if (u32SupplementConfig == 0) {
160 s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
161 } else {
162 s32Ret = SAMPLE_COMM_SYS_InitWithVbSupplement(&stVbConf, u32SupplementConfig);
163 }
164 if (HI_SUCCESS != s32Ret) {
165 SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
166 return s32Ret;
167 }
168
169 return HI_SUCCESS;
170 }
171
SAMPLE_VENC_VI_Init(SAMPLE_VI_CONFIG_S * pstViConfig,HI_BOOL bLowDelay,HI_U32 u32SupplementConfig)172 HI_S32 SAMPLE_VENC_VI_Init(SAMPLE_VI_CONFIG_S *pstViConfig, HI_BOOL bLowDelay, HI_U32 u32SupplementConfig)
173 {
174 HI_S32 s32Ret;
175 SAMPLE_SNS_TYPE_E enSnsType;
176 ISP_CTRL_PARAM_S stIspCtrlParam;
177 HI_U32 u32FrameRate;
178
179 enSnsType = pstViConfig->astViInfo[0].stSnsInfo.enSnsType;
180
181 pstViConfig->as32WorkingViId[0] = 0;
182 pstViConfig->astViInfo[0].stSnsInfo.MipiDev =
183 SAMPLE_COMM_VI_GetComboDevBySensor(pstViConfig->astViInfo[0].stSnsInfo.enSnsType, 0);
184 pstViConfig->astViInfo[0].stSnsInfo.s32BusId = 0;
185 pstViConfig->astViInfo[0].stDevInfo.enWDRMode = WDR_MODE_NONE;
186
187 if (HI_TRUE == bLowDelay) {
188 pstViConfig->astViInfo[0].stPipeInfo.enMastPipeMode = VI_ONLINE_VPSS_ONLINE;
189 } else {
190 pstViConfig->astViInfo[0].stPipeInfo.enMastPipeMode = VI_OFFLINE_VPSS_OFFLINE;
191 }
192 s32Ret = SAMPLE_VENC_SYS_Init(u32SupplementConfig, enSnsType);
193 if (s32Ret != HI_SUCCESS) {
194 SAMPLE_PRT("Init SYS err for %#x!\n", s32Ret);
195 return s32Ret;
196 }
197
198 pstViConfig->astViInfo[0].stPipeInfo.aPipe[1] = -1; // -1: the value of aPipe[1]
199 pstViConfig->astViInfo[0].stPipeInfo.aPipe[2] = -1; // -1: the value of aPipe[2]
200 pstViConfig->astViInfo[0].stPipeInfo.aPipe[3] = -1; // -1: the value of aPipe[3]
201 pstViConfig->astViInfo[0].stChnInfo.enVideoFormat = VIDEO_FORMAT_LINEAR;
202 pstViConfig->astViInfo[0].stChnInfo.enCompressMode = COMPRESS_MODE_SEG; // COMPRESS_MODE_SEG
203
204 s32Ret = SAMPLE_COMM_VI_SetParam(pstViConfig);
205 if (HI_SUCCESS != s32Ret) {
206 SAMPLE_PRT("SAMPLE_COMM_VI_SetParam failed with %d!\n", s32Ret);
207 return s32Ret;
208 }
209
210 SAMPLE_COMM_VI_GetFrameRateBySensor(enSnsType, &u32FrameRate);
211
212 s32Ret = HI_MPI_ISP_GetCtrlParam(pstViConfig->astViInfo[0].stPipeInfo.aPipe[0], &stIspCtrlParam);
213 if (HI_SUCCESS != s32Ret) {
214 SAMPLE_PRT("HI_MPI_ISP_GetCtrlParam failed with %d!\n", s32Ret);
215 return s32Ret;
216 }
217
218 // 30: ISP statistics update frequency is equal to (FrameRate / 30)
219 stIspCtrlParam.u32StatIntvl = u32FrameRate / 30;
220
221 s32Ret = HI_MPI_ISP_SetCtrlParam(pstViConfig->astViInfo[0].stPipeInfo.aPipe[0], &stIspCtrlParam);
222 if (HI_SUCCESS != s32Ret) {
223 SAMPLE_PRT("HI_MPI_ISP_SetCtrlParam failed with %d!\n", s32Ret);
224 return s32Ret;
225 }
226
227 s32Ret = SAMPLE_COMM_VI_StartVi(pstViConfig);
228 if (HI_SUCCESS != s32Ret) {
229 SAMPLE_COMM_SYS_Exit();
230 SAMPLE_PRT("SAMPLE_COMM_VI_StartVi failed with %d!\n", s32Ret);
231 return s32Ret;
232 }
233
234 return HI_SUCCESS;
235 }
236
SAMPLE_VENC_ModifyResolution(SAMPLE_SNS_TYPE_E enSnsType,PIC_SIZE_E * penSize,SIZE_S * pstSize)237 HI_S32 SAMPLE_VENC_ModifyResolution(SAMPLE_SNS_TYPE_E enSnsType, PIC_SIZE_E *penSize, SIZE_S *pstSize)
238 {
239 HI_S32 s32Ret;
240 SIZE_S stSnsSize;
241 PIC_SIZE_E enSnsSize;
242
243 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(enSnsType, &enSnsSize);
244 if (HI_SUCCESS != s32Ret) {
245 SAMPLE_PRT("SAMPLE_COMM_VI_GetSizeBySensor failed!\n");
246 return s32Ret;
247 }
248 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSnsSize, &stSnsSize);
249 if (HI_SUCCESS != s32Ret) {
250 SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
251 return s32Ret;
252 }
253
254 *penSize = enSnsSize;
255 pstSize->u32Width = stSnsSize.u32Width;
256 pstSize->u32Height = stSnsSize.u32Height;
257
258 return HI_SUCCESS;
259 }
260
SAMPLE_VENC_CheckSensor(SAMPLE_SNS_TYPE_E enSnsType,SIZE_S stSize)261 HI_S32 SAMPLE_VENC_CheckSensor(SAMPLE_SNS_TYPE_E enSnsType, SIZE_S stSize)
262 {
263 HI_S32 s32Ret;
264 SIZE_S stSnsSize;
265 PIC_SIZE_E enSnsSize;
266
267 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(enSnsType, &enSnsSize);
268 if (HI_SUCCESS != s32Ret) {
269 SAMPLE_PRT("SAMPLE_COMM_VI_GetSizeBySensor failed!\n");
270 return s32Ret;
271 }
272 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSnsSize, &stSnsSize);
273 if (HI_SUCCESS != s32Ret) {
274 SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
275 return s32Ret;
276 }
277
278 if ((stSnsSize.u32Width < stSize.u32Width) || (stSnsSize.u32Height < stSize.u32Height)) {
279 SAMPLE_PRT("Sensor size is (%d,%d), but encode chnl is (%d,%d) !\n",
280 stSnsSize.u32Width, stSnsSize.u32Height, stSize.u32Width, stSize.u32Height);
281 return HI_FAILURE;
282 }
283
284 return HI_SUCCESS;
285 }
286
SAMPLE_VENC_VPSS_Init(VPSS_GRP VpssGrp,HI_BOOL * pabChnEnable,DYNAMIC_RANGE_E enDynamicRange,PIXEL_FORMAT_E enPixelFormat,SIZE_S stSize[],SAMPLE_SNS_TYPE_E enSnsType)287 HI_S32 SAMPLE_VENC_VPSS_Init(VPSS_GRP VpssGrp, HI_BOOL* pabChnEnable, DYNAMIC_RANGE_E enDynamicRange,
288 PIXEL_FORMAT_E enPixelFormat, SIZE_S stSize[], SAMPLE_SNS_TYPE_E enSnsType)
289 {
290 HI_S32 i;
291 HI_S32 s32Ret;
292 PIC_SIZE_E enSnsSize;
293 SIZE_S stSnsSize;
294 VPSS_GRP_ATTR_S stVpssGrpAttr = {0};
295 VPSS_CHN_ATTR_S stVpssChnAttr[VPSS_MAX_PHY_CHN_NUM];
296
297 s32Ret = SAMPLE_COMM_VI_GetSizeBySensor(enSnsType, &enSnsSize);
298 if (HI_SUCCESS != s32Ret) {
299 SAMPLE_PRT("SAMPLE_COMM_VI_GetSizeBySensor failed!\n");
300 return s32Ret;
301 }
302
303 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSnsSize, &stSnsSize);
304 if (HI_SUCCESS != s32Ret) {
305 SAMPLE_PRT("SAMPLE_COMM_SYS_GetPicSize failed!\n");
306 return s32Ret;
307 }
308
309 stVpssGrpAttr.enDynamicRange = enDynamicRange;
310 stVpssGrpAttr.enPixelFormat = enPixelFormat;
311 stVpssGrpAttr.u32MaxW = stSnsSize.u32Width;
312 stVpssGrpAttr.u32MaxH = stSnsSize.u32Height;
313 stVpssGrpAttr.stFrameRate.s32SrcFrameRate = -1; // -1: The source frame rate, no frame rate control
314 stVpssGrpAttr.stFrameRate.s32DstFrameRate = -1; // -1: The destination frame rate, no frame rate control
315 stVpssGrpAttr.bNrEn = HI_TRUE;
316 stVpssGrpAttr.stNrAttr.enNrType = VPSS_NR_TYPE_VIDEO;
317 stVpssGrpAttr.stNrAttr.enNrMotionMode = NR_MOTION_MODE_NORMAL;
318 stVpssGrpAttr.stNrAttr.enCompressMode = COMPRESS_MODE_FRAME;
319
320 for (i = 0; i < VPSS_MAX_PHY_CHN_NUM; i++) {
321 if (HI_TRUE == pabChnEnable[i]) {
322 stVpssChnAttr[i].u32Width = stSize[i].u32Width;
323 stVpssChnAttr[i].u32Height = stSize[i].u32Height;
324 stVpssChnAttr[i].enChnMode = VPSS_CHN_MODE_USER;
325 stVpssChnAttr[i].enCompressMode = COMPRESS_MODE_NONE; // COMPRESS_MODE_SEG
326 stVpssChnAttr[i].enDynamicRange = enDynamicRange;
327 stVpssChnAttr[i].enPixelFormat = enPixelFormat;
328 stVpssChnAttr[i].stFrameRate.s32SrcFrameRate = -1; // -1: The source frame rate, no frame rate control
329 stVpssChnAttr[i].stFrameRate.s32DstFrameRate = -1; // -1: The destination frame rate, no frame rate control
330 stVpssChnAttr[i].u32Depth = 0;
331 stVpssChnAttr[i].bMirror = HI_FALSE;
332 stVpssChnAttr[i].bFlip = HI_FALSE;
333 stVpssChnAttr[i].enVideoFormat = VIDEO_FORMAT_LINEAR;
334 stVpssChnAttr[i].stAspectRatio.enMode = ASPECT_RATIO_NONE;
335 }
336 }
337
338 s32Ret = SAMPLE_COMM_VPSS_Start(VpssGrp, pabChnEnable, &stVpssGrpAttr, stVpssChnAttr);
339 if (s32Ret != HI_SUCCESS) {
340 SAMPLE_PRT("start VPSS fail for %#x!\n", s32Ret);
341 }
342
343 return s32Ret;
344 }
345
346 /* init ViCfg */
ViCfgInit(ViCfg * self)347 HI_S32 ViCfgInit(ViCfg *self)
348 {
349 HI_S32 s32Ret;
350 HI_ASSERT(self);
351 if (memset_s(self, sizeof(*self), 0, sizeof(*self)) != EOK) {
352 HI_ASSERT(0);
353 }
354
355 SAMPLE_COMM_VI_GetSensorInfo(self);
356 if (SAMPLE_SNS_TYPE_BUTT == self->astViInfo[0].stSnsInfo.enSnsType) {
357 SAMPLE_PRT("Not set SENSOR%d_TYPE !\n", 0);
358 return HI_FAILURE;
359 }
360 s32Ret = SAMPLE_VENC_CheckSensor(self->astViInfo[0].stSnsInfo.enSnsType, g_sampleStoreInfo.stSize[0]);
361 if (s32Ret != HI_SUCCESS) {
362 s32Ret = SAMPLE_VENC_ModifyResolution(self->astViInfo[0].stSnsInfo.enSnsType,
363 &enSize[0], &g_sampleStoreInfo.stSize[0]);
364 SAMPLE_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, "SAMPLE_VENC_ModifyResolution failed!\n", s32Ret);
365 }
366
367 return HI_SUCCESS;
368 }
369
ViCfgSetDevPipeChnInfo(ViCfg * self)370 HI_VOID ViCfgSetDevPipeChnInfo(ViCfg *self)
371 {
372 HI_ASSERT(self);
373 self->s32WorkingViNum = 1;
374 self->astViInfo[0].stDevInfo.ViDev = 0;
375 self->astViInfo[0].stPipeInfo.aPipe[0] = 0;
376 self->astViInfo[0].stChnInfo.ViChn = 0;
377 self->astViInfo[0].stChnInfo.enDynamicRange = DYNAMIC_RANGE_SDR8;
378 self->astViInfo[0].stChnInfo.enPixFormat = PIXEL_FORMAT_YVU_SEMIPLANAR_420;
379 }
380
Pause(HI_VOID)381 static HI_VOID Pause(HI_VOID)
382 {
383 printf("---------------press Enter key to exit!---------------\n");
384 (void)getchar();
385 }
386
EnRcModeGopModeCfg(SampleStoreInfo * storeInfo)387 static HI_VOID EnRcModeGopModeCfg(SampleStoreInfo *storeInfo)
388 {
389 storeInfo->enRcMode = SAMPLE_VENC_GetRcMode();
390 storeInfo->enGopMode = SAMPLE_VENC_GetGopMode();
391 }
392
SAMPLE_VENC_H265_H264(void)393 int SAMPLE_VENC_H265_H264(void)
394 {
395 HI_S32 s32Ret;
396
397 for (int i = 0; i < 2; i++) { // 2: channel number
398 s32Ret = SAMPLE_COMM_SYS_GetPicSize(enSize[i], &g_sampleStoreInfo.stSize[i]);
399 SAMPLE_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, "SAMPLE_COMM_SYS_GetPicSize failed!\n", s32Ret);
400 }
401
402 s32Ret = ViCfgInit(&g_sampleStoreInfo.viCfg);
403 SAMPLE_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, "ViCfgInit failed!\n", s32Ret);
404 ViCfgSetDevPipeChnInfo(&g_sampleStoreInfo.viCfg);
405
406 s32Ret = SAMPLE_VENC_VI_Init(&g_sampleStoreInfo.viCfg, HI_FALSE, u32SupplementConfig);
407 SAMPLE_CHECK_EXPR_RET(s32Ret != HI_SUCCESS, s32Ret, "Init VI err for %#x!\n", s32Ret);
408
409 s32Ret = SAMPLE_VENC_VPSS_Init(0, abChnEnable, DYNAMIC_RANGE_SDR8, PIXEL_FORMAT_YVU_SEMIPLANAR_420,
410 g_sampleStoreInfo.stSize, g_sampleStoreInfo.viCfg.astViInfo[0].stSnsInfo.enSnsType);
411 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, EXIT_VI_STOP, "Init VPSS err for %#x!\n", s32Ret);
412
413 s32Ret = SAMPLE_COMM_VI_Bind_VPSS(0, 0, 0);
414 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, EXIT_VPSS_STOP, "VI Bind VPSS err for %#x!\n", s32Ret);
415
416 /* start stream venc */
417 EnRcModeGopModeCfg(&g_sampleStoreInfo);
418 s32Ret = SAMPLE_COMM_VENC_GetGopAttr(g_sampleStoreInfo.enGopMode, &g_sampleStoreInfo.stGopAttr);
419 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, EXIT_VI_VPSS_UNBIND, "Venc Get GopAttr for %#x!\n", s32Ret);
420
421 /* encode h.265 */
422 s32Ret = SAMPLE_COMM_VENC_Start(VencChn[0], enPayLoad[0], enSize[0],
423 g_sampleStoreInfo.enRcMode, u32Profile[0], bRcnRefShareBuf, &g_sampleStoreInfo.stGopAttr);
424 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, EXIT_VI_VPSS_UNBIND, "Venc Start failed for %#x!\n", s32Ret);
425
426 s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(0, VpssChn[0], VencChn[0]);
427 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, EXIT_VENC_H265_STOP, "Venc Get GopAttr failed for %#x!\n", s32Ret);
428
429 /* encode h.264 */
430 s32Ret = SAMPLE_COMM_VENC_Start(VencChn[1], enPayLoad[1], enSize[1],
431 g_sampleStoreInfo.enRcMode, u32Profile[1], bRcnRefShareBuf, &g_sampleStoreInfo.stGopAttr);
432 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, EXIT_VENC_H265_UnBind, "Venc Start failed for %#x!\n", s32Ret);
433
434 s32Ret = SAMPLE_COMM_VPSS_Bind_VENC(0, VpssChn[1], VencChn[1]);
435 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, EXIT_VENC_H264_STOP, "Venc bind Vpss failed for %#x!\n", s32Ret);
436
437 /* stream save process */
438 s32Ret = SAMPLE_COMM_VENC_StartGetStream(VencChn, 2); // 2: channel number
439 SAMPLE_CHECK_EXPR_GOTO(s32Ret != HI_SUCCESS, EXIT_VENC_H264_UnBind, "Start Venc failed!\n", s32Ret);
440
441 Pause();
442
443 /* exit process */
444 SAMPLE_COMM_VENC_StopGetStream();
445
446 EXIT_VENC_H264_UnBind:
447 SAMPLE_COMM_VPSS_UnBind_VENC(0, VpssChn[1], VencChn[1]);
448 EXIT_VENC_H264_STOP:
449 SAMPLE_COMM_VENC_Stop(VencChn[1]);
450 EXIT_VENC_H265_UnBind:
451 SAMPLE_COMM_VPSS_UnBind_VENC(0, VpssChn[0], VencChn[0]);
452 EXIT_VENC_H265_STOP:
453 SAMPLE_COMM_VENC_Stop(VencChn[0]);
454 EXIT_VI_VPSS_UNBIND:
455 SAMPLE_COMM_VI_UnBind_VPSS(0, 0, 0);
456 EXIT_VPSS_STOP:
457 SAMPLE_COMM_VPSS_Stop(0, abChnEnable);
458 EXIT_VI_STOP:
459 SAMPLE_COMM_VI_StopVi(&g_sampleStoreInfo.viCfg);
460 SAMPLE_COMM_SYS_Exit();
461
462 return s32Ret;
463 }
464
465 #ifdef __cplusplus
466 #if __cplusplus
467 }
468 #endif
469 #endif /* End of #ifdef __cplusplus */
470