MI VENC API

1. API Reference¶

1.1. Overview¶

The video coding module mainly provides the functions of creating and destroying a video coding channel, resetting a video coding channel, starting and stopping receiving images, setting and acquiring coding channel attributes, and acquiring and releasing a code stream. This module supports multi-channel real-time coding, each channel is independent, and different coding protocols and profiles can be set.

1.1.1. Encoding Process¶

The coding process includes receiving the input image, coding the input image, and outputting the encoded stream. The format of input source can be NV12 or YUYV422.

The input sources of this module include the following two types:

1. The user's app directly sends image data to the encoding module

2. The pre-bound module such as VPE or DIVP sends the image data to the encoding module, as shown in the figure below:

   

1.1.2. Coding Channel¶

As a basic control unit, coding channels are completely independent of each other. Encoder (HW) completes the function of converting the original image into a code stream, which is completed by the control of Rate Controller and the Encoder (SW) in cooperation. The Rate Controller and Encoder (SW) of each channel stores all the resources set and managed by all users of the current encoding channel, such as rate control, buffer demand and allocation, etc. The rate control ensures the balance between the output rate and the image quality, while the encoder focuses on the realization of the syntax elements of each codec. Software and hardware control, at the same time, a codec hardware time-sharing multiplexing. Taking two coding channels for example, the basic block diagram of coding channel is as follows:

1.2. Keyword Description¶

1.2.1. QP¶

Quantization Parameter: QP value corresponds to the sequence number of quantization step. The smaller the value is, the smaller the quantization step is, the higher the accuracy of quantization, the better the image quality and the larger the encoded size are.

1.2.2. GOP¶

Group Of Pictures: The interval between two I frames. The video image sequence consists of one or more GOPs which are independent.

1.2.3. MB¶

Macroblock: Coding macroblock, basic unit of H.264 encoding.

1.2.4. CU¶

Coding Unit: Coding unit, basic unit of H.265 encoding which is similar to H.264 encoding macroblock.

1.2.5. SPS¶

Sequence Parameter Set: It contains the public information of all images in a GOP.

1.2.6. PPS¶

Picture Parameter Set: It contains the parameters used to encode an image.

1.2.7. SEI¶

Supplemental Enhancement information

1.2.8. ECS¶

Entropy-coded segment: Compressed image strip after entropy encoding of JPEG

1.2.9. MCU¶

Minimum code unit: The basic unit of JPEG encoding

1.2.10. Rate control¶

From the perspective of Informatics, the image compression ratio is inversely proportional to the quality: the higher the compression ratio, the lower the quality; the lower the compression ratio, the higher the quality.

Taking H.264 as an example, the lower the general image QP, the higher the image quality and the higher the bit rate; the higher the image QP, the lower the image quality and the lower the bit rate. The rate control algorithms supported by different coding protocols are as follows:

1.2.10.1. FIXQP

FIXQP: Fixed Quantization Parameter. At any time point, Qp of all MB/CU of the encoded image can directly be set by the user, and the Qp of I frame and P frame can be set respectively in H.264/H.265. However, some chips cannot set P frame Qp. The behavior of different chips is shown in the following table:

The control flow chart of H.264 and H.265 is as follows:

The control flow chart of JPEG is as follows:

It adopts the Qp table recommended by ITU-t81 K.1. The Qfactor set by the user is converted into a proportional factor according to a certain formula, and the multiplication of the two is the final Qp.

1.2.10.2. CBR

CBR: Constant Bit Rate. It can guarantee the stability of coding rate during code rate statistics. Because of different prediction methods, the size of I frame and P frame will be significantly different after coding. The bottom statistical time is based on Gop, and the bit accumulation and compensation will be realized between GOPs.

The main steps are as follows:

1. Convert Fps/Gop/bitrate set by user to bits of each GOP

2. I/P take different process, and BPP(bitperpixel) is calculated according to GOP bits and resolution

3. Map BPP to frame QP by rate control model

4. HW further adjusts MB/Cu QP based on frame QP by image texture complexity and other information

5. After coding, the rate control model is updated to achieve the continuous stability of the whole sequence, and the bit error is accumulated for the fine-tuning of bit allocation of subsequent frames

6. The bit error of the whole GOP is accumulated after the completion of the whole GOP, which is used for fine tuning of the next GOP bit allocation.

The control flow chart is as follows:

1.2.10.3. VBR

VBR: Variable Bit Rate. It allows the code rate to fluctuate within the code rate statistics time, so as to ensure the stable quality of the coding image. Take H.264 for example, users can set MaxQp, MinQp, MaxBitRate and ChangePos, details of which can be found in MI_VENC_ParamH264Vbr_t. MaxQp and MinQp are used to control the quality range of images. MaxBitRate is used for limiting maximum code rate within the statistics time. ChangePos is a percentage of the maximum bit rate, which is used to control the code rate reference line of starting to adjust QP, that is when the code rate is greater than MaxBitRate*ChangePos, the image QP will gradually adjust to MaxQp, if the image QP has reached MaxQp, the image QP will be clamped to the maximum value, the clamping effect of MaxBitRate will be lost, and the code rate may exceed MaxBitRate; if the code rate is less than MaxBitRate*ChangePos, the image QP will gradually adjust to MinQp. If the image QP has reached MinQp, the code rate has reached the maximum value and the image quality is best.

The specific process is as follows:

1. Convert the Fps/Gop/MaxBitRate/ChangePos and resolution set by user into the initial quality benchmark in order to set starting QP of the sequence.

2. HW further adjusts MB/CU QP based on frame QP by image texture complexity and other information.

3. Update rate control model after coding

4. Update the quality of the overall sequence

5. Calculate the deviation coefficient according to the difference between the current expected bit and the actual encoded bit, and decide whether the quality can be improved or reduced

6. Calculate the target quality of the current frame by the deviation coefficient and two quality coefficients

7. Map the target quality to frame QP, looping from 2.

The control flow chart is as follows:

1.2.10.4. AVBR

AVBR: Adaptive Variable Bit Rate. It allows the code rate to fluctuate within the code rate statistics time, so as to ensure the stable quality of the coding image. The rate control will detect the static state of the current scene, adopt higher rate coding when moving, and actively reduce the rate when still. Take H.264 for example, users can set MaxBitRate, ChangePos and MinStillPercent, details of which can be found in MI_VENC_ParamH264Avbr_t. MaxBitRate represents the maximum code rate in the motion scene, Minstitlpercent is the percentage of the minimum bit rate relative to the adjusted threshold bit rate in the static scene, MaxBitRate*ChangePos*MinStillPercent represents the minimum code rate in the static scene, and the target code rate will be adjusted between the minimum code rate and the maximum code rate according to the different degree of motion. MaxQp and MinQp are used to control the quality range of the image. The highest priority of the rate control is QP clamp. The rate control beyond MinQp and MaxQp will fail.

1.2.11. QPMAP¶

In qpmap mode, users are allowed to decide the rate control strategy freely, and absolute qpmap and relative qpmap are supported. Please refer to MI_VENC_AllocCustomMap.

1.2.12. Reference frame structure¶

H. 264/H.265 only supports one reference frame in a single frame, but the whole stream supports multiple reference frame buffers. For example: in LTR/TSVC3 mode, each P can only refer to one, but at most two reference frames will be saved for different P frames.

The reference frame supports 5 modes: NormalP, LTR (VI Ref IDR), LTR (VI Ref VI), TSVC-2 and TSVC-3. All reference frame structures are controlled by three parameters: u32Base, u32Enhance and bEnablePred. Please refer to MI_VENC_ParamRef_t for specific meanings. When u32Enhance is set to 0, it will be converted to NormalP reference frame structure. For other structures, please refer to the corresponding structure chart. The default structure is NormalP reference frame structure. The following details each reference diagram and parameter setting.

1.2.12.1. NormalP

NormalP is the most basic and common reference relationship. P frame directly refers to the previous one, and its structure diagram is shown in the following figure:

1.2.12.2. LTR mode

LTR (Long Term Reference) uses long-term reference frame and short-term reference frame to realize the same frame can be referred to multiple frames. This mode defines one special P as virtual I frame (VI). Compared with all IDR, using VI can reduce the code rate while maintaining a certain error recovery power. At present, LTR supports two modes: all VI refers to the latest IDR and VI refers to the previous VI or IDR (in the case of the first VI). The structures of the two reference modes are as follows:

Note: an extra buffer is required to enable LTR mode.

1.2.12.3. TSVC-2

TSVC-2 provides two-layers coding, and the frame rate can vary between ½ and full. The structure diagram is as follows:

1.2.12.4. TSVC-3

TSVC-3 provides three-layer coding, and the frame rate can vary between ¼, ½, ¾ and full. The structure diagram is as follows:

Note: an extra buffer is required to enable TSVC-3 mode.

1.2.13. Crop¶

Crop, that is, cutting out a part of the image for encoding. User can set the starting point of clipping left/top, width and height, please refer to relevant API: MI_VENC_SetCrop. The schematic diagram is as follows:

1.2.14. ROI¶

ROI: Region Of Interest. Region of interest coding, users can configure ROI region to limit the image QP of this region, so as to realize the difference between the QP of this region and other image regions. The system supports H264 and h265 to set ROI, and provides 8 ROI areas for users to use at the same time.

Eight ROI regions can be overlapped with each other, and the priority of the overlapped region is raised in sequence according to the index number of 0-7, that is to say, the QP of the overlapped region is finally determined to be processed only according to the region with the highest priority. The ROI area can be configured with absolute QP and relative QP:

Absolute QP: QP in ROI area is the QP value set by the user

Relative QP: the QP in ROI area is the sum of the QP generated by rate control and the QP offset value set by the user.

In the following example, the encoded image adopts the fixqp mode, setting the image QP to 30, that is, the QP value of all macroblocks of the image is 30. ROI region 0 is set to absolute QP mode, QP value is 20, index is 0; ROI region 1 is set to relative QP mode, QP is -15, index is 1. Because the index of ROI region 0 is smaller than the index of ROI region 1, the QP of ROI region 1 with high priority is set in the overlapped image region. The QP value of region 1 is 30-15 = 15, and the QP value of region 0 except the overlapped image region is 20.

1.2.15. Low frame rate encode in non ROI area¶

Low frame rate encode in non ROI area, that is to say, the ROI area is normally encoded after the ROI is turned on, while the non ROI area can reduce the frame rate by setting the proportional relationship between the source and the target. According to the scale relationship, the non ROI area of some frames in a GOP will directly use the data of the corresponding area of the previous frame. The user can set the relative frame rate of non ROI area according to the actual situation, and only when the ROI is turned on can it take effect. Please refer to API:MI_VENC_SetRoiBgFrameRate,s32srcFrmRate and s32dstFrmRate only represent a proportional relationship, independent of the actual frame rate.

1.2.16. Bind Type¶

Generally speaking, the bind type between front level and VENC is E_MI_SYS_BIND_TYPE_FRAME_BASE, that is, the front level completes a frame buffer completely, and then outputs it to the Venc. In this mode, at least three frame buffers need to be allocated. if the front level is VPE, there are two bind types which can save memory: E_MI_SYS_BIND_TYPE_HW_RING and E_MI_SYS_BIND_TYPE_REALTIME:

E_MI_SYS_BIND_TYPE_HW_RING means that VPE and VENC can read and write on the same one frame buffer in same time. In addition, Ispahan also supports reading and writing on half frame buffer; please refer to MI_VENC_SetInputSourceConfig for details.

E_MI_SYS_BIND_TYPE_REALTIME means that there is no need to allocate additional DRAM between VPE and VENC, because VPE and VENC are directly hardware connected.

Different chip and encode protocols support different bind type as follows:

1.3. Output buffer configuration of coded bitstream¶

Different chips support different configurations due to different SW architectures. The default configurations are as follows:

The above is the default output buffer configuration of each chip. User can specify the output buffer configuration by MI_VENC_CreateChn. Take H.264 as an example, user can specify the output buffer configuration by setting stVeAttr.stAttrH264e.u32BufSize,if the value is 0, the default configuration is used. In Pretzel, frame mode was used, that is to say, for each stream of coding, a specific size buffer will be allocated, generally the size used in the actual encoding will be smaller than the allocated size, which will cause memory fragmentation; while in the ring pool mode, each channel will separately allocate an output ring pool, and each coding will obtain the maximum free buffer from the pool, and then record the size of the actual coding used, and recycle output ring pool, which effectively improves the utilization of the buffer and reduces memory fragmentation.

2. Module list¶

2.1. MI_VENC_GetChnDevid¶

• Features

  Get the device id of the encoding channel.

• Syntax

  MI_S32 MI_VENC_GetChnDevid(MI_VENC_CHN VeChn, MI_U32 *pu32Devid);
  

• Form parameter

  parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pu32Devid	Encoding device id pointer.	Output

• Return Value

  • Zero: Successful

  • Non-zero: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Chip Difference

  The device ID corresponding to different coding protocols are different under different chips, as shown in the following table:

  Chip	H.264	H.265	JPEG
  Pretzel	0	0	1
  Macaron	0	0	1
  Pudding	0	0	1
  Ispahan	0	0	1
  Tiramisu	0	0	1

• Note

  This interface is called after the channel is created, and returns if the channel is not created.

  Because the device ID corresponding to different coding protocols may be different, if the parameter of interface to be called contains the device ID, User need to call this interface first to obtain the corresponding device ID of the current channel.

• Example

  MI_S32 BindVpeToJpeg()
  
  {
  
      MI_S32 s32Ret;
  
      MI_SYS_ChnPort_t stVencInputPort;
  
      MI_SYS_ChnPort_t stVpeOutputPort;
  
      MI_U32 u32DevId = 0;
  
      MI_U32 u32ChnId = 0;
  
      /*call MI_VPE_CreateChannel to create vpe channel*/
  
      /*call MI_VENC_CreateChn to create jpeg channel*/
  
      memset(&stVencInputPort, 0, sizeof(MI_SYS_ChnPort_t));
  
      s32Ret = MI_VENC_GetChnDevid(u32ChnId, &u32DevId);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetChnDevid err 0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stVencInputPort.eModId = E_MI_MODULE_ID_VENC;
  
      stVencInputPort.u32DevId = u32DevId;
  
      stVencInputPort.u32ChnId = u32ChnId;
  
      stVencInputPort.u32PortId = 0;
  
      stVpeOutputPort.eModId = E_MI_MODULE_ID_VPE;
  
      stVpeOutputPort.u32DevId = 0;
  
      stVpeOutputPort.u32ChnId = 0;
  
      stVpeOutputPort.u32PortId = 0;
  
      s32Ret = MI_SYS_BindChnPort2(&stVpeOutputPort, &stVencInputPort, 30, 30,
      E_MI_SYS_BIND_TYPE_FRAME_BASE, 0);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_SYS_BindChnPort2 err 0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return MI_SUCCESS;
  
  }
  

2.2. MI_VENC_SetModParam¶

• Features

  Set the module parameters related to the encoding.

• Syntax

  MI_S32 MI_VENC_SetModParam(MI_VENC_ModParam_t *pstModParam)
  

• Form parameter

  parameter name	Description	Input/Output
  pstModParam	Encoding module parameter pointer.	Input

• Return Value

  • Zero: Successful

  • Non-zero: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • This interface is called before the channel is created, and returns if the channel has been created.

  • MI_ERR_VENC_NOT_PERM.

  • You can set the parameters of the mi_venc.ko, mi_h264e.ko, mi_h265e.ko, mi_jpge.ko modules.

  • Not supported yet.

2.3. MI_VENC_GetModParam¶

• Features

  Get the module parameters related to the encoding.

• Syntax

  MI_S32 MI_VENC_GetModParam(MI_VENC_ModParam_t *pstModParam)
  

• Parameter

  Parameter name	Description	Input/Output
  pstModParam	Encoding module parameter pointer.	Output

• Return Value

  • Zero: Successful

  • Non-zero: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • You can get the parameters of the mi_venc.ko, mi_h264e.ko, mi_h265e.ko, mi_jpge.ko modules.

  • Not supported yet.

2.4. MI_VENC_CreateChn¶

• Features

  Create a code channel.

• Syntax

  MI_S32 MI_VENC_CreateChn(MI_VENC_CHN Vehn, *pstAttr);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstAttr	Coding channel property pointer.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_comm_rc.h, mi_venc.h

  • Library file: libmi.a

• Chip Difference

  The supported coding specifications of different chip are shown in the following table:

  Chip	H.264			H.265	JPEG
  	Baseline Profile	Main Profile	High Profile	Main Profile	Baseline Profile
  Pretzel	Y	Y	N	Y	Y
  Macaron	Y	Y	N	Y	Y
  Pudding	Y	Y	Y	Y	Y
  Ispahan	Y	Y	Y	Y	Y
  Tiramisu	Y	Y	Y	Y	Y

  The width and height of coding channels supported by different chips are shown in the table below:

  Chip	Resolution Spec	H.264	H.265	JPEG
  Pretzel	MIN_WIDTHxMIN_HEIGHT	192x128	192x128	16x16
  	MAX_WIDTHxMAX_HEIGHT	3840x2176	3840x2176	3840x2176
  	MIN_ALIGN	8x2	8x2	8x2
  Macaron	MIN_WIDTHxMIN_HEIGHT	192x128	192x128	16x16
  	MAX_WIDTHxMAX_HEIGHT	2688x1920	2688x1920	2688x2688
  	MIN_ALIGN	8x2	8x2	8x2
  Pudding	MIN_WIDTHxMIN_HEIGHT	256x128	256x128	16x16
  	MAX_WIDTHxMAX_HEIGHT	3840x2176	3840x2176	3840x2176
  	MIN_ALIGN	8x2	8x2	8x2
  Ispahan	MIN_WIDTHxMIN_HEIGHT	256x128	256x128	16x16
  	MAX_WIDTHxMAX_HEIGHT	2592x1952	2592x1952	2688x2688
  	MIN_ALIGN	8x2	8x2	8x2
  Tiramisu	MIN_WIDTHxMIN_HEIGHT	256x128	256x128	16x16
  	MAX_WIDTHxMAX_HEIGHT	4096x2176	4096x2176	8192x8192
  	MIN_ALIGN	8x2	8x2	8x2

• Note

  • The encoding channel attribute consists of two parts, the encoder attribute and the rate controller attribute.

  • The encoder attribute first needs to select the encoding protocol, and then assign values ​​to the attributes corresponding to the various protocols.

  • The maximum width and height of the encoder attributes must be as follows:

    MaxPicWidth∈[MIN_WIDTH,MAX_WIDTH]

    MaxPicHeight∈[MIN_HEIGHT,MAX_HEIGHT]

    PicWidth∈[MIN_WIDTH,MaxPicwidth]

    PicHeight∈[MIN_HEIGHT,MaxPicHeight]

  • The maximum width and height, the channel width must be an integer multiple of MIN_ALIGN.

  • Where MIN_WIDTH, MAX_WIDTH, MIN_HEIGHT, MAX_HEIGHT, MIN_ALIGN represent the minimum width, maximum width, minimum height, maximum height, and minimum alignment unit (pixels) supported by the encoding channel, respectively.

  • The encoding channel can be encoded when the input image size is not greater than the maximum width and height of the channel encoded image.

  • The recommended code widths are: 3840x2160 ( 4k*2k ), 1920x1080(1080P)、1280x720 ( 720P ), 960x540, 640x360, 704x576, 704x480, 352x288, 352x240.

  • In addition to the channel width and height and profile, the encoder attribute is a static attribute. Once the code channel is created successfully, the static attribute does not support modification unless the channel is destroyed and recreated. Please refer to the MI_VENC_SetChnAttr interface Description for the matters needing attention during setup.

  • The rate controller attribute first needs to configure the RC mode. The JPEG capture channel does not need to configure the rate controller attribute. Other protocol type channels (H.264/H.265/MJPEG) must be configured. The rate controller attribute RC mode must match the encoder attribute protocol type.

  • Three encoding protocols (H.264/H.265 /MJPEG) support three modes for rate control: CBR, VBR and FIXQP. And for different protocols, the attribute variables of the same RC mode are basically the same.

  • u32srcFrmRateNum refers to the molecular part of the frame rate of the encoding module, and u32srcFrmRateDen refers to the denominator part of the frame rate of the encoding module. u32srcFrmRateNum/u32srcFrmRateDen should be set to the actual frame rate generated by TimeRef.RC needs to count the actual frame rate and control the code rate according to u32srcFrmRateNum/u32srcFrmRateDen.If the source of the encoded image is VI,u32srcFrmRateNum/u32srcFrmRateDen should be set to the actual output frame rate of VI, because TimeRef is generated when VI output. If the actual output frame rate of VI is 30,u32srcFrmRateNum should be set to 30 and u32srcFrmRateDen should be set to 1.

  In addition to the above attributes, CBR also needs to set the average bit rate and fluctuation level.

  The unit of the average bit rate is bps. The setting of the average bit rate is related to the encoding channel width and the image frame rate. The typical average bit rate settings are shown in the following table. Note that the setting of the average bit rate in the table below is the setting when the channel encoding frame rate is the full frame rate (30 fps). When the user sets the code output frame rate not to the full frame rate, the ratio of the user-set frame rate to the full frame rate (30 fps) can be converted to the bit rate in the table below.

  Image W/H/bitrate level	D1 (720x576)	720p (1280x720)	1080p (1920x1080)
  Low bit rate	＜400 Kbps	＜800 Kbps	＜2000 Kbps
  Medium code rate	400～1000Kbps	800～4000Kpbs	2000～8000Kbps
  High code rate	1000Kbps	4000Kbps	8000Kbps

  • The fluctuation level setting is divided into 5 levels. The larger the fluctuation level, the larger the fluctuation range of the system allowed code rate. If the fluctuation level is set high, the image quality may be smoother for some scenes with complex images and dramatic changes. It is suitable for scenes with rich network bandwidth. If the fluctuation level is set low, the code rate of the code will be relatively stable. For some images, In scenes with dramatic changes, the image quality may not be as high as the volatility level. It is suitable for scenes with less bandwidth, reserved, and temporarily unused.

  • In addition to the above attributes, VBR needs to set MaxBitRate, MaxQp, MinQp.

  • MaxBitRate: The maximum code rate allowed for the encoding channel during the rate statistics period.

  • MaxQp: The maximum QP allowed for the image.

  • MinQp: The minimum QP allowed for the image.

  • FIXQP addition to the above properties, also need to set IQp, PQp.

  • IQp: QP value used for fixed images in I frames.

  • PQp: The QP value used for fixed images in P frames.

    When the I frame QP and the P frame QP are set, the I frame QP and the P frame QP can be adjusted upward or downward simultaneously according to the current bandwidth limitation. In order to reduce the breathing effect, it is recommended that the I frame QP is always 2 to 3 smaller than the QP of the P frame.

  The maximum VENC_MAX_CHN_NUM specifications supported by different chips are shown in the following table:

  Chips	NUMmax
  Macaron	16
  Pudding	16
  Ispahan	16
  Ikayaki	16
  Tiramisu	33

• Example

  MI_S32 StartVenc()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_CHN VeChn = 0;
  
      MI_VENC_ChnAttr_t stAttr;
  
      /*set h264 chnnel video encode attribute*/
  
      stAttr.stVeAttr.eType = E_MI_VENC_MODTYPE_H264E;
  
      stAttr.stVeAttr.stAttrH264e.u32PicWidth = u32PicWidth;
  
      stAttr.stVeAttr.stAttrH264e.u32PicHeight = u32PicHeigh;
  
      stAttr.stVeAttr.stAttrH264e.u32MaxPicWidth = u32MaxPicWidth;
  
      stAttr.stVeAttr.stAttrH264e.u32MaxPicHeight = u32MaxPicHeigh;
  
      stAttr.stVeAttr.stAttrH264e.u32Profile = 2;
  
      /*set h264 chnnel rate control attribute*/
  
      stAttr.stRcAttr.enRcMode = E_MI_VENC_RC_MODE_H264CBR;
  
      stAttr.stRcAttr.stAttrH264Cbr.u32BitRate = 10*1024*1024;
  
      stAttr.stRcAttr.stAttrH264Cbr.fr32DstFrmRate = 30;
  
      stAttr.stRcAttr.stAttrH264Cbr.u32SrcFrmRate = 30;
  
      stAttr.stRcAttr.stAttrH264Cbr.u32Gop = 30;
  
      stAttr.stRcAttr.stAttrH264Cbr.u32FluctuateLevel = 1;
  
      stAttr.stRcAttr.stAttrH264Cbr.u32StatTime = 1;
  
      s32Ret = MI_VENC_CreateChn(VeChn, &stAttr);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_CreateChn err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      s32Ret = MI_VENC_StartRecvPic(VeChn);
  
      if (s32Ret != MI_SUCCESS)
  
      {
  
          printf("MI_VENC_StartRecvPic err0x%x\n",s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return MI_SUCCESS;
  
  }
  

2.5. MI_VENC_DestroyChn¶

• Features

  Destroy the encoding channel.

• Syntax

  MI_S32 MI_VENC_DestroyChn(MI_VENC_CHN VeChn);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • Destroy a channel that does not exist and return failure.

  • You must stop receiving images before destroying, otherwise the return fails.

  • If the OSD is enabled, the interface MI_RGN_DetachFrmChn is called to remove the OSD area from the current channel before the encoding channel is destroyed.

• Example

  MI_S32 StopVenc()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_CHN VeChn = 0;
  
      s32Ret = MI_VENC_StopRecvPic(VeChn);
  
      if (s32Ret != MI_SUCCESS)
  
      {
  
          printf("MI_VENC_StopRecvPic err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      s32Ret = MI_VENC_DestroyChn(VeChn);
  
      if (s32Ret != MI_SUCCESS)
  
      {
  
          printf("MI_VENC_DestroyChn err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return MI_SUCCESS;
  
  }
  

2.6. MI_VENC_ResetChn¶

• Features

  Reset the channel. It will clear the cached image and bitstream before calling the interface.

• Syntax

  MI_S32 MI_VENC_ResetChn(MI_VENC_CHN VeChn);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • Reset does not exist in the channel, returning failure MI_ERR_VENC_UNEXIST.

  • If a channel does not stop receiving images and resets the channel, it returns a failure.

  • Not supported yet.

2.7. MI_VENC_StartRecvPic¶

• Features

  Turn on the encoding channel to receive the input image.

• Syntax

  MI_S32 MI_VENC_StartRecvPic(MI_VENC_CHN VeChn);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • If the channel is not created, the failure MI_ERR_VENC_UNEXIST is returned.

  • This interface does not determine whether the reception is currently enabled, that is, allows repeated activation without returning an error.

  • The encoder starts receiving image coding only after receiving the reception.

  • Example

    Please refer to MI_VENC_CreateChn Example.

2.8. MI_VENC_StartRecvPicEx¶

• Features

  Turn on the encoding channel to receive the input image, and automatically stop receiving images after the specified number of frames.

• Syntax

  MI_S32 MI_VENC_StartRecvPicEx(MI_VENC_CHN VeChn,
  MI_VENC_RecvPicParam_t *pstRecvParam);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstRecvParam	Receives an image parameter structure pointer that specifies the number of image frames that need to be received.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • If the channel is not created, the failure MI_ERR_VENC_UNEXIST is returned.

  • If the channel has already called MI_VENC_StartRecvPic to start receiving images without stopping receiving images, or has not received enough images since the last call to MI_VENC_StartRecvPicEx, calling this interface again is not allowed.

  • This interface is used to continuously receive N frames and encode scenes. When N=0, the interface is equivalent to MI_VENC_StartRecvPic.

  • If the channel has already called MI_VENC_StartRecvPic to start receiving images, stop receiving images, and call MI_VENC_StartRecvPicEx to start encoding again, it is recommended that the user call MI_VENC_ResetChn to clear the image and code stream buffered by the encoding module before calling the interface.

  • If you create a jpeg channel capture, it is recommended that you call MI_VENC_StartRecvPicEx because you need to receive an integer image and stop receiving it automatically.

• Example

  MI_S32 JpegSnapProcess()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_CHN VeChn=0;
  
      MI_VENC_ChnAttr_t stAttr;
  
      MI_VENC_RecvPicParam_t stRecvParam;
  
      /*set jpeg channel video encode attribute*/
  
      stAttr.stVeAttr.eType = E_MI_VENC_MODTYPE_JPEGE;
  
      stAttr.stVeAttr.stAttrJpeg.u32PicWidth = u32PicWidth;
  
      stAttr.stVeAttr.stAttrJpeg.u32PicHeight = u32PicHeigh;
  
      stAttr.stVeAttr.stAttrJpeg.u32MaxPicWidth = u32MaxPicWidth;
  
      stAttr.stVeAttr.stAttrJpeg.u32MaxPicHeight = u32MaxPicHeigh;
  
      //…omit other video encode assignments here.
  
      //create jpeg channel
  
      s32Ret = MI_VENC_CreateChn(VeChn, &stAttr);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_CreateChn err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      //start snapping
  
      stRecvParam.s32RecvPicNum = 2;
  
      s32Ret = MI_VENC_StartRecvPicEx(VeChn, &stRecvParam);
  
      if (s32Ret != MI_SUCCESS)
  
      {
  
          printf("MI_VENC_StartRecvPicEx err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      //…wait until all pictures have been encoded.
  
      s32Ret = MI_VENC_StopRecvPic(VeChn);
  
      if (s32Ret != MI_SUCCESS)
  
      {
  
          printf("MI_VENC_StopRecvPic err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      //destroy jpeg channel
  
      s32Ret = MI_VENC_DestroyChn(VeChn);
  
      if (s32Ret != MI_SUCCESS)
  
      {
  
          printf("MI_VENC_DestroyChn err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return MI_SUCCESS;
  
  }
  

2.9. MI_VENC_StopRecvPic¶

• Features

  Stop the encoding channel to receive the input image.

• Syntax

  MI_S32 MI_VENC_StopRecvPic(MI_VENC_CHN VeChn);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • If the channel is not created, it returns a failure.

  • This interface does not determine whether to stop receiving currently, that is, to allow repeated stop reception without returning an error.

  • This interface is used to encode the channel to stop receiving images for encoding, and must stop receiving images before the encoding channel is destroyed or reset.

  • Calling this interface only stops receiving the original data encoding, and the stream buffer is not cleared.

  • Call the MI_VENC_StartRecvPic and MI_VENC_StartRecvPicEx interfaces to start receiving images, you can call this interface to stop receiving.

• Example

  Please refer to MI_VENC_DestroyChn Example.

2.10. MI_VENC_Query¶

• Features

  Query the status of the encoded channel.

• Syntax

  MI_S32 MI_VENC_Query(MI_VENC_CHN VeChn,MI_VENC_ChnStat_t *pstStat);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstStat	The status pointer of the encoding channel.	Output

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • If the channel is not created, it returns a failure.

    This interface is used to query the encoder state at the time of this function call. pstStat contains four main pieces of information:

  • u32LeftPics represents the number of frames to be encoded. Before resetting the channel, you can determine the reset timing by querying whether there are still images to be encoded, and prevent the frames that may need to be cleaned out during reset.

  • u32LeftStreamBytes represents the number of bytes remaining in the code stream buffer. Before resetting the channel, you can determine the reset timing by querying whether the code stream is still not processed, and prevent the code stream that may be needed from being cleared when resetting.

  • u32LeftStreamFrames represents the number of frames remaining in the code stream buffer. Before resetting the channel, you can determine the reset timing by querying whether the code stream of the image is not taken, and prevent the code stream that may be needed from being cleared when resetting.

  • u32CurPacks represents the number of code stream packets of the current frame. Make sure u32CurPacks is greater than 0 before calling MI_VENC_GetStream ; otherwise, it will return an error that no buffer is available.

  • The current frame may not be a complete frame (taken a part) when acquired by packet, and the number of packets representing the current complete frame when acquired by frame (or 0 if there is no frame data ). When the user needs to obtain the code stream by frame, the number of packets of a complete frame needs to be queried. In this case, the query operation can usually be performed after the select succeeds. At this time, u32CurPacks is the number of packets in the current complete frame.

  • In the code channel state structure, u32LeftRecvPics indicates the number of frames remaining waiting to be received after calling the MI_VENC_StartRecvPicEx interface.

  • In the code channel state structure, u32LeftEncPics indicates the number of frames waiting to be encoded after calling the MI_VENC_StartRecvPicEx interface.

  • If MI_VENC_StartRecvPicEx is not called, the number of u32LeftRecvPics and u32LeftEncPics is always 0.

• Example

  Please refer to MI_VENC_GetStream Example.

2.11. MI_VENC_SetChnAttr¶

• Features

  Set the encoding channel dynamic properties, including coded width and height, profile, and rate control parameters.

• Syntax

  MI_S32 MI_VENC_SetChnAttr(MI_VENC_CHN
  VeChn,MI_VENC_ChnAttr_t *pstAttr);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstAttr	Coding channel property pointer.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • The maximum width and maximum height of the encoding channel cannot be dynamically set.

  • The encoding channel attribute includes two parts: the encoder attribute and the rate controller attribute.

  • Sets the properties of an uncreated channel and returns a failure.

  • If pstAttr is empty, it returns a failure.

  • As the channel limitations and restrictions created when the coded picture size setting.

  • The coding channel attributes are divided into dynamic attributes and static attributes. The attribute value of the dynamic attribute is configured when the channel is created, and can be modified before the channel is destroyed. The attribute value of the static attribute is configured when the channel is created, and cannot be modified after the channel is created.

  • This interface can only set dynamic properties in the encoding channel properties, or return failure if the static properties are set. The encoding protocol of the encoding channel, the way of acquiring the code stream (acquiring the code stream by frame or by packet), and the maximum width and height of the encoded image attribute are static attributes. In addition, the static attributes of each encoding protocol are specified by each protocol module. For details, see [I_VENC_Chn Attr_t.

  • Set the code rate controller attribute in the code channel attribute. The rate control mode is VBR. When the rate control advanced parameter is u32MinIQp is less than u32MinQp, where u32MinQp is the rate controller attribute, this interface changes the value of u32MinIQp to u32MinQp.

  • When setting the channel width and height attributes in the encoder properties, the priority of the channel will not be restored to the default. All other parameters of the encoding channel are restored to the default values, the OSD is closed, and the stream buffer and cached image queue are cleared.

2.12. MI_VENC_GetChnAttr¶

• Features

  Get the encoding channel properties.

• Syntax

  MI_S32 MI_VENC_GetChnAttr(MI_VENC_CHN
  VeChn,MI_VENC_ChnAttr_t *pstAttr);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstAttr	Coding channel property pointer.	Output

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • Get the properties of the channel that was not created, returning the failure MI_ERR_VENC_UNEXIST.

  • If pstAttr is empty, it returns a failure.

2.13. MI_VENC_GetStream¶

• Features

  Get the encoded code stream.

• Syntax

  MI_S32 MI_VENC_GetStream(MI_VENC_CHN VeChn,
  MI_VENC_Stream_t *pstStream,MI_S32 s32MilliSec);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstStream	Code stream structure pointer. The upper layer needs to point the pointer to an allocated block of memory, and also needs to allocate the memory of PackCount*sizeof(MI_VENC_Pack_t) for the Member MI_VENC_Pack_t *pstPack.	Input/Output
  s32MilliSec	The waiting time to call the API until the code stream is obtained. Value range: greater than or equal to 1. -1: Blocked. 0: Non-blocking. Greater than 0: Timeout, which is relative time, in ms.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • If the channel is not created, the return fails.

  • Returns MI_ERR_VENC_NULL_PTR if pstStream is empty.

  • If s32MilliSec is less than -1, return MI_ERR_VENC_ILLEGAL_PARAM.

  • Support timeout mode acquisition. Support for select/poll system calls.

  • When s32MilliSec=0, it is non-blocking acquisition, that is, if there is no data in the buffer, it returns the failure MI_ERR_VENC_BUF_EMPTY. When s32MilliSec=-1, it is blocked, that is, if there is no data in the buffer, it will return to the success if it waits for data. When s32MilliSec>0, it is timeout, that is, if there is no data in the buffer, it will wait for the timeout time set by the user. If there is data within the set time, the return is successful, otherwise the return timeout fails.

  • The code stream structure MI_VENC_Stream_t contains four parts:

  • the code stream packet information pointer pstPack points to a memory space of a group of MI_VENC_Pack_t, which space is allocated by the caller. The size is u32PackCount x sizeof(MI_VENC_Pack_t), which can be obtained by calling MI_VENC_Query after selection.

  • U32PackCount specifies the number of MI_VENC_Pack_t in the pstPack, which is the number of code streams in a complete frame.

  • U32Seq represents the sequence of a frame.

  • The stH264Info/stJpegInfo/stMpeg4Info/stH265Info combinations are the stream feature, which contains the characteristic information of code stream corresponding to different coding protocols. The output of the characteristic information of code stream is used to support the upper application of users.

  • This interface should be paired with MI_Venc_ReleaseStream for use. The system will not actively release the bitstream cache after the user obtains the bitstream. The user needs to release the acquired bitstream cache in time; otherwise, it may cause the bitstream buffer to be full, thereby affecting the encoder coding.

  • It is recommended that the user use the select method to obtain the code stream, and follow the following process:

  • call the MI_VENC_Query function to query the encoding channel state.

  • ensure that u32CurPacks and u32LeftStreamFrames are greater than 0 at the same time.

  • call malloc to allocate u32CurPacks packet information structures.

  • call MI_VENC_GetStream to obtain the encoded code stream.

  • Call MI_VENC_ReleaseStream to release the code stream buffer.

  • Taking H.264 as an example to introduce the code stream structure stored in pstPack[0], the corresponding information of pstPack[0] is as follows:

    pstPack[0].u32DataNum=3,

    pstPack[0].stPackInfo[0].u32PackType.enH264EType=E_MI_VENC_H264E_NALU_SPS, pstPack[0].stPackInfo[1].u32PackType.enH264EType=E_MI_VENC_H264E_NALU_PPS, pstPack[0].stPackInfo[2].u32PackType.enH264EType=E_MI_VENC_H264E_NALU_SEI ;

    The pstPack[0] contains three NALU packages, including SPS/PPS/SEI, as shown in the figure below:

    

  • Tiramisu platform supports decoding, so it can encoding and decoding in a same case, in that case, the packet obtained from MI_VENC_GetStream needs to be ensured if it is a complete frame. If the answer is yes, send the packet to the decoder directly. If not, combine multiple packets into a complete frame and send it to vdec for decoding. Judging whether the packet is a complete frame through the bFrameEnd flag of MI_VENC_Pack_t. If it is 1, it means yes, if it is 0, it is divided into multiple packets.

• Example

  MI_S32 VencGetH264Stream()
  {
      MI_S32 i;
      MI_S32 s32Ret;
      MI_S32 s32VencFd;
      MI_U32 u32FrameIdx = 0;
      MI_VENC_CHN VeChn = 0;
      MI_VENC_ChnAttr_t stStat;
      MI_VENC_Stream_t stStream;
      fd_set read_fds;
      FILE* pFile=NULL;
  
      pFile = fopen("stream.h264","wb");
      if (pFile == NULL)
      {
          return E_MI_ERR_FAILED;
      }
      s32VencFd = MI_VENC_GetFd(VeChn);
      do{
          FD_ZERO(&read_fds);
          FD_SET(s32VencFd, &read_fds);
          s32Ret = select(s32VencFd+1, &read_fds, NULL, NULL, NULL);
          if (s32Ret < 0)
          {
              printf("select err\n");
              return E_MI_ERR_FAILED;
          }
          else if (0 == s32Ret)
          {
              printf("timeout\n");
              return E_MI_ERR_FAILED;
          }
          else
          {
              if (FD_ISSET(s32VencFd, &read_fds))
              {
                  s32Ret = MI_VENC_Query(VeChn, &stStat);
                  if (s32Ret != MI_SUCCESS)
                  {
                      return E_MI_ERR_FAILED;
                  }
      /*******************************************************
      suggest to check both u32CurPacks and u32LeftStreamFrames at
      the same time,for 举例:
                  if (0 == stStat.u32CurPacks || 0 == stStat.u32LeftStreamFrames)
                  {
                      continue;
                  }
      *******************************************************/
                  if (0 == stStat.u32CurPacks)
                  {
                      continue;
                  }
                  stStream.pstPack = (MI_VENC_Pack_t*)malloc(sizeof(MI_VENC_Pack_t)*stStat.u32CurPacks);
                  if (NULL == stStream.pstPack)
                  {
                      return E_MI_ERR_FAILED;
                  }
                  stStream.u32PackCount = stStat.u32CurPacks;
                  s32Ret = MI_VENC_GetStream(VeChn, &stStream, -1);
                  if (MI_SUCCESS != s32Ret)
                  {
                      free(stStream.pstPack);
                      stStream.pstPack = NULL;
                      return E_MI_ERR_FAILED;
                  }
                  for (i=0; i<stStream.u32PackCount; i++)
                  {
                      fwrite(stStream.pstPack[i].pu8Addr+stStream.pstPack[i].u32Offset, 1,
                          stStream.pstPack[i].u32Len-stStream.pstPack[i].u32Offset, pFile);
                  }
                  s32Ret = MI_VENC_ReleaseStream(VeChn, &stStream);
                  if (MI_SUCCESS != s32Ret)
                  {
                      free(stStream.pstPack);
                      stStream.pstPack=NULL;
                      return E_MI_ERR_FAILED;
                  }
                  free(stStream.pstPack);
                  stStream.pstPack = NULL;
              }
          }
          u32FrameIdx++;
      }while(u32FrameIdx<0xff);
      fclose(pFile);
  
      return s32Ret;
  }
  

2.14. MI_VENC_ReleaseStream¶

• Features

  Release stream buffer.

• Syntax

  MI_S32 MI_VENC_ReleaseStream(MI_VENC_CHN
  VeChn,MI_VENC_Stream_t *pstStream);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstStream	Code stream structure pointer.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • If the channel is not created, an error code is returned MI_ERR_VENC_UNEXIST.

  • in case pstStream Empty, return error code MI_ERR_VENC_NULL_PTR.

  • This interface should be MI_VENC_GetStream Paired and used, the user must release the acquired code stream cache in time after obtaining the code stream, otherwise the code stream may be caused. Buffer Full, affecting the encoder encoding, and the user must release the already acquired stream buffer in the order in which they were first released first.

  • After the code channel is reset, all unreleased stream packets are invalid and cannot be used or released.

  • Invalid stream cache.

  • Releasing an invalid stream will return a failure MI_ERR_VENC_ILLEGAL_PARAM.

• Example

  Please refer to MI_VENC_GetStream Example.

2.15. MI_VENC_InsertUserData¶

• Features

  Insert user data.

• Syntax

  MI_S32 MI_VENC_InsertUserData(MI_VENC_CHN VeChn,MI_U8
  *pu8Data,MI_U32 u32Len);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pu8Data	User data pointer.	Input
  u32Len	User data length. Value range: (0,1024), in bytes.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • If the channel is not created, it returns a failure.

  • In case of pu8Data, if it is empty, it will return failure.

  • Insertion of user data only supports H.264/H.265.

  • H.264 Protocol channels are allocated at the same time. The block memory space is used to cache user data, and the data size of each segment of the user does not exceed 1kbyte. If the user inserts 4 extra data blocks, or inserts piece of user data greater than 1kbyte, this interface will return an error. Each piece of user data is inserted as an SEI package before the next I frame. After a certain user data packet is encoded and sent, H.264 The memory space of the user data buffered in the channel is cleared to store new user data.

• Example

  MI_S32 VencInsertUserData()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_CHN VeChn = 0;
  
      MI_U8 au8UserData[]="sigmastar2020";
  
      s32Ret = MI_VENC_InsertUserData(VeChn, au8UserData, sizeof(au8UserData));
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_InsertUserData err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.16. MI_VENC_SetMaxStreamCnt¶

• Features

  Set the maximum number of cache frames for the stream.

• Syntax

  MI_S32 MI_VENC_SetMaxStreamCnt(MI_VENC_CHN VeChn,MI_U32
  u32MaxStrmCnt);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  u32MaxStrmCnt	Maximum number of stream buffer frames.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • This interface is used to set the code stream of the encoding channel. Buffer The maximum number of streams that can be cached.

  • If the number of cached stream frames has reached the maximum number of stream frames, the current image to be encoded is due to the code stream. Buffer Full without being encoded.

  • The maximum number of streams is specified by the system when the channel is created. The default value is 3.

  • This interface can be called after the channel is created and before the code channel is destroyed. Take effect before the next frame starts encoding. This interface allows multiple calls. It is recommended to set the encoding before starting the encoding. It is not recommended to dynamically adjust during the encoding process.

2.17. MI_VENC_GetMaxStreamCnt¶

• Features

  Get the maximum number of cache frames in the stream.

• Syntax

  MI_S32 MI_VENC_GetMaxStreamCnt(MI_VENC_CHN VeChn,MI_U32
  *pu32MaxStrmCnt);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pu32MaxStrmCnt	A pointer to the maximum number of stream buffer frames.	Output

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

2.18. MI_VENC_RequestIdr¶

• Features

  Request an IDR frame.

• Syntax

  MI_S32 MI_VENC_RequestIdr(MI_VENC_CHN VeChn,MI_BOOL bInstant);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  bInstant	Whether to enable encoding of IDR frames immediately. 0: IDR frames are coded in the shortest possible time. 1: The next frame is an IDR frame.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • If the channel is not created, it returns a failure.

  • I Frame request, only support H.264/H.265Coding protocol.

  • Since this interface is not affected by frame rate control, an IDR will be encoded when call this interface. Frequent calls will affect the stability of frame rate and code rate.

• Example

  MI_S32 VencRequestIdr()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_CHN VeChn = 0;
  
      MI_BOOL bInstant;
  
      bInstant = TRUE;
  
      s32Ret = MI_VENC_RequestIdr(VeChn, bInstant);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_RequestIDR err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.19. MI_VENC_EnableIdr¶

• Features

  Whether to enable IDR frames.

• Syntax

  MI_S32 MI_VENC_EnableIdr(MI_VENC_CHN VeChn,MI_BOOL bEnableIdr);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  bEnableIDR	Whether the flag is enabled.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Note

  • If the channel is not created, it returns a failure.

  • If not enabled IDR Frame, it will not be edited after the next frame IDR Frame or I Frame until it is enabled again.

  • This interface only supports H.264/H.265 Coding protocol.

• Example

  MI_S32 VencEnableIdr()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_CHN VeChn = 0;
  
      s32Ret = MI_VENC_EnableIdr(VeChn);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_EnableIdr err0x%x\n",s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.20. MI_VENC_SetH264IdrPicId¶

• Features

  Set the idr_pic_id attribute of the IDR frame.

• Syntax

  MI_S32 MI_VENC_SetH264IdrPicId(MI_VENC_CHN
  VeChn,MI_VENC_H264IdrPicIdCfg_t *pstH264eIdrPicIdCfg);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstH264IdrPicIdCfg	The parameter pointer to idr_pic_id.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • If the channel is not created, it returns a failure.

  • Idr_pic_id The parameters are mainly determined by two parameters:

  • enH264eIdrPicIdMode: Settings IDR frame Idr_pic_id Mode, enH264eIdrPicIdMode = E_MI_VENC_H264E_IDR_PIC_ID_MODE_AUTO Representation generated automatically by the internal process of the code Idr_pic_id, enH264eIdrPicIdMode=E_MI_VENC_H264E_IDR_PIC_ID_MODE_USR Indicates that the user is set Idr_pic_id Value.

  • u32H264eIdrPicId: Settings IDR frame Idr_pic_id value. This value is valid only when enH264eIdrPicIdMode = E_MI_VENC_H264E_IDR_PIC_ID_MODE_USR.

  • Setting IDR Framed Idr_pic_id, only supported H.264 Coding protocol.

  • This interface can be called after the channel is created and before the code channel is destroyed. Take effect before the next frame starts encoding. This interface allows multiple calls. It is recommended to set the encoding before starting the encoding. It is not recommended to dynamically adjust during the encoding process.

  • Not supported yet.

2.21. MI_VENC_GetH264IdrPicId¶

• Features

  Get the configuration attribute of the idr_pic_id of the IDR frame.

• Syntax

  MI_S32 MI_VENC_GetH264IdrPicId(MI_VENC_CHN
  VeChn,MI_VENC_H264IdrPicIdCfg_t*pstH264eIdrPicIdCfg);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstH264eIdrPicIdCfg	The parameter pointer to idr_pic_id.	Output

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • If the channel is not created, it returns a failure.

  • This interface can be called after the channel is created and before the code channel is destroyed.

  • Not supported yet.

2.22. MI_VENC_GetFd¶

• Features

  Get the device file handle corresponding to the encoding channel. It will be called before calling select/poll to listen for encoded data, thereby reducing CPU usage compared to polling.

• Syntax

  MI_S32 MI_VENC_GetFd(MI_VENC_CHN VeChn);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Example

  See the example in MI_VENC_GetStream .

2.23. MI_VENC_CloseFd¶

• Features

  Close the device file handle corresponding to the encoding channel.

• Syntax

  MI_S32 MI_VENC_CloseFd(MI_VENC_CHN VeChn);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Video encoding channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

2.24. MI_VENC_SetRoiCfg¶

• Features

  Set the ROI attribute of the H.264/H.265 channel.

• Syntax

  MI_S32 MI_VENC_SetRoiCfg(MI_VENC_CHN
  VeChn,MI_VENC_RoiCfg_t *pstVencRoiCfg);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstVencRoiCfg	ROI area parameters.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Chip Difference

  Different chip and coding protocols have different restrictions on ROI parameters, as shown in the following table:

  Chip	Codec	Alignment				bAbsQp
  		u32Left	u32Top	u32Width	u32Height	AbsQp	RelQP
  Pretzel	H.264	16	16	16	16	[12,48]	[-7,7]
  	H.265	32	32	32	32	[12,48]	[-7,7]
  Macaron	H.264	16	16	16	16	[12,48]	[-7,7]
  	H.265	32	32	32	32	[12,48]	[-7,7]
  Pudding	H.264	16	16	16	16	No support	[-32,31]
  	H.265	32	32	32	32	No support	[-32,31]
  Ispahan	H.264	16	16	16	16	No support	[-32,31]
  	H.265	32	32	32	32	No support	[-32,31]
  Tiramisu	H.264	16	16	16	16	No support	[-32,31]
  	H.265	32	32	32	32

• Note

  • This interface is used to set H.264/H.265 Protocol coding channel ROI Regional parameters, ROI Mainly by parameters 5 Parameter decision.

  • u32Index: System supports each channel to be set 8 One ROI Area, inside the system 0 ~ 7 Index number pair ROI Regional management, u32Index User settings indicated ROI Index number. ROI Areas can be superimposed on each other, and when overlays occur, ROI Priority between regions according to index number 0 ~ 7 Increase in turn.

  • bEnable: specify the current ROI Whether the area is enabled.

  • bAbsQp: specify the current ROI absolute use of the area QP Way or relative QP.

  • s32Qp: when bAbsQp for True Time, s32Qp Express ROI All macroblocks within the region are used QP Value, when bAbsQp for False Time, s32Qp Express ROI Relative to all macroblocks within the region QP value.

  • tRect: specify the current ROI The position coordinates of the area and size of the area. ROI starting point coordinates of the area must be within the image range.

  • This interface belongs to the advanced interface. The system does not have a default. ROI The zone is enabled and the user must call this interface to start ROI.

  • This interface can be set before the code channel is destroyed after the code channel is created. This interface takes effect when the next frame is called when it is called during encoding.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • It is recommended that the user call before calling this interface. MI_VENC_GetRoiCfg Interface, get the current channel ROI Configure and then set it up.

• Example

  MI_S32 VencSetRoi()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_RoiCfg_t stRoiCfg;
  
      MI_S32 index=0;
  
      MI_VENC_CHN VeChnId=0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetRoiCfg(VeChnId, index, &stRoiCfg);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetRoiCfg err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stRoiCfg.bEnable = TRUE;
  
      stRoiCfg.bAbsQp = FALSE;
  
      stRoiCfg.s32Qp = 10;
  
      stRoiCfg.stRect.u32Left = 16;
  
      stRoiCfg.stRect.u32Top = 16;
  
      stRoiCfg.stRect.u32Width = 16;
  
      stRoiCfg.stRect.u32Height = 16;
  
      stRoiCfg.u32Index = 0;
  
      s32Ret = MI_VENC_SetRoiCfg(VeChnId, &stRoiCfg);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetRoiCfg err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.25. MI_VENC_GetRoiCfg¶

• Features

  Get the Roi configuration properties of the H.264/H.265 channel.

• Syntax

  MI_S32 MI_VENC_GetRoiCfg(MI_VENC_CHN VeChn,MI_U32
  u32Index,MI_VENC_RoiCfg_t *pstVencRoiCfg);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  u32Index	H.264 protocol encoding channel ROI region index.	Input
  pstVencRoiCfg	Corresponds to the configuration of the ROI area.	Output

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • This interface is used to obtain H.264 Protocol coding channel Index of ROI Configuration.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  Please refer to MI_VENC_GetRoiCfg Example.

2.26. MI_VENC_SetRoiBgFrameRate¶

• Features

  Set the non-ROI area frame rate attribute of the H.264/H.265 channel.

• Syntax

  MI_S32 MI_VENC_SetRoiBgFrameRate(MI_VENC_CHN
  VeChn,MI_VENC_RoiBgFrameRate_t *pstRoiBgFrmRate);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstRoiBgFrmRate	Non-ROI area frame rate control parameters.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • This interface is used to set H.264 Protocol coding channel ROI The parameters of the area frame rate control.

  • This interface must be enabled before it can be called. ROI region.

  • This interface belongs to the advanced interface. The system is not enabled by default. ROI The area frame rate attribute, the user must call this interface to enable.

  • This interface can be set before the code channel is destroyed after the code channel is created. This interface takes effect when the next frame is called when it is called during encoding.

  • Input frame rate when setting channel frame rate control attribute SrcFrmRate Greater than the output frame rate DstFrmRate And DstFrmRate greater or equal to 0 Or at the same time -1.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • It is recommended that the user call MI_VENC_GetRoiBgFrameRate interface before calling this interface.

  • Get the current channel's non ROI Regional frame rate configuration, and then set.

  • For non ROI, the frame rate of the area is lower than ROI Frame skipping or Svc-t coding. Frame skip reference or Svc-t Encoding, if set is not ROI The frame rate of the area is lower than ROI Area, the actual coded non ROI The regional target frame rate may be greater than the user configured target frame rate because Base Non-layer ROI Area cannot be encoded as Pskip Piece. For example, before calling this interface to set the frame rate ratio of non ROI area to 2:1, MI_VENC_SetRefParam is also called to set the long reference frame, which will result in the actual frame rate ratio of non ROI area being less than 2:1.

• Example

  MI_S32 VencSetRoiFrameRate()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_RoiBgFrameRate_t stRoiBgFrameRate;
  
      MI_S32 index = 0;
  
      MI_VENC_CHN VeChnId=0;
  
      //...omit other thing
  
      stRoiBgFrameRate.s32SrcFrmRate=30;
  
      stRoiBgFrameRate.s32DstFrmRate=15;
  
      s32Ret = MI_VENC_SetRoiBgFrameRate(VeChnId, &stRoiBgFrameRate);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetRoiBgFrameRate err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.27. MI_VENC_GetRoiBgFrameRate¶

• Features

  Get the non-Roi area frame rate configuration attribute of the H.264/H.265 channel.

• Syntax

  MI_S32 MI_VENC_GetRoiBgFrameRate(MI_VENC_CHN
  VeChn,MI_VENC_RoiBgFrameRate_t *pstRoiBgFrmRate);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstRoiBgFrmRate	Configuration of non-ROI area frame rate.	Output

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  Please refer to MI_VENC_SetRoiBgFrameRate Example.

2.28. MI_VENC_SetH264SliceSplit¶

• Features

  Set the slice split attribute of the H.264 channel.

• Syntax

  MI_S32 MI_VENC_SetH264SliceSplit(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264SliceSplit_t *pstSliceSplit);
  

• Parameter

  Parameter name	Description	Input/Output
  VeChn	Code channel number. Value range: [0, VENC_MAX_CHN_NUM).	Input
  pstSliceSplit	H.264 code stream slice segmentation parameters.	Input

• Return Value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Requirement

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  • This interface is used to set H.264 Protocol encoding channel code stream segmentation

  • Slice Split attribute is mainly Two Parameter decision:

  • bSplitEnable: Whether the current frame is in progress Slice segmentation.

  • u32SliceRowCount: Slice Split according to the macro block line. u32SliceRowCount represents the number of lines of each splice in the image macro block. And when encoding to the last few lines of the image, insufficient u32SliceRowCount will occur when the remaining macroblock lines are divided into one Slice.

  • The default value of bSplitEnable is false. When bSplitEnable is set to true, the u32SliceRowCount macroblock row is used as a slice to encode separately. After each slice is encoded, the user can get the stream data of the slice. It is better not to set u32SliceRowCount too small. The smaller the u32SliceRowCount is, the more frequent the user receives the notification, the greater the system overhead, and the easier it is to cause bit stream output memory fragmentation,and reduce the use efficiency of the bit stream output memory.

  • It is recommended to call this interface after creating the channel and before starting the channel, to reduce the number of calls during the encoding process. It takes effect at the next frame.

  • It is recommended that the user call before calling this interface. MI_VENC_GetH264SliceSplit Interface, get the current channel SliceSplit Configure and then set it up.

• Example

  MI_S32 VencSetSliceSplit()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamH264SliceSplit_t stSlice;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetH264SliceSplit(VeChnId, &stSlice);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetH264SliceSplit err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stSlice.bSplitEnable = TRUE;
  
      stSlice.u32SliceRowCount = 8;
  
      s32Ret = MI_VENC_SetH264SliceSplit(VeChnId, &stSlice);
  
      if(MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetH264SliceSplit err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.29. MI_VENC_GetH264SliceSplit¶

• Description

  Get the slice split attribute of the H.264 channel

• Prototype

  MI_S32 MI_VENC_GetH264SliceSplit(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264SliceSplit_t *pstSliceSplit);
  

• parameters

  parameter name	Description	input/output
  VeChn	Enocode channel number.. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstSliceSplit	H.264 stream slice splite parameters.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the slice segmentation attribute of the H.264 protocol encoding channel.

  • This interface can be called before the encoding channel is destroyed and after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding and after creating the channel, reducing the number of calls during the encoding process

• Example

  See the example of MI_VENC_SetH264SliceSplit

2.30. MI_VENC_SetH264InterPred¶

• Description

  Set the inter prediction property of the H.264 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetH264InterPred(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264InterPred_t *pstH264InterPred);
  

• parameters

  Parameter Name	Description	Input/Output
  VeChn	Encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264InterPred	Inter-prediction configuration of the H.264 protocol encoding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the interframe prediction configuration of the H.264 protocol encoding channel.

  • The properties of inter prediction are mainly determined by seven parameters:

  • u32HWSize: the size of the horizontal search window when inter prediction.

  • u32VWSize: The size of the vertical search window for inter prediction.

  • bInter16x16PredEn: 16x16 block inter prediction enable flag.

  • bInter16x8PredEn: 16x8 block inter prediction enable flag.

  • bInter8x16PredEn: 8x16 block inter prediction enable flag.

  • bInter8x8PredEn: 8x8 block inter prediction enable flag.

  • bExtedgeEn: Interframe prediction expansion search enable. When inter-prediction is performed on a macroblock on an image boundary, the range of the search window may exceed the boundary of the image. At this time, the expansion search enables the image to be expanded and inter-frame predicted. If the extended search enable is turned off, no prediction will be made for search windows that are outside the range of the image.

  • This interface belongs to the advanced interface, which can be called by the user. It is recommended not to call, and the system will have default values. The default search window size will vary depending on the resolution of the image, and the other five predictive enable switches are all enabled by default.

  • The predictive switch of bInter16x16PredEn can only be turned on.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process

  • Users are advised before calling this interface, first call MI_VENC_GetH264InterPred interface configured to obtain InterPred current channel coding, and then set it.

• Example

  MI_S32 VencSetInterPred()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamH264InterPred_t stInterPred;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetH264InterPred(VeChnId, &stInterPred);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetH264InterPred err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stInterPred.bExtedgeEn = TRUE;
  
      stInterPred.bInter16x16PredEn = TRUE;
  
      stInterPred.bInter16x8PredEn = FALSE;
  
      stInterPred.bInter8x16PredEn = FALSE;
  
      stInterPred.bInter8x8PredEn = FALSE;
  
      stInterPred.u32HWSize = 4;
  
      stInterPred.u32VWSize = 2;
  
      s32Ret = MI_VENC_SetH264InterPred(VeChnId, &stInterPred);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetH264InterPred err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.31. MI_VENC_GetH264InterPred¶

• Description

  Obtain the inter prediction property of the H.264 protocol coding channel.

• Prototype

  MI_S32 MI_VENC_GetH264InterPred(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264InterPred_t *pstH264InterPred);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264InterPred	Inter-prediction parameters of the H.264 protocol coding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the interframe prediction mode of the H.264 protocol coding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH264InterPred.

2.32. MI_VENC_SetH264IntraPred¶

• Description

  Set the intra prediction property of the H.264 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetH264IntraPred(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264IntraPred_t *pstH264IntraPred);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264IntraPred	Intra prediction configuration of the H.264 protocol coding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the intra prediction configuration of the H.264 protocol encoding channel.

  • The inter-prediction attribute is mainly determined by four parameters:

  • bIntra16x16PredEn: 16x16 block intra prediction enable flag.

  • bIntraNxNPredEn: NxN block intra prediction enable flag. Among them, NxN means 4x4 and 8x8.

  • bIpcmEn: IPCM block intra prediction enable flag.

  • constrained_intra_pred_flag: For the specific meaning, please refer to the H.264 protocol.

  • This interface is a high-level interface that can be called by the user. It is not recommended to call. The system has default values. bIntra16x16PredEn and bIntraNxNPredEn are enabled by default. bIpcmEn has different default values ​​for different chips. Constrained_intra_pred_flag defaults to 0

  • There must be one of the two intra prediction enable switches, bIntra16x16PredEn and bIntraNxNPredEn, and the system does not support that all two switches are turned off.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next I frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • It is recommended that the user call the MI_VENC_GetH264IntraPred interface to obtain the IntraPred configuration of the current encoding channel before calling this interface, and then set it.

• Example

  MI_S32 VencSetIntraPred()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamH264IntraPred_t stIntraPred;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetH264IntraPred(VeChnId, &stIntraPred);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetH264IntraPred err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stIntraPred.bIntra16x16PredEn = TRUE;
  
      stIntraPred.bIntraNxNPredEn = FALSE;
  
      stIntraPred.bIpcmEn = FALSE;
  
      stIntraPred.constrained_intra_pred_flag = 0;
  
      s32Ret = MI_VENC_SetH264IntraPred(VeChnId, &stIntraPred);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetH264IntraPred err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.33. MI_VENC_GetH264IntraPred¶

• Description

  Get the intra prediction attribute of the H.264 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_GetH264IntraPred(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264IntraPred_t *pstH264IntraPred);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264IntraPred	Intra prediction parameters of the H.264 protocol coding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the intra prediction mode of the H.264 protocol coding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH264IntraPred.

2.34. MI_VENC_SetH264Trans¶

• Description

  Set the transform and quantized attributes of the H.264 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetH264Trans(MI_VENC_CHN
  VeChn, MI_VENC_ParamH264Trans_t *pstH264Trans);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264Trans	The transform and quantization attributes of the H.264 protocol coding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: mi_venc.ko, libmi_venc.so

• note

  • This interface is used to set the transformation and quantization configuration of the H.264 protocol encoding channel.

  • Transform, quantization property mainly by three parameters.

  • u32IntraTransMode: The transform attribute of the intra prediction macroblock. This is a reserved interface that is currently not supported.

  • u32InterTransMode: The transform attribute of the inter prediction macroblock. This is a reserved interface that is currently not supported.

  • s32ChromaQpIndexOffset: For details, see the chroma_qp_index_offset of H.264 protocol.

  • This interface is a high-level interface that can be called by the user. It is not recommended to call this interface. The system has default values.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next I frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • Users are advised before calling this interface, first call MI_VENC_GetH264Trans interfaces, access to pre-coded channel when the trans configuration, and then set it.

• Example

  MI_S32 VencSetTrans()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamH264Trans_t stTrans;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetH264Trans(VeChnId, &stTrans);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetH264Trans err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stTrans.u32IntraTransMode = 2;
  
      stTrans.u32InterTransMode = 2;
  
      stTrans.s32ChromaQpIndexOffset = 2;
  
      s32Ret = MI_VENC_SetH264Trans(VeChnId, &stTrans);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetH264Trans err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.35. MI_VENC_GetH264Trans¶

• Description

  Obtain the transform and quantization attributes of the H.264 protocol coding channel.

• Prototype

  MI_S32 MI_VENC_GetH264Trans(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264Trans_t *pstH264Trans);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264Trans	The transform and quantization parameters of the H.264 protocol coding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the transform and quantization configuration of the H.264 protocol coding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH264Trans.

2.36. MI_VENC_SetH264Entropy¶

• Description

  Set the entropy coding mode of the H.264 protocol coding channel.

• Prototype

  MI_S32 MI_VENC_SetH264Entropy(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264Entropy_t *pstH264EntropyEnc);
  

• Parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264EntropyEnc	Entropy coding mode of the H.264 protocol coding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the entropy coding configuration of the H.264 protocol coding channel.

  • Transform quantization property mainly by two parameters:

  • u32EntropyEncModeI: entropy coding mode I frame, u32EntropyEncModeI = 0 indicates that the I-frame coding using cavlc, u32EntropyEncModeI = 1 indicates an I frame encoding cabac used.

  • u32EntropyEncModeP: entropy encoding of P frames, u32EntropyEncModeP = 0 indicates coding P frames use cavlc, u32EntropyEncModeP = 1 indicates P-frame coding using cabac.

  • The entropy coding mode of the I frame and the entropy coding mode of the P frame can be set separately.

  • Baselineprofile does not support cabac encoding, supports cavlc encoding, mainprofile and highprofile support cabac encoding and cavlc encoding.

  • The Cabac encoding method requires a larger amount of computation than the cavlc encoding method, but generates less code streams. If the system performance is not rich enough, it is recommended that users can take I frame cavlcencoding, P frame cabac encoding.

  • This interface is a high-level interface that can be called by the user. It is not recommended to call. The system has default values. The default parameters are set according to different profiles. The default entropy encoding parameters of the system under different profiles are shown in the table below.

    Profile	u32EntropyEncModeI	u32EntropyEncModeP
    Baseline	0	0
    Mainprofile/Highprofile	1	1

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next I frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • It is recommended that the user call the MI_VENC_GetH264Entropy interface to obtain the Entropy configuration of the current encoding channel before calling this interface, and then set it.

• Example

  MI_S32 VencSetEntropy()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamH264Entropy_t stEntropy;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetH264Entropy(VeChnId, &stEntropy);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetH264Entropy err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stEntropy.u32EntropyEncModeI = 0;
  
      stEntropy.u32EntropyEncModeP = 0;
  
      s32Ret = MI_VENC_SetH264Entropy(VeChnId, &stEntropy);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetH264Entropy err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.37. MI_VENC_GetH264Entropy¶

• Description

  Obtain the entropy encoding attribute of the H.264 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_GetH264Entropy(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264Entropy_t*pstH264EntropyEnc);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264EntropyEnc	The entropy coding attribute of the H.264 protocol coding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the entropy coding configuration of the H.264 protocol coding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH264Entropy

2.38. MI_VENC_SetH265InterPred¶

• Description

  Set the inter prediction property of the H.265 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetH265InterPred(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265InterPred_t *pstH265InterPred);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH265InterPred	Inter-prediction configuration of the H.265 protocol coding channel	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the interframe prediction configuration of the H.265 protocol encoding channel.

  • The properties of inter prediction are mainly determined by seven parameters:

  • u32HWSize: the size of the horizontal search window when inter prediction.

  • u32VWSize: The size of the vertical search window for inter prediction.

  • bInter16x16PredEn: 16x16 block inter prediction enable flag.

  • bInter16x8PredEn: 16x8 block inter prediction enable flag.

  • bInter8x16PredEn: 8x16 block inter prediction enable flag.

  • bInter8x8PredEn: 8x8 block inter prediction enable flag.

  • bExtedgeEn: Interframe prediction expansion search enable. When inter-prediction is performed on a macroblock on an image boundary, the range of the search window may exceed the boundary of the image. At this time, the expansion search enables the image to be expanded and inter-frame predicted. If the extended search enable is turned off, no prediction will be made for search windows that are outside the range of the image.

  • This interface belongs to the advanced interface, which can be called by the user. It is recommended not to call, and the system will have default values. The default search window size will vary depending on the resolution of the image, and the other five predictive enable switches are all enabled by default.

  • The predictive switch of bInter16x16PredEn can only be turned on.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

    Before calling this interface, users are advised to call MI_VENC_GetH265InterPred interface first to obtain InterPred current channel coding, and then set it.

• Example

  Please refer to the example of MI_VENC_SetH264InterPred

2.39. MI_VENC_GetH265InterPred¶

• Description

  Obtain the inter prediction property of the H.265 protocol coding channel.

• Prototype

  MI_S32 MI_VENC_GetH265InterPred(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265InterPred_t *pstH265InterPred);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH265InterPred	Inter-prediction parameters of the H.265 protocol coding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the inter-frame prediction mode of the H.265 protocol coding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH265InterPred

2.40. MI_VENC_SetH265IntraPred¶

• Description

  Set the intra prediction property of the H.265 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetH265IntraPred(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265IntraPred_t *pstH265IntraPred);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH265IntraPred	Intra prediction configuration of the H.265 protocol coding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the intra prediction configuration of the H.265 protocol encoding channel.

  • The intra-frame prediction is mainly determined by the properties of three parameters.

  • u32Intra32x32Penalty: The probability that 32 x 32 block intra prediction is selected. The larger the value, the lower the probability.

  • u32Intra16x16Penalty: The probability that 16 x 16 block intra prediction is selected. The larger the value, the lower the probability.

  • u32Intra8x8Penalty: 8 x 8 block intra prediction is selected probability, the larger the value, the lower the probability.

  • This interface is a high-level interface that can be called by the user. It is not recommended to call. The system has default values.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next I frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • It is recommended that the user call the MI_VENC_GetH265IntraPred interface to obtain the IntraPred configuration of the current encoding channel before calling this interface, and then set it.

• Example

  MI_S32 H265SetIntraPred()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamH265IntraPred_t stIntraPred;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetH265IntraPred(VeChnId, &stIntraPred);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetH265IntraPred err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stIntraPred.u32Intra32x32Penalty = 0;
  
      stIntraPred.u32Intra16x16Penalty = 0;
  
      stIntraPred.u32Intra8x8Penalty = 10;
  
      s32Ret = MI_VENC_SetH265IntraPred(VeChnId, &stIntraPred);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetH265IntraPred err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.41. MI_VENC_GetH265IntraPred¶

• Description

  Obtain the intra prediction attribute of the H.265 protocol coding channel.

• Prototype

  MI_S32 MI_VENC_GetH265IntraPred(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265IntraPred_t *pstH265IntraPred);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH265IntraPred	The intra prediction parameter of the H.265 protocol coding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the intra prediction mode of the H.265 protocol coding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH265IntraPred

2.42. MI_VENC_SetH265Trans¶

• Description

  Set the transform and quantized attributes of the H.265 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetH265Trans(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265Trans_t *pstH265Trans);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH265Trans	Transform and quantization attributes of the H.265 protocol coding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the conversion and quantization configuration of the H.265 protocol encoding channel.

  • Transform, quantization property mainly by three parameters.

  • u32IntraTransMode: The transform attribute of the intra prediction macroblock. This is a reserved interface that is currently not supported.

  • u32InterTransMode: The transform attribute of the inter prediction macroblock. This is a reserved interface that is currently not supported.

  • s32ChromaQpIndexOffset: For details, see the slice_cb_qp_offset and slice_cr_qp_offset of H.265 protocol.

  • This interface is a high-level interface that can be called by the user. It is not recommended to call this interface. The system has default values.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next I frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • It is recommended that the user call the MI_VENC_GetH265Trans interface before calling this interface.

• Example

  MI_S32 H265SetTrans()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamH265Trans_t stTrans;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetH265Trans(VeChnId, &stTrans);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetH265Trans err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stTrans.u32IntraTransMode = 2;
  
      stTrans.u32InterTransMode = 2;
  
      stTrans.s32ChromaQpIndexOffset = 2;
  
      s32Ret = MI_VENC_SetH265Trans(VeChnId, &stTrans);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetH265Trans err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.43. MI_VENC_GetH265Trans¶

• Description

  Obtain the transform and quantization attributes of the H.265 protocol coding channel.

• Prototype

  MI_S32 MI_VENC_GetH265Trans(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265Trans_t *pstH265Trans);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0, VENC_MAX_CHN_NUM).	input
  pstH265Trans	The transform and quantization parameters of the H.265 protocol coding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the transform and quantization configuration of the H.265 protocol coding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH265Trans

2.44. MI_VENC_SetH264Dblk¶

• Description

  Set the Deblocking type of the H.264 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetH264Dblk(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264Dblk_t *pstH264Dblk);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0, VENC_MAX_CHN_NUM).	input
  pstH264Dblk	Deblocking parameter of the H.264 protocol encoding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the Deblocking configuration of the H.264 protocol encoding channel.

  • The transform and quantization attributes are mainly composed of three parameters:

  • disable_deblocking_filter_idc: For details, see the H.264 protocol.

  • Slice_alpha_c0_offset_div2: For details, see the H.264 protocol.

  • Slice_beta_offset_div2: See the H.264 protocol for the specific meaning.

  • The system disables the deblocking function by default. The default disable_deblocking_filter_idc=0, slice_alpha_c0_offset_div2=0, slice_beta_offset_div2=0.

  • If the user wants to turn off the deblocking function, set disable_deblocking_filter_idc to 1.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • It is recommended that the user call the MI_VENC_GetH264Dblk interface before calling this interface to get the Dblk configuration and then set.

• Example

  MI_S32 VencSetDblk()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamH264Dblk_t stDblk;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetH264Dblk(VeChnId, &stDblk);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetH264Dblk err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stDblk.disable_deblocking_filter_idc = 0;
  
      stDblk.slice_alpha_c0_offset_div2 = 6;
  
      stDblk.slice_beta_offset_div2 = 5;
  
      s32Ret = MI_VENC_SetH264Dblk(VeChnId,&stDblk);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetH264Dblk err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.45. MI_VENC_GetH264Dblk¶

• Description

  Get the dblk type of the H.264 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_GetH264Dblk(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264Dblk_t *pstH264Dblk);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264Dblk	The dblk attribute of the H.264 protocol encoding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the dblk configuration of the H.264 protocol encoding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH264Dblk

2.46. MI_VENC_SetH265Dblk¶

• Description

  Set the Deblocking type of the H.265 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetH265Dblk(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265Dblk_t *pstH265Dblk);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH265Dblk	H.265 Deblocking parameters of the protocol coding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the channel coding H.265 protocol configuration Deblocking

  • The transform and quantization attributes are mainly composed of three parameters:

  • disable_deblocking_filter_idc: For details, see the slice_deblocking_filter_disabled_flag of H.265 Protocol.

  • slice_tc_offset_div2: For details, see H.265 Protocol.

  • slice_beta_offset_div2: For details, see H.265 protocol.

  • The system disables the deblocking function by default. The default disable_deblocking_filter_idc=0, slice_tc_offset_div2=0, slice_beta_offset_div2=0.

  • If the user wants to turn off the deblocking function, set disable_deblocking_filter_idc to 1.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • It is recommended that the user call the MI_VENC_GetH265 Dblk interface to get the Dblk configuration before calling this interface.

• Example

  See MI_VENC_SetH264Dblk Example.

2.47. MI_VENC_GetH265Dblk¶

• Description

  Get the dblk type of the H.265 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_GetH265Dblk(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265Dblk_t *pstH265Dblk);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH265Dblk	H.265 dblk channel coding protocol attributes.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the dblk configuration of the H.265 protocol encoding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH264Dblk

2.48. MI_VENC_SetH264Vui¶

• Description

  Set the vui parameter of the H.264 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetH264Vui(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264Vui_t *pstH264Vui);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264Vui	The Vui parameter of the H.264 protocol encoding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the VUI configuration of the H.264 protocol encoding channel.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next I frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • Users are advised before calling this interface, first call MI_VENC_GetH264Vui interface to get the current channel coding Vui configuration, and then set it.

• Example

  MI_S32 SetVui()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamH264Vui_t stVui;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetH264Vui(VeChnId, &stVui);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetH264Vui err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stVui.stVuiTimeInfo.u8TimingInfoPresentFlag = 1;
  
      s32Ret = MI_VENC_SetH264Vui(VeChnId,&stVui);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetH264Vui err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.49. MI_VENC_GetH264Vui¶

• Description

  Obtain the Vui configuration of the H.264 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_GetH264Vui(MI_VENC_CHN
  VeChn,MI_VENC_ParamH264Vui_t *pstH264Vui);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH264Vui	The Vui attribute of the H.264 protocol encoding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the Vui configuration of the H.264 protocol encoding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH264Vui

2.50. MI_VENC_SetH265Vui¶

• Description

  Set the vui parameter of the H.265 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetH265Vui(MI_VENC_CHN VeChn,
  MI_VENC_ParamH265Vui_t *pstH265Vui);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH265Vui	H.265 Vui parameters of the protocol coding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the VUI configuration of the H.265 protocol encoding channel.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it takes effect until the next I frame.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • It is recommended that the user call the MI_VENC_GetH265 Vui interface before calling this interface to obtain the Vui configuration of the current encoding channel, and then set it.

• Example

  See the example of MI_VENC_SetH264Vui Example

2.51. MI_VENC_GetH265Vui¶

• Description

  Obtain the Vui configuration of the H.265 protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_GetH265Vui(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265Vui_t *pstH265Vui);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstH265Vui	H.265 Vui attribute of the protocol encoding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the Vui configuration of the H.264 5 protocol encoding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH264Vui

2.52. MI_VENC_SetH265SliceSplit¶

• Description

  Set the slice split attribute of H.265 channels.

• Prototype

  MI_S32 MI_VENC_SetH265SliceSplit(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265SliceSplit_t *pstSliceSplit);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstSliceSplit	H.265 code stream slice segmentation parameters.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set the split mode of the H.265 protocol coded channel code stream.

  • Slice dividing property consists of two decision parameters.

  • bSplitEnable: whether the current frame slice division.

  • u32SliceRowCount: The slice is split according to the macro block line. u32SliceRowCount indicates that each slice occupies the number of image macroblock lines. And when encoding to the last few lines of the image, less than u32SliceRowCount, the remaining macroblock lines are divided into a slice.

  • This interface belongs to the advanced interface. The user can call it selectively. It is recommended not to call. The default bSplitEnable is false. This interface can be set before the code channel is destroyed after the code channel is created. This interface takes effect when the next frame is called when it is called during encoding.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • It is recommended that the user call the MI_VENC_GetH265 SliceSplit interface to obtain the sliceplit configuration of the current channel before calling this interface, and then set it.

• Example

  See the example of MI_VENC_SetH264SliceSplit

2.53. MI_VENC_GetH265SliceSplit¶

• Description

  Get the slice split attribute of H.265 channel.

• Prototype

  MI_S32 MI_VENC_GetH265SliceSplit(MI_VENC_CHN
  VeChn,MI_VENC_ParamH265SliceSplit_t*pstSliceSplit);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstSliceSplit	H.265 code stream slice segmentation parameters.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the slice split attribute of the H.265 protocol code channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetH264SliceSplit

2.54. MI_VENC_SetJpegParam¶

• Description

  Set advanced parameters for the JPEG protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_SetJpegParam(MI_VENC_CHN
  VeChn,MI_VENC_ParamJpeg_t  *pstJpegParam);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstJpegParam	A collection of advanced parameters for the JPEG protocol encoding channel.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to set advanced parameters of the JPEG protocol encoding channel.

  • The advanced parameters are mainly composed of 4 parameters:

  • u32Qfactor: The quantization table factor range is [1,99]. The larger the u32Qfactor is, the smaller the quantization coefficient in the quantization table is, the better the image quality will be, and the lower the compression ratio. Similarly the smaller the u32Qfactor is, the greater the quantization coefficients in the quantization table, the image quality will be obtained even worse, while a higher code compression rate. See the RFC2435 standard for the relationship between the specific u32Qfactor and the quantization table.

  • au8YQt [64], au8CbCrQt [64]: corresponding to two quantization table space, by which the user can two sets a quantization table of user parameters.

  • u32McuPerEcs: Each Ecs contains much Mcu. The system mode u32MCUPerECS=0 indicates that all MCUs of the current frame are encoded as one ECS. The minimum value of u32MCUPerECS is 0, and the maximum value does not exceed (picwidth+15)>>4x(picheight+15)>>4x2.

  • If you want to use your own quantization table, set the Qfactor to 50 while setting the quantization table.

  • This interface can be set before the code channel is destroyed after the code channel is created. When this interface is called during the encoding process, it will take effect when the next frame is encoded.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

  • Users are advised before calling this interface, first call MI_VENC_GetJpegParam interface to obtain when the front channel coding JpegParam configuration, and then set it.

• Example

  MI_S32 SetJpegParam()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamJpeg_t stParamJpeg;
  
      MI_VENC_CHN VeChnId = 0;
  
      int i;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetJpegParam(VeChnId, &stParamJpeg);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetJpegParam err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stParamJpeg.u32MCUPerEcs = 100;
  
      for (i = 0; i < 64; i++)
  
      {
  
          stParamJpeg.au8YQt[i] = 16;
  
          stParamJpeg.au8CbCrQt[i] = 17;
  
      }
  
      s32Ret=MI_VENC_SetJpegParam(VeChnId, &stParamJpeg);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetJpegParam err0x%x\n",s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      return s32Ret;
  
  }
  

2.55. MI_VENC_GetJpegParam¶

• Description

  Get the advanced parameter configuration of the JPEG protocol encoding channel.

• Prototype

  MI_S32 MI_VENC_GetJpegParam(MI_VENC_CHN
  VeChn,MI_VENC_ParamJpeg_t *pstJpegParam);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstJpegParam	Advanced parameter configuration of the Jpeg protocol encoding channel.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the advanced parameter configuration of the JPEG protocol encoding channel.

  • This interface can be called after the encoding channel is destroyed after the encoding channel is created.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

• Example

  See the example of MI_VENC_SetJpegParam

2.56. MI_VENC_SetRcParam¶

• Description

  Set advanced parameters for the code channel rate controller.

• Prototype

  MI_S32 MI_VENC_SetRcParam(MI_VENC_CHN
  VeChn,MI_VENC_RcParam_t *pstRcParam);
  

• parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstRcParam	Advanced parameters for encoding channel rate controllers.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Chip Difference

  The rate control algorithms supported by different chips and different coding protocols are different, as shown in the following table:

  Chip	H.264	H.265	JPEG
  Pretzel	FIXQP/CBR/VBR	FIXQP/CBR/VBR	FIXQP/CBR
  Macaron	FIXQP/CBR/VBR	FIXQP/CBR/VBR	FIXQP/CBR
  Pudding	FIXQP/CBR/VBR/AVBR	FIXQP/CBR/VBR/AVBR	FIXQP/CBR
  Ispahan	FIXQP/CBR/VBR/AVBR	FIXQP/CBR/VBR/AVBR	FIXQP/CBR
  Tiramisu	FIXQP/CBR/VBR/AVBR	FIXQP/CBR/VBR/AVBR	FIXQP/CBR

• note

  • The advanced parameters of the coded channel rate controller have default values, rather than having to call this interface to start the code channel.

  • It is recommended that the user first call the MI_VENC_GetRcParam interface to obtain the RC advanced parameters, then modify the corresponding parameters, and then call this interface to set the advanced parameters.

  • The RC advanced parameters now only support H.264/H.265/Mjpeg rate control modes.

  • The advanced parameters of the rate controller consist of the following parameters: u32ThrdI[ RC_TEXTURE_THR_SIZE ], u32ThrdP[ RC_TEXTURE_THR_SIZE ]: A set of thresholds for measuring the macroblock complexity of I frames and P frames, respectively. The thresholds are arranged in order from small to large, and each threshold has a value range of [0, 255]. This set of thresholds is used to appropriately adjust the Qp of each macroblock according to image complexity when performing macroblock level rate control. For H.264, the macroblock level rate control only adds direction (maximum plus 12 ), that is, if the image complexity of the current macroblock is between some two thresholds, the Qp value of the current macroblock starts at the macroblock line. Qp based on adding value X.

    The value of X is shown in the following table (C represents image complexity):

    C Range	x
    C<=u32Thrd[0]	0
    u32Thrd[0]< C<=u32Thrd[1]	1
    u32Thrd[1]< C<=u32Thrd[2]	2
    u32Thrd[2]< C<=u32Thrd[3]	3
    u32Thrd[3]< C<=u32Thrd[4]	4
    u32Thrd[4]< C<=u32Thrd[5]	5
    u32Thrd[5]< C<=u32Thrd[6]	6
    u32Thrd[6]< C<=u32Thrd[7]	7
    u32Thrd[7]< C<=u32Thrd[8]	8
    u32Thrd[8]< C<=u32Thrd[9]	9
    u32Thrd[9]< C<=u32Thrd[10]	10
    u32Thrd[10]< C<=u32Thrd[11]	11
    u32Thrd[11]< C	12

    For H.265, macroblock The code rate control has both the plus direction (maximum plus 8) and the minus direction (maximum minus 4 ), that is, if the image complexity of the current macroblock is less than or equal to the u32Thr[3] threshold, the Qp value of the current macroblock is in the macro. Block rows starting Qp subtracting the value on the basis of X ; If the current macroblock image complexity is greater than u32Thr [3] the threshold value, the current macroblock Qp value is a macroblock row starting Qp based on adding value y. The values of X and Y are shown in the following table (C represents image complexity):

    C Range	x or y
    C< u32Thrd[0]	x=4
    u32Thrd[0]<=C< u32Thrd[1]	x=3
    u32Thrd[1]<=C< u32Thrd[2]	x=2
    u32Thrd[2]<=C< u32Thrd[3]	x=1
    u32Thrd[3]<=C<=u32Thrd[4]	x=y=0
    u32Thrd[4]< C<=u32Thrd[5]	y=1
    u32Thrd[5]< C<=u32Thrd[6]	y=2
    u32Thrd[6]< C<=u32Thrd[7]	y=3
    u32Thrd[7]< C<=u32Thrd[8]	y=4
    u32Thrd[8]< C<=u32Thrd[9]	y=5
    u32Thrd[9]< C<=u32Thrd[10]	y=6
    u32Thrd[10]< C<=u32Thrd[11]	y=7
    u32Thrd[11]< C	y=8

  • u32RowQpDelta: The amplitude of the fluctuation of the starting QP of each row of macroblocks relative to the starting QP of the frame at the time of macroblock level rate control. For the next rate fluctuations more stringent scenario, this parameter can try to transfer large to achieve a more accurate rate control, but may cause image quality to the interior of the frame images have some difference different. At high bit rates, this value is recommended to be 0; the medium code rate is recommended to be 0 or 1; for low bit rates it is recommended to be 2 to 5.

  • The CBR parameters are as follows:

  • u32MinIprop&u32MaxIprop: CBR advanced parameters, which represent the minimum IP ratio and the maximum IP ratio. The IP ratio represents the ratio of the number of Bits of the I frame and the P frame. These two values ​​are used to clamp the range of IP ratios. When u32MinIprop is adjusted to be large, the I frame is clear and the P frame is blurred. When u32MaxIprop is adjusted to be small, the I frame is blurred and the P frame is clear. Under normal circumstances, it is not recommended to constrain the IP size ratio to avoid breathing effects and code rate fluctuations. The default u32MinIprop is set to 1 and u32MaxIprop is set to 20. In a scenario where the I frame size is constrained, u32MinIprop can be set according to the dependence on the I frame size fluctuation. And the value of u32MaxIprop.

  • u32MaxQp&u32MinQp&u32MaxStartQp: CBR advanced parameters, u32MaxQp, u32MinQp represent the maximum QP and minimum QP of the current frame. This clamp has the strongest effect, and all other adjustments to the imageQP, such as macroblock rate control, are ultimately constrained to this maximum QP and minimum QP. u32MaxStartQp represents the maximum QP of the frame-level rate control output, which is in the range [u32MinQp, u32MaxQp]. Macroblock level rate control may cause QPs of some macroblocks to be larger or smaller than u32MaxStartQp, but will be clamped to [u32MinQp, u32MaxQp]. The default value u32MinQp is 10, u32MaxQp is 51, andu32MaxStartQp is 51. It is recommended not to change this group of parameters without special requirements for quality.

  • u32MaxPPDeltaQp&u32MaxIPDeltaQp: The CBR advanced parameter indicates the maximum difference between the maximum difference between the starting Qp of two consecutive P frames and the starting QP of consecutive IP frames. When there is a large motion, scene switching, etc., the guaranteed code rate is stable, which may cause the QP difference between consecutive P frames to be too large, resulting in image mosaic, etc., and the QP changes can be clamped by adjusting these two parameters. Avoid image quality fluctuations. The default value of u32MaxPPDelta is 3 ; the default value of u32MaxIPdeltaQP is 5, which can be modified according to the difference between the quality and the code rate requirements.

  • s32IPQPDelta: CBR advanced parameter, which indicates the difference between the average QP value and the current I frame QP. This parameter can be negative. Can be used to adjust I frame oversize and breathing effects. The system default value is 2, increase this value, and the I frame becomes clear. u32RQRatio[8]: The CBR advanced parameter indicates the weight of the rate constant and the quality stability in the rate control. u32RQRatio[i]/100 represents the quality stability weight, 1-u32RQRatio[i]/100 represents the code rate stability weight, for example: u32RQRatio[i]=75, indicating that the quality is stable and accounts for 75% of the weight, code rate Stability accounts for 25% of the weight. CBR is provided. 8 scene modes, namely: Normal ( normal scenario ), the Move ( moving scene ), Still ( static scenario ), StillToMove ( static scene into motion ), MoveToStill ( sports scene brought to a standstill ), SceneSwitch ( scenes Switch ), SharpMove ( violent motion scene ), Init ( program initialization ), respectively correspond to the index number of 0 to 7 in u32RQRatio. The system default now is u32RQRatio[]={75,75,75,50,50,20,30,0}. Users can set the weight of the rate control in different scenarios to meet specific dependencies. For example, in a large sports scenario, the quality is stable at 30%, and the code rate is stable at 70%. Users can continue the quality ratio. Smaller, the rate fluctuations become smaller, reserved, not used.

  • The VBR parameters are as follows.

  • s32DeltaQP: The VBR advanced parameter indicates the maximum QP change between frames and frames during VBR quality fluctuations. This parameter can be used to prevent mosaics from appearing. The system defaults to 2.

  • s32ChangePos: VBR advanced parameter, which indicates the ratio of the code rate to the maximum code rate when VBR starts to adjust QP. The system defaults to 90. If the content changes drastically and the maximum bit rate is not exceeded, it is recommended to reduce this value and increase s32DeltaQP, but the code rate is small and the quality deviation is stable when the rate control is stable.

  • The AVBR parameters are as follows.

  • s32ChangePos: AVBR advanced parameter, which indicates the ratio of code rate to maximum code rate when AVBR starts to adjust QP. The default value of the system is 80. If the content changes drastically and the maximum bit rate is not exceeded, it is recommended to reduce this value and increase s32DeltaQP, but the code rate is small and the quality deviation is stable when the rate control is stable.

  • u32MaxQp&u32MinQp: AVBR advanced parameters, u32MaxQp and u32MinQp represent the maximum and minimum QP of the current frame. The clamping effect is the most powerful, and all other adjustments to image QP such as macroblock level rate control, will eventually be constrained to this maximum and minimum QP. The default value of u32MinQp is 12, and u32MaxQp is 48. If there is no special requirement for quality, it is not recommended to change this group of parameters.

  • u32MaxIQp&u32MinIQp: AVBR advanced parameters, u32MaxIQp and u32MinIQp represent the maximum and minimum QP of IDR frame in the current sequence. The clamping effect is the most powerful, and all other adjustment of image QP such as macroblock level rate control, will eventually be constrained to the maximum and minimum QP. If there is no special requirement for quality, it is not recommended to change this group of parameters.

  • u32MotionSensivity: AVBR advanced parameters for motion sensitivity. If this value is higher, it means the rate control will have faster response for motion info, but then it will be more sensitive to noise.

  • pRcParam: RC advanced parameters formulated by the user, reserved, not used at the moment.

  • It is recommended that the user call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process.

2.57. MI_VENC_GetRcParam¶

• Description

  Get the channel rate control advanced parameters.

• Prototype

  MI_S32 MI_VENC_GetRcParam(MI_VENC_CHN
  VeChn,MI_VENC_RcParam_t *pstRcParam);
  

• Parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstRcParam	Channel rate control parameter pointer.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain advanced parameters of the H.264 encoding channel rate control. The specific meaning of each parameter, please refer to MI_VENC_RcParam_t.

  • If pstRcParam is empty, it returns a failure.

• Example

  MI_S32 VencSetRcParam()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_RcParam_t stVencRcPara;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      s32Ret = MI_VENC_GetRcParam(VeChnId, &stVencRcPara);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_GetRcParam err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      stVencRcPara.stParamH264Cbr.s32IPQPDelta = 2;
  
      s32Ret = MI_VENC_SetRcParam(VeChnId, &stVencRcPara);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetRcParam err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      //...omit other thing
  
      return s32Ret;
  
  }
  

2.58. MI_VENC_SetRefParam¶

• Description

  Set the H.264/H.265 encoding channel advanced frame skipping reference parameters.

• Prototype

  MI_S32 MI_VENC_SetRefParam(MI_VENC_CHN
  VeChn,MI_VENC_ParamRef_t *pstRefParam)
  

• Parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0, VENC_MAX_CHN_NUM).	input
  pstRefParam	H.264/H.265 coding channel advanced frame skipping reference parameters.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • If pstRefParam is empty, it returns a failure.

  • Create H.264 / H.265 when channel coding protocol, the default mode is the reference frame skipping 1 times the reference frame skip mode. If the user needs to modify the frame skipping reference of the encoding channel, it is recommended to call this interface before starting the encoding after creating the channel, reducing the number of calls during the encoding process

  • When this interface is called during the encoding process, it takes effect until the next I frame.

  • If the user sets a time reference frame skip mode, the corresponding configuration is: bEnablePred = TRUE, u32Enhance = 0, u32Base = 1;

    if set 2 times the reference frame skip mode, the corresponding configuration is:bEnablePred = TRUE, u32Enhance = 1, u32Base = 1;

    if set 4 times the reference frame skip mode, the corresponding configuration is: bEnablePred = TRUE, u32Enhance = 3, u32Base = 1.

• Example

  MI_S32 VencSetRefParam()
  
  {
  
      MI_S32 s32Ret;
  
      MI_VENC_ParamRef_t stRefParam;
  
      MI_VENC_CHN VeChnId = 0;
  
      //...omit other thing
  
      stRefParam.u32Base = 1;
  
      stRefParam.u32Enhance = 3;
  
      stRefParam.bEnablePred = TRUE;
  
      s32Ret = MI_VENC_SetRefParam(VeChn, &stRefParam);
  
      if (MI_SUCCESS != s32Ret)
  
      {
  
          printf("MI_VENC_SetRefParam err0x%x\n", s32Ret);
  
          return E_MI_ERR_FAILED;
  
      }
  
      //...omit other thing
  
      return s32Ret;
  
  }
  

2.59. MI_VENC_GetRefParam¶

• Description

  Obtain the advanced frame skipping reference parameters of the H.264/H.265 coding channel.

• Prototype

  MI_S32 MI_VENC_GetRefParam(MI_VENC_CHN
  VeChn,MI_VENC_ParamRef_t *pstRefParam)
  

• Parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstRefParam	H.264/H.265 coding channel advanced frame skipping reference parameters.	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  If pstRefParam is empty, it returns a failure.

2.60. MI_VENC_SetCrop¶

• Description

  Set the crop properties of the channel.

• Prototype

  MI_S32 MI_VENC_SetCrop (VENC_CHNVeChn,
  MI_VENC_CropCfg_t *pstCropCfg)
  

• Parameters

  parameter name	Description	input/output
  VeChn	Channel number	input
  pstCropCfg	Channel cropping properties.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• Note

  The Crop alignment rules supported by different Chips are shown below:

  Chip	H.264	H.265	JPEG
  	CropWidth x CropHeight : CropLeft x CropTop	CropWidth x CropHeight : CropLeft x CropTop	CropWidth x CropHeight : CropLeft x CropTop
  Pretzel	8x2:16x16	8x2:16x16	8x2:256x16
  Macaron	8x2:16x16	8x2:16x16	8x2:256x16
  Pudding	8x2:16x16	8x2:16x16	8x2:256x16
  Ispahan	8x2:16x16	8x2:16x16	8x2:256x16
  Tiramisu	8x2:16x16	8x2:16x16	8x2:256x16

  • This interface is used to set the cropping properties of the channel.

  • This interface must be called after the channel is created and before the channel is destroyed.

  • The crop property consists of two parts:

    1. bEnable: Whether the channel cropping function is enabled.

    2. stRect: Crop area properties, including the coordinates of the starting point of the crop area, and the size of the crop area.

2.61. MI_VENC_GetCrop¶

• Description

  Get the crop properties of the channel.

• Prototype

  MI_S32 MI_VENC_GetCrop (MI_VENC_CHN VeChn,
  MI_VENC_CropCfg_t *pstCropCfg)
  

• Parameters

  parameter name	Description	input/output
  VeChn	Channel number	input
  pstCropCfg	Channel cropping properties	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • This interface is used to obtain the cropping properties of the channel.

  • This interface must be called after the channel is created and before the channel is destroyed.

2.62. MI_VENC_SetFrameLostStrategy¶

• Description

  Set the frame loss policy when the code channel instantaneous code rate exceeds the threshold.

• Prototype

  MI_S32 MI_VENC_SetFrameLostStrategy (MI_VENC_CHN VeChn,
  MI_VENC_ParamFrameLost_t *pstFrmLostParam)
  

• Parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0, VENC_MAX_CHN_NUM).	input
  pstFrmLostParam	The parameter of the code channel drop frame strategy.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  • If pstFrmLostParam is empty, it returns a failure.

  • pstFrmLostParam is mainly determined by four parameters.

  • enFrmLostMode: frame loss strategy mode.

  • u32EncFrmGaps: Drop frame interval.

  • bFrmLostOpen: Drop frame switch.

  • u32FrmLostBpsThr: Drop frame threshold.

  • This interface belongs to the advanced interface. The user can select it selectively. The system has default values. By default, the frame is dropped when the instantaneous code rate exceeds the threshold.

  • This interface provides two processing modes when the instantaneous bit rate exceeds the threshold: frame loss and encoding pskip frames. u32EncFrmGaps controls whether frames are evenly dropped or uniformly encoded pskip frames. As the figure below:

    T

    ->The instantaneous encoding frame rate does not exceed the threshold value, the frame and retained

    -> The frame where the instantaneous bit rate exceeds the threshold when the frame is encoded, and the dropped frame

    -> When the frame is encoded, the instantaneous code rate exceeds the threshold and is encoded as a pskip frame

    enFrmLostMode=E_MI_VENC_FRMLOST_NORMAL, u32EncFrmGaps=0

    enFrmLostMode=E_MI_VENC_FRMLOST_NORMAL, u32EncFrmGaps=1

    enFrmLostMode=E_MI_VENC_FRMLOST_PSKIP, u32EncFrmGaps=0

    enFrmLostMode=E_MI_VENC_FRMLOST_PSKIP, u32EncFrmGaps=1

  • This interface can be set before the code channel is destroyed after the code channel is created. This interface takes effect when the next frame is called when it is called during encoding.

2.63. MI_VENC_GetFrameLostStrategy¶

• Description

  Obtain the frame loss policy when the instantaneous code rate of the coding channel exceeds the threshold.

• Prototype

  MI_S32 MI_VENC_GetFrameLostStrategy(MI_VENC_CHN
  VeChn,MI_VENC_ParamFrameLost_t *pstFrmLostParam);
  

• Parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0, VENC_MAX_CHN_NUM).	input
  pstFrmLostParam	The parameter of the code channel drop frame strategy	output

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_common.h, mi_venc.h

  • Library file: libmi.a

• note

  If pstFrmLostParam is empty, it returns a failure.

2.64. MI_VENC_SetSuperFrameCfg¶

• Description

  Set the encoding jumbo frame configuration.

• Prototype

  MI_S32 MI_VENC_SetSuperFrameCfg(MI_VENC_CHN
  VeChn,MI_VENC_SuperFrameCfg_t *pstSuperFrmParam);
  

• Parameters

  parameter name	Description	input/output
  VeChn	encode channel number. Value range: [0,VENC_MAX_CHN_NUM).	input
  pstSuperFrmParam	Encode jumbo frame configuration parameters.	input

• Return value

  • MI_OK: Successful

  • Not MI_OK: Failed, see ERROR CODE for details.

• Dependence

  • Header files: mi_comm_rc.h, mi_venc.h

  • Library file: libmi.a

• note

  • If the channel is not created, it returns a failure.

  • This interface is a high-level interface that users can optionally call, the system defaults. The system default is eSuperFrmMode = E_MI_VENC_SUPERFRM_NONE.

  • This interface can be set before the code channel is destroyed after the code channel is created.

  • When super frame mode is E_MI_VENC_SUPERFRM_NONE , MI do nothing.

  • When super frame mode is E_MI_VENC_SUPERFRM_DISCARD, MI will discard the super frame and continue encoding the next frame.If the chip version is Macaron , Ispahan,MI will force to request I frame after discarding the super frame.

  • When super frame mode is E_MI_VENC_SUPERFRM_REENCODE,MI will increase the QP of the frame by 4 and reencode the super frame.If it still exceeds the threshold after repeating up to 4 times, MI will discard the frame.

    

  • Super frame processing is mainly to prevent the picture from getting stuck due to a certain frame being too large.The unit of threshold is bit.It is recommended to set it according to the actual scene.