mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-24 02:31:03 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/sys/qsv/libmfx/api/vpl/mfxstructures.h

4910 lines
277 KiB
C
Raw Blame History

/*############################################################################
# Copyright Intel Corporation
#
# SPDX-License-Identifier: MIT
############################################################################*/
#ifndef __MFXSTRUCTURES_H__
#define __MFXSTRUCTURES_H__
#include "mfxcommon.h"
#if !defined (__GNUC__)
#pragma warning(disable: 4201)
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Frame ID for MVC */
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! Describes the view and layer of a frame picture. */
typedef struct {
mfxU16 TemporalId; /*!< The temporal identifier as defined in the annex H of the ITU*-T H.264 specification. */
mfxU16 PriorityId; /*!< Reserved and must be zero. */
union {
struct {
mfxU16 DependencyId; /*!< Reserved for future use. */
mfxU16 QualityId; /*!< Reserved for future use. */
};
struct {
mfxU16 ViewId; /*!< The view identifier as defined in the annex H of the ITU-T H.264 specification. */
};
};
} mfxFrameId;
MFX_PACK_END()
/* This struct has 4-byte alignment for binary compatibility with previously released versions of API. */
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! Specifies properties of video frames. See also "Configuration Parameter Constraints" chapter. */
typedef struct {
mfxU32 reserved[4]; /*!< Reserved for future use. */
/*! The unique ID of each VPP channel set by application. It's required that during Init/Reset application fills ChannelId for
each mfxVideoChannelParam provided by the application and the SDK sets it back to the correspondent
mfxSurfaceArray::mfxFrameSurface1 to distinguish different channels. It's expected that surfaces for some channels might be
returned with some delay so application has to use mfxFrameInfo::ChannelId to distinguish what returned surface belongs to
what VPP channel. Decoder's initialization parameters are always sent through channel with mfxFrameInfo::ChannelId equals to
zero. It's allowed to skip setting of decoder's parameters for simplified decoding procedure */
mfxU16 ChannelId;
/*! Number of bits used to represent luma samples.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported. */
mfxU16 BitDepthLuma;
/*! Number of bits used to represent chroma samples.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported. */
mfxU16 BitDepthChroma;
/*! When the value is not zero, indicates that values of luma and chroma samples are shifted. Use BitDepthLuma and BitDepthChroma to calculate
shift size. Use zero value to indicate absence of shift. See example data alignment below.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported.
*/
mfxU16 Shift;
mfxFrameId FrameId; /*!< Describes the view and layer of a frame picture. */
mfxU32 FourCC; /*!< FourCC code of the color format. See the ColorFourCC enumerator for details. */
union {
struct { /* Frame parameters */
mfxU16 Width; /*!< Width of the video frame in pixels. Must be a multiple of 16. */
mfxU16 Height; /*!< Height of the video frame in pixels. Must be a multiple of 16 for progressive frame sequence and a multiple of 32 otherwise. */
/*! @{
@name ROI
The region of interest of the frame. Specify the display width and height in mfxVideoParam. */
mfxU16 CropX; /*!< X coordinate. */
mfxU16 CropY; /*!< Y coordinate. */
mfxU16 CropW; /*!< Width in pixels. */
mfxU16 CropH; /*!< Height in pixels. */
/*! @} */
};
struct { /* Buffer parameters (for plain formats like P8) */
mfxU64 BufferSize; /*!< Size of frame buffer in bytes. Valid only for plain formats (when FourCC is P8). In this case, Width, Height, and crop values are invalid. */
mfxU32 reserved5;
};
};
/*! @{
@name FrameRate
Specify the frame rate with the following formula: FrameRateExtN / FrameRateExtD.
For encoding, frame rate must be specified. For decoding, frame rate may be unspecified (FrameRateExtN and FrameRateExtD
are all zeros.) In this case, the frame rate is defaulted to 30 frames per second.
*/
mfxU32 FrameRateExtN; /*!< Frame rate numerator. */
mfxU32 FrameRateExtD; /*!< Frame rate denominator. */
/*! @} */
mfxU16 reserved3;
/*! @{
@name AspectRatio
AspectRatioW and AspectRatioH are used to specify the sample aspect ratio. If sample aspect ratio is explicitly defined by the standards (see
Table 6-3 in the MPEG-2 specification or Table E-1 in the H.264 specification), AspectRatioW and AspectRatioH should be the defined values.
Otherwise, the sample aspect ratio can be derived as follows:
@li @c AspectRatioW=display_aspect_ratio_width*display_height
@li @c AspectRatioH=display_aspect_ratio_height*display_width
For MPEG-2, the above display aspect ratio must be one of the defined values in Table 6-3 in the MPEG-2 specification. For H.264, there is no restriction
on display aspect ratio values.
If both parameters are zero, the encoder uses the default value of sample aspect ratio.
*/
mfxU16 AspectRatioW; /*!< Aspect Ratio for width. */
mfxU16 AspectRatioH; /*!< Aspect Ratio for height. */
/*! @} */
mfxU16 PicStruct; /*!< Picture type as specified in the PicStruct enumerator. */
mfxU16 ChromaFormat; /*!< Color sampling method. Value is the same as that of ChromaFormatIdc.
ChromaFormat is not defined if FourCC is zero.*/
mfxU16 reserved2;
} mfxFrameInfo;
MFX_PACK_END()
/*! The ColorFourCC enumerator itemizes color formats. */
enum {
MFX_FOURCC_NV12 = MFX_MAKEFOURCC('N','V','1','2'), /*!< NV12 color planes. Native format for 4:2:0/8b Gen hardware implementation. */
MFX_FOURCC_YV12 = MFX_MAKEFOURCC('Y','V','1','2'), /*!< YV12 color planes. */
MFX_FOURCC_NV16 = MFX_MAKEFOURCC('N','V','1','6'), /*!< 4:2:2 color format with similar to NV12 layout. */
MFX_FOURCC_YUY2 = MFX_MAKEFOURCC('Y','U','Y','2'), /*!< YUY2 color planes. */
MFX_FOURCC_RGB565 = MFX_MAKEFOURCC('R','G','B','2'), /*!< 2 bytes per pixel, uint16 in little-endian format, where 0-4 bits are blue, bits 5-10 are green and bits 11-15 are red. */
/*! RGB 24 bit planar layout (3 separate channels, 8-bits per sample each). This format should be mapped to D3DFMT_R8G8B8 or VA_FOURCC_RGBP. */
MFX_FOURCC_RGBP = MFX_MAKEFOURCC('R','G','B','P'),
MFX_DEPRECATED_ENUM_FIELD_INSIDE(MFX_FOURCC_RGB3) = MFX_MAKEFOURCC('R','G','B','3'), /* Deprecated. */
MFX_FOURCC_RGB4 = MFX_MAKEFOURCC('R','G','B','4'), /*!< RGB4 (RGB32) color planes. BGRA is the order, 'B' is 8 MSBs, then 8 bits for 'G' channel, then 'R' and 'A' channels. */
/*!
Internal color format. The application should use the following functions to create a surface that corresponds to the Direct3D* version in use.
For Direct3D* 9: IDirectXVideoDecoderService::CreateSurface()
For Direct3D* 11: ID3D11Device::CreateBuffer()
*/
MFX_FOURCC_P8 = 41,
/*!
Internal color format. The application should use the following functions to create a surface that corresponds to the Direct3D* version in use.
For Direct3D 9: IDirectXVideoDecoderService::CreateSurface()
For Direct3D 11: ID3D11Device::CreateTexture2D()
*/
MFX_FOURCC_P8_TEXTURE = MFX_MAKEFOURCC('P','8','M','B'),
MFX_FOURCC_P010 = MFX_MAKEFOURCC('P','0','1','0'), /*!< P010 color format. This is 10 bit per sample format with similar to NV12 layout. This format should be mapped to DXGI_FORMAT_P010. */
MFX_FOURCC_P016 = MFX_MAKEFOURCC('P','0','1','6'), /*!< P016 color format. This is 16 bit per sample format with similar to NV12 layout. This format should be mapped to DXGI_FORMAT_P016. */
MFX_FOURCC_P210 = MFX_MAKEFOURCC('P','2','1','0'), /*!< 10 bit per sample 4:2:2 color format with similar to NV12 layout. */
MFX_FOURCC_BGR4 = MFX_MAKEFOURCC('B','G','R','4'), /*!< RGBA color format. It is similar to MFX_FOURCC_RGB4 but with different order of channels. 'R' is 8 MSBs, then 8 bits for 'G' channel, then 'B' and 'A' channels. */
MFX_FOURCC_A2RGB10 = MFX_MAKEFOURCC('R','G','1','0'), /*!< 10 bits ARGB color format packed in 32 bits. 'A' channel is two MSBs, then 'R', then 'G' and then 'B' channels. This format should be mapped to DXGI_FORMAT_R10G10B10A2_UNORM or D3DFMT_A2R10G10B10. */
MFX_FOURCC_ARGB16 = MFX_MAKEFOURCC('R','G','1','6'), /*!< 10 bits ARGB color format packed in 64 bits. 'A' channel is 16 MSBs, then 'R', then 'G' and then 'B' channels. This format should be mapped to DXGI_FORMAT_R16G16B16A16_UINT or D3DFMT_A16B16G16R16 formats. */
MFX_FOURCC_ABGR16 = MFX_MAKEFOURCC('B','G','1','6'), /*!< 10 bits ABGR color format packed in 64 bits. 'A' channel is 16 MSBs, then 'B', then 'G' and then 'R' channels. This format should be mapped to DXGI_FORMAT_R16G16B16A16_UINT or D3DFMT_A16B16G16R16 formats. */
MFX_FOURCC_R16 = MFX_MAKEFOURCC('R','1','6','U'), /*!< 16 bits single channel color format. This format should be mapped to DXGI_FORMAT_R16_TYPELESS or D3DFMT_R16F. */
MFX_FOURCC_AYUV = MFX_MAKEFOURCC('A','Y','U','V'), /*!< YUV 4:4:4, AYUV color format. This format should be mapped to DXGI_FORMAT_AYUV. */
MFX_FOURCC_AYUV_RGB4 = MFX_MAKEFOURCC('A','V','U','Y'), /*!< RGB4 stored in AYUV surface. This format should be mapped to DXGI_FORMAT_AYUV. */
MFX_FOURCC_UYVY = MFX_MAKEFOURCC('U','Y','V','Y'), /*!< UYVY color planes. Same as YUY2 except the byte order is reversed. */
MFX_FOURCC_Y210 = MFX_MAKEFOURCC('Y','2','1','0'), /*!< 10 bit per sample 4:2:2 packed color format with similar to YUY2 layout. This format should be mapped to DXGI_FORMAT_Y210. */
MFX_FOURCC_Y410 = MFX_MAKEFOURCC('Y','4','1','0'), /*!< 10 bit per sample 4:4:4 packed color format. This format should be mapped to DXGI_FORMAT_Y410. */
MFX_FOURCC_Y216 = MFX_MAKEFOURCC('Y','2','1','6'), /*!< 16 bit per sample 4:2:2 packed color format with similar to YUY2 layout. This format should be mapped to DXGI_FORMAT_Y216. */
MFX_FOURCC_Y416 = MFX_MAKEFOURCC('Y','4','1','6'), /*!< 16 bit per sample 4:4:4 packed color format. This format should be mapped to DXGI_FORMAT_Y416. */
MFX_FOURCC_NV21 = MFX_MAKEFOURCC('N', 'V', '2', '1'), /*!< Same as NV12 but with weaved V and U values. */
MFX_FOURCC_IYUV = MFX_MAKEFOURCC('I', 'Y', 'U', 'V'), /*!< Same as YV12 except that the U and V plane order is reversed. */
MFX_FOURCC_I010 = MFX_MAKEFOURCC('I', '0', '1', '0'), /*!< 10-bit YUV 4:2:0, each component has its own plane. */
MFX_FOURCC_I210 = MFX_MAKEFOURCC('I', '2', '1', '0'), /*!< 10-bit YUV 4:2:2, each component has its own plane. */
MFX_FOURCC_I420 = MFX_FOURCC_IYUV, /*!< Alias for the IYUV color format. */
MFX_FOURCC_I422 = MFX_MAKEFOURCC('I', '4', '2', '2'), /*!< Same as YV16 except that the U and V plane order is reversed */
MFX_FOURCC_BGRA = MFX_FOURCC_RGB4, /*!< Alias for the RGB4 color format. */
/*! BGR 24 bit planar layout (3 separate channels, 8-bits per sample each). This format should be mapped to VA_FOURCC_BGRP. */
MFX_FOURCC_BGRP = MFX_MAKEFOURCC('B','G','R','P'),
#ifdef ONEVPL_EXPERIMENTAL
/*! 8bit per sample 4:4:4 format packed in 32 bits, X=unused/undefined, 'X' channel is 8 MSBs, then 'Y', then 'U', and then 'V' channels. This format should be mapped to VA_FOURCC_XYUV. */
MFX_FOURCC_XYUV = MFX_MAKEFOURCC('X','Y','U','V'),
#endif
#ifdef ONEVPL_EXPERIMENTAL
MFX_FOURCC_ABGR16F = MFX_MAKEFOURCC('B', 'G', 'R', 'F'), /*!< 16 bits float point ABGR color format packed in 64 bits. 'A' channel is 16 MSBs, then 'B', then 'G' and then 'R' channels. This format should be mapped to DXGI_FORMAT_R16G16B16A16_FLOAT or D3DFMT_A16B16G16R16F formats.. */
#endif
};
/* PicStruct */
enum {
MFX_PICSTRUCT_UNKNOWN =0x00, /*!< Unspecified or mixed progressive/interlaced/field pictures. */
MFX_PICSTRUCT_PROGRESSIVE =0x01, /*!< Progressive picture. */
MFX_PICSTRUCT_FIELD_TFF =0x02, /*!< Top field in first interlaced picture. */
MFX_PICSTRUCT_FIELD_BFF =0x04, /*!< Bottom field in first interlaced picture. */
MFX_PICSTRUCT_FIELD_REPEATED=0x10, /*!< First field repeated: pic_struct=5 or 6 in H.264. */
MFX_PICSTRUCT_FRAME_DOUBLING=0x20, /*!< Double the frame for display: pic_struct=7 in H.264. */
MFX_PICSTRUCT_FRAME_TRIPLING=0x40, /*!< Triple the frame for display: pic_struct=8 in H.264. */
MFX_PICSTRUCT_FIELD_SINGLE =0x100, /*!< Single field in a picture. */
MFX_PICSTRUCT_FIELD_TOP =MFX_PICSTRUCT_FIELD_SINGLE | MFX_PICSTRUCT_FIELD_TFF, /*!< Top field in a picture: pic_struct = 1 in H.265. */
MFX_PICSTRUCT_FIELD_BOTTOM =MFX_PICSTRUCT_FIELD_SINGLE | MFX_PICSTRUCT_FIELD_BFF, /*!< Bottom field in a picture: pic_struct = 2 in H.265. */
MFX_PICSTRUCT_FIELD_PAIRED_PREV =0x200, /*!< Paired with previous field: pic_struct = 9 or 10 in H.265. */
MFX_PICSTRUCT_FIELD_PAIRED_NEXT =0x400, /*!< Paired with next field: pic_struct = 11 or 12 in H.265 */
};
/* The ChromaFormatIdc enumerator itemizes color-sampling formats. */
enum {
MFX_CHROMAFORMAT_MONOCHROME =0, /*!< Monochrome. */
MFX_CHROMAFORMAT_YUV420 =1, /*!< 4:2:0 color. */
MFX_CHROMAFORMAT_YUV422 =2, /*!< 4:2:2 color. */
MFX_CHROMAFORMAT_YUV444 =3, /*!< 4:4:4 color. */
MFX_CHROMAFORMAT_YUV400 = MFX_CHROMAFORMAT_MONOCHROME, /*!< Equal to monochrome. */
MFX_CHROMAFORMAT_YUV411 = 4, /*!< 4:1:1 color. */
MFX_CHROMAFORMAT_YUV422H = MFX_CHROMAFORMAT_YUV422, /*!< 4:2:2 color, horizontal sub-sampling. It is equal to 4:2:2 color. */
MFX_CHROMAFORMAT_YUV422V = 5, /*!< 4:2:2 color, vertical sub-sampling. */
MFX_CHROMAFORMAT_RESERVED1 = 6 /*!< Reserved. */
};
enum {
MFX_TIMESTAMP_UNKNOWN = -1 /*!< Indicates that time stamp is unknown for this frame/bitstream portion. */
};
enum {
MFX_FRAMEORDER_UNKNOWN = -1 /*!< Unused entry or API functions that generate the frame output do not use this frame. */
};
/* The FrameDataFlag enumerator itemizes DataFlag value in mfxFrameData. */
enum {
MFX_FRAMEDATA_TIMESTAMP_UNKNOWN = 0x0000,/*!< Indicates the time stamp of this frame is unknown and will be calculated by SDK. */
MFX_FRAMEDATA_ORIGINAL_TIMESTAMP = 0x0001 /*!< Indicates the time stamp of this frame is not calculated and is a pass-through of the original time stamp. */
};
/* Corrupted in mfxFrameData */
enum {
MFX_CORRUPTION_NO = 0x0000, /*!< No corruption. */
MFX_CORRUPTION_MINOR = 0x0001, /*!< Minor corruption in decoding certain macro-blocks. */
MFX_CORRUPTION_MAJOR = 0x0002, /*!< Major corruption in decoding the frame - incomplete data, for example. */
MFX_CORRUPTION_ABSENT_TOP_FIELD = 0x0004, /*!< Top field of frame is absent in bitstream. Only bottom field has been decoded. */
MFX_CORRUPTION_ABSENT_BOTTOM_FIELD = 0x0008, /*!< Bottom field of frame is absent in bitstream. Only top filed has been decoded. */
MFX_CORRUPTION_REFERENCE_FRAME = 0x0010, /*!< Decoding used a corrupted reference frame. A corrupted reference frame was used for decoding this
frame. For example, if the frame uses a reference frame that was decoded with minor/major corruption flag, then this
frame is also marked with a reference corruption flag. */
MFX_CORRUPTION_REFERENCE_LIST = 0x0020 /*!< The reference list information of this frame does not match what is specified in the Reference Picture Marking
Repetition SEI message. (ITU-T H.264 D.1.8 dec_ref_pic_marking_repetition) */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! Specifies "pixel" in Y410 color format. */
typedef struct
{
mfxU32 U : 10; /*!< U component. */
mfxU32 Y : 10; /*!< Y component. */
mfxU32 V : 10; /*!< V component. */
mfxU32 A : 2; /*!< A component. */
} mfxY410;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! Specifies "pixel" in Y416 color format. */
typedef struct
{
mfxU32 U : 16; /*!< U component. */
mfxU32 Y : 16; /*!< Y component. */
mfxU32 V : 16; /*!< V component. */
mfxU32 A : 16; /*!< A component. */
} mfxY416;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! Specifies "pixel" in A2RGB10 color format */
typedef struct
{
mfxU32 B : 10; /*!< B component. */
mfxU32 G : 10; /*!< G component. */
mfxU32 R : 10; /*!< R component. */
mfxU32 A : 2; /*!< A component. */
} mfxA2RGB10;
MFX_PACK_END()
#ifdef ONEVPL_EXPERIMENTAL
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! Specifies "pixel" in ABGR 16 bit half float point color format */
typedef struct
{
mfxFP16 R; /*!< R component. */
mfxFP16 G; /*!< G component. */
mfxFP16 B; /*!< B component. */
mfxFP16 A; /*!< A component. */
} mfxABGR16FP;
MFX_PACK_END()
#endif
/*! Describes frame buffer pointers. */
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
typedef struct {
/*! @name Extension Buffers */
/*! @{ */
union {
mfxExtBuffer **ExtParam; /*!< Points to an array of pointers to the extra configuration structures. See the ExtendedBufferID
enumerator for a list of extended configurations. */
mfxU64 reserved2;
};
mfxU16 NumExtParam; /*!< The number of extra configuration structures attached to this structure. */
/*! @} */
/*! @name General members */
/*! @{ */
mfxU16 reserved[9]; /*!< Reserved for future use. */
mfxU16 MemType; /*!< Allocated memory type. See the ExtMemFrameType enumerator for details. Used for better integration of
3rd party plugins into the pipeline. */
mfxU16 PitchHigh; /*!< Distance in bytes between the start of two consecutive rows in a frame. */
mfxU64 TimeStamp; /*!< Time stamp of the video frame in units of 90KHz. Divide TimeStamp by 90,000 (90 KHz) to obtain the time in seconds.
A value of MFX_TIMESTAMP_UNKNOWN indicates that there is no time stamp. */
mfxU32 FrameOrder; /*!< Current frame counter for the top field of the current frame. An invalid value of MFX_FRAMEORDER_UNKNOWN indicates that
API functions that generate the frame output do not use this frame. */
mfxU16 Locked; /*!< Counter flag for the application. If Locked is greater than zero then the application locks the frame or field pair.
Do not move, alter or delete the frame. */
union{
mfxU16 Pitch;
mfxU16 PitchLow; /*!< Distance in bytes between the start of two consecutive rows in a frame. */
};
/*! @} */
/*!
@name Color Planes
Data pointers to corresponding color channels (planes). The frame buffer pointers must be 16-byte aligned. The application has to specify pointers to
all color channels even for packed formats. For example, for YUY2 format the application must specify Y, U, and V pointers.
For RGB32 format, the application must specify R, G, B, and A pointers.
*/
/*! @{ */
union {
mfxU8 *Y; /*!< Y channel. */
mfxU16 *Y16; /*!< Y16 channel. */
mfxU8 *R; /*!< R channel. */
};
union {
mfxU8 *UV; /*!< UV channel for UV merged formats. */
mfxU8 *VU; /*!< YU channel for VU merged formats. */
mfxU8 *CbCr; /*!< CbCr channel for CbCr merged formats. */
mfxU8 *CrCb; /*!< CrCb channel for CrCb merged formats. */
mfxU8 *Cb; /*!< Cb channel. */
mfxU8 *U; /*!< U channel. */
mfxU16 *U16; /*!< U16 channel. */
mfxU8 *G; /*!< G channel. */
mfxY410 *Y410; /*!< T410 channel for Y410 format (merged AVYU). */
mfxY416 *Y416; /*!< This format is a packed 16-bit representation that includes 16 bits of alpha. */
};
union {
mfxU8 *Cr; /*!< Cr channel. */
mfxU8 *V; /*!< V channel. */
mfxU16 *V16; /*!< V16 channel. */
mfxU8 *B; /*!< B channel. */
mfxA2RGB10 *A2RGB10; /*!< A2RGB10 channel for A2RGB10 format (merged ARGB). */
#ifdef ONEVPL_EXPERIMENTAL
mfxABGR16FP* ABGRFP16; /*!< ABGRFP16 channel for half float ARGB format (use this merged one due to no separate FP16 Alpha Channel). */
#endif
};
mfxU8 *A; /*!< A channel. */
mfxMemId MemId; /*!< Memory ID of the data buffers. Ignored if any of the preceding data pointers is non-zero. */
/*! @} */
/*!
@name Additional Flags
*/
/*! @{ */
mfxU16 Corrupted; /*!< Some part of the frame or field pair is corrupted. See the Corruption enumerator for details. */
mfxU16 DataFlag; /*!< Additional flags to indicate frame data properties. See the FrameDataFlag enumerator for details. */
/*! @} */
} mfxFrameData;
MFX_PACK_END()
/*! The mfxHandleType enumerator itemizes system handle types that implementations might use. */
typedef enum {
MFX_HANDLE_DIRECT3D_DEVICE_MANAGER9 =1, /*!< Pointer to the IDirect3DDeviceManager9 interface. See Working with Microsoft* DirectX* Applications for more details on how to use this handle. */
MFX_HANDLE_D3D9_DEVICE_MANAGER = MFX_HANDLE_DIRECT3D_DEVICE_MANAGER9, /*!< Pointer to the IDirect3DDeviceManager9 interface. See Working with Microsoft* DirectX* Applications for more details on how to use this handle. */
MFX_HANDLE_RESERVED1 = 2, /* Reserved. */
MFX_HANDLE_D3D11_DEVICE = 3, /*!< Pointer to the ID3D11Device interface. See Working with Microsoft* DirectX* Applications for more details on how to use this handle. */
MFX_HANDLE_VA_DISPLAY = 4, /*!< Pointer to VADisplay interface. See Working with VA-API Applications for more details on how to use this handle. */
MFX_HANDLE_RESERVED3 = 5, /* Reserved. */
MFX_HANDLE_VA_CONFIG_ID = 6, /*!< Pointer to VAConfigID interface. It represents external VA config for Common Encryption usage model. */
MFX_HANDLE_VA_CONTEXT_ID = 7, /*!< Pointer to VAContextID interface. It represents external VA context for Common Encryption usage model. */
MFX_HANDLE_CM_DEVICE = 8, /*!< Pointer to CmDevice interface ( Intel(r) C for Metal Runtime ). */
MFX_HANDLE_HDDLUNITE_WORKLOADCONTEXT = 9, /*!< Pointer to HddlUnite::WorkloadContext interface. */
MFX_HANDLE_PXP_CONTEXT = 10, /*!< Pointer to PXP context for protected content support. */
} mfxHandleType;
/*! The mfxMemoryFlags enumerator specifies memory access mode. */
typedef enum
{
MFX_MAP_READ = 0x1, /*!< The surface is mapped for reading. */
MFX_MAP_WRITE = 0x2, /*!< The surface is mapped for writing. */
MFX_MAP_READ_WRITE = MFX_MAP_READ|MFX_MAP_WRITE, /*!< The surface is mapped for reading and writing. */
/*!
* The mapping would be done immediately without any implicit synchronizations.
* \attention This flag is optional.
*/
MFX_MAP_NOWAIT = 0x10
} mfxMemoryFlags;
#define MFX_FRAMESURFACE1_VERSION MFX_STRUCT_VERSION(1, 1)
/* Frame Surface */
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/*! Defines the uncompressed frames surface information and data buffers.
The frame surface is in the frame or complementary field pairs of pixels up to four color-channels, in two parts:
mfxFrameInfo and mfxFrameData.
*/
typedef struct {
union
{
struct mfxFrameSurfaceInterface* FrameInterface; /*!< Specifies interface to work with surface. */
mfxU32 reserved[2];
};
mfxStructVersion Version; /* Specifies version of mfxFrameSurface1 structure. */
mfxU16 reserved1[3];
mfxFrameInfo Info; /*!< Specifies surface properties. */
mfxFrameData Data; /*!< Describes the actual frame buffer. */
} mfxFrameSurface1;
MFX_PACK_END()
#define MFX_FRAMESURFACEINTERFACE_VERSION MFX_STRUCT_VERSION(1, 0)
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/* Specifies frame surface interface. */
typedef struct mfxFrameSurfaceInterface {
mfxHDL Context; /*!< The context of the memory interface. User should not touch (change, set, null) this pointer. */
mfxStructVersion Version; /*!< The version of the structure. */
mfxU16 reserved1[3];
/*! @brief
Increments the internal reference counter of the surface. The surface is not destroyed until the surface is released using the mfxFrameSurfaceInterface::Release function.
mfxFrameSurfaceInterface::AddRef should be used each time a new link to the surface is created (for example, copy structure) for proper surface management.
@param[in] surface Valid surface.
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If surface is NULL. \n
MFX_ERR_INVALID_HANDLE If mfxFrameSurfaceInterface->Context is invalid (for example NULL). \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *AddRef)(mfxFrameSurface1* surface);
/*! @brief
Decrements the internal reference counter of the surface. mfxFrameSurfaceInterface::Release should be called after using the
mfxFrameSurfaceInterface::AddRef function to add a surface or when allocation logic requires it. For example, call
mfxFrameSurfaceInterface::Release to release a surface obtained with the GetSurfaceForXXX function.
@param[in] surface Valid surface.
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If surface is NULL. \n
MFX_ERR_INVALID_HANDLE If mfxFrameSurfaceInterface->Context is invalid (for example NULL). \n
MFX_ERR_UNDEFINED_BEHAVIOR If Reference Counter of surface is zero before call. \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *Release)(mfxFrameSurface1* surface);
/*! @brief
Returns current reference counter of mfxFrameSurface1 structure.
@param[in] surface Valid surface.
@param[out] counter Sets counter to the current reference counter value.
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If surface or counter is NULL. \n
MFX_ERR_INVALID_HANDLE If mfxFrameSurfaceInterface->Context is invalid (for example NULL). \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *GetRefCounter)(mfxFrameSurface1* surface, mfxU32* counter);
/*! @brief
Sets pointers of surface->Info.Data to actual pixel data, providing read-write access.
In case of video memory, the surface with data in video memory becomes mapped to system memory.
An application can map a surface for read access with any value of mfxFrameSurface1::Data::Locked, but can map a surface for write access only when mfxFrameSurface1::Data::Locked equals to 0.
Note: A surface allows shared read access, but exclusive write access. Consider the following cases:
@li Map with Write or Read|Write flags. A request during active another read or write access returns MFX_ERR_LOCK_MEMORY error immediately, without waiting.
MFX_MAP_NOWAIT does not impact behavior. This type of request does not lead to any implicit synchronizations.
@li Map with Read flag. A request during active write access will wait for resource to become free,
or exits immediately with error if MFX_MAP_NOWAIT flag was set. This request may lead to the implicit synchronization (with same logic as Synchronize call)
waiting for surface to become ready to use (all dependencies should be resolved and upstream components finished writing to this surface).
It is guaranteed that read access will be acquired right after synchronization without allowing another thread to acquire this surface for writing.
If MFX_MAP_NOWAIT was set and the surface is not ready yet (for example the surface has unresolved data dependencies or active processing), the read access request exits immediately with error.
Read-write access with MFX_MAP_READ_WRITE provides exclusive simultaneous reading and writing access.
@note Bitwise copying of mfxFrameSurface1 object between map / unmap calls may result in having dangling data pointers in copies.
@param[in] surface Valid surface.
@param[out] flags Specify mapping mode.
@param[out] surface->Info.Data Pointers set to actual pixel data.
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If surface is NULL. \n
MFX_ERR_INVALID_HANDLE If mfxFrameSurfaceInterface->Context is invalid (for example NULL). \n
MFX_ERR_UNSUPPORTED If flags are invalid. \n
MFX_ERR_LOCK_MEMORY If user wants to map the surface for write and surface->Data.Locked does not equal to 0. \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *Map)(mfxFrameSurface1* surface, mfxU32 flags);
/*! @brief
Invalidates pointers of surface->Info.Data and sets them to NULL.
In case of video memory, the underlying texture becomes unmapped after last reader or writer unmap.
@param[in] surface Valid surface.
@param[out] surface->Info.Data Pointers set to NULL.
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If surface is NULL. \n
MFX_ERR_INVALID_HANDLE If mfxFrameSurfaceInterface->Context is invalid (for example NULL). \n
MFX_ERR_UNSUPPORTED If surface is already unmapped. \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *Unmap)(mfxFrameSurface1* surface);
/*! @brief
Returns a native resource's handle and type. The handle is returned *as-is*, meaning that the reference counter of base resources is not incremented.
The native resource is not detached from surface and the library still owns the resource. User must not destroy
the native resource or assume that the resource will be alive after mfxFrameSurfaceInterface::Release.
@param[in] surface Valid surface.
@param[out] resource Pointer is set to the native handle of the resource.
@param[out] resource_type Type of native resource. See mfxResourceType enumeration).
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If any of surface, resource or resource_type is NULL. \n
MFX_ERR_INVALID_HANDLE If any of surface, resource or resource_type is not valid object (no native resource was allocated). \n
MFX_ERR_UNSUPPORTED If surface is in system memory. \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *GetNativeHandle)(mfxFrameSurface1* surface, mfxHDL* resource, mfxResourceType* resource_type);
/*! @brief
Returns a device abstraction that was used to create that resource.
The handle is returned *as-is*, meaning that the reference counter for the device abstraction is not incremented.
The native resource is not detached from the surface and the library still has a reference to the resource.
User must not destroy the device or assume that the device will be alive after mfxFrameSurfaceInterface::Release.
@param[in] surface Valid surface.
@param[out] device_handle Pointer is set to the device which created the resource
@param[out] device_type Type of device (see mfxHandleType enumeration).
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If any of surface, device_handle or device_type is NULL. \n
MFX_ERR_INVALID_HANDLE If any of surface, resource or resource_type is not valid object (no native resource was allocated). \n
MFX_ERR_UNSUPPORTED If surface is in system memory. \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *GetDeviceHandle)(mfxFrameSurface1* surface, mfxHDL* device_handle, mfxHandleType* device_type);
/*! @brief
Guarantees readiness of both the data (pixels) and any frame's meta information (for example corruption flags) after a function completes.
Instead of MFXVideoCORE_SyncOperation, users may directly call the mfxFrameSurfaceInterface::Synchronize function after the corresponding
Decode or VPP function calls (MFXVideoDECODE_DecodeFrameAsync or MFXVideoVPP_RunFrameVPPAsync).
The prerequisites to call the functions are:
@li The main processing functions return MFX_ERR_NONE.
@li A valid mfxFrameSurface1 object.
@param[in] surface Valid surface.
@param[out] wait Wait time in milliseconds.
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If surface is NULL. \n
MFX_ERR_INVALID_HANDLE If any of surface is not valid object . \n
MFX_WRN_IN_EXECUTION If the given timeout is expired and the surface is not ready. \n
MFX_ERR_ABORTED If the specified asynchronous function aborted due to data dependency on a previous asynchronous function that did not complete. \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *Synchronize)(mfxFrameSurface1* surface, mfxU32 wait);
/*! @brief
The library calls the function after complete of associated video operation
notifying the application that frame surface is ready.
@attention This is callback function and intended to be called by
the library only.
@note The library calls this callback only when this surface is used as the output surface.
It is expected that the function is low-intrusive designed otherwise it may
impact performance.
@param[in] sts The status of completed operation.
*/
void (MFX_CDECL *OnComplete)(mfxStatus sts);
/*! @brief
Returns an interface defined by the GUID. If the returned interface is a reference
counted object the caller should release the obtained interface to avoid memory leaks.
@param[in] surface Valid surface.
@param[in] guid GUID of the requested interface.
@param[out] iface Interface.
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If interface or surface is NULL. \n
MFX_ERR_UNSUPPORTED If requested interface is not supported. \n
MFX_ERR_NOT_IMPLEMENTED If requested interface is not implemented. \n
MFX_ERR_NOT_INITIALIZED If requested interface is not available (not created or already deleted). \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *QueryInterface)(mfxFrameSurface1* surface, mfxGUID guid, mfxHDL* iface);
mfxHDL reserved2[2];
} mfxFrameSurfaceInterface;
MFX_PACK_END()
/*! The TimeStampCalc enumerator itemizes time-stamp calculation methods. */
enum {
/*! The time stamp calculation is based on the input frame rate if time stamp is not explicitly specified. */
MFX_TIMESTAMPCALC_UNKNOWN = 0,
/*! Adjust time stamp to 29.97fps on 24fps progressively encoded sequences if telecine attributes are available in the bitstream and
time stamp is not explicitly specified. The input frame rate must be specified. */
MFX_TIMESTAMPCALC_TELECINE = 1,
};
/* Transcoding Info */
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! Specifies configurations for decoding, encoding, and transcoding processes.
A zero value in any of these fields indicates that the field is not explicitly specified. */
typedef struct {
mfxU32 reserved[7]; /*!< Reserved for future use. */
/*! Hint to enable low power consumption mode for encoders. See the CodingOptionValue enumerator for values
of this option. Use the Query API function to check if this feature is supported. */
mfxU16 LowPower;
/*! Specifies a multiplier for bitrate control parameters. Affects the following variables: InitialDelayInKB, BufferSizeInKB,
TargetKbps, MaxKbps. If this value is not equal to zero, the encoder calculates BRC parameters as ``value * BRCParamMultiplier``. */
mfxU16 BRCParamMultiplier;
mfxFrameInfo FrameInfo; /*!< mfxFrameInfo structure that specifies frame parameters. */
mfxU32 CodecId; /*!< Specifies the codec format identifier in the FourCC code; see the CodecFormatFourCC enumerator for details.
This is a mandated input parameter for the QueryIOSurf and Init API functions. */
mfxU16 CodecProfile; /*!< Specifies the codec profile; see the CodecProfile enumerator for details. Specify the codec profile explicitly or the API functions will determine
the correct profile from other sources, such as resolution and bitrate. */
mfxU16 CodecLevel; /*!< Codec level; see the CodecLevel enumerator for details. Specify the codec level explicitly or the functions will determine the correct level from other sources,
such as resolution and bitrate. */
mfxU16 NumThread;
union {
struct { /* Encoding Options */
mfxU16 TargetUsage; /*!< Target usage model that guides the encoding process; see the TargetUsage enumerator for details. */
/*! Number of pictures within the current GOP (Group of Pictures); if GopPicSize = 0, then the GOP size is unspecified. If GopPicSize = 1, only I-frames are used.
The following pseudo-code that shows how the library uses this parameter:
@code
mfxU16 get_gop_sequence (...) {
pos=display_frame_order;
if (pos == 0)
return MFX_FRAMETYPE_I | MFX_FRAMETYPE_IDR | MFX_FRAMETYPE_REF;
If (GopPicSize == 1) // Only I-frames
return MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
if (GopPicSize == 0)
frameInGOP = pos; //Unlimited GOP
else
frameInGOP = pos%GopPicSize;
if (frameInGOP == 0)
return MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
if (GopRefDist == 1 || GopRefDist == 0) // Only I,P frames
return MFX_FRAMETYPE_P | MFX_FRAMETYPE_REF;
frameInPattern = (frameInGOP-1)%GopRefDist;
if (frameInPattern == GopRefDist - 1)
return MFX_FRAMETYPE_P | MFX_FRAMETYPE_REF;
return MFX_FRAMETYPE_B;
}
@endcode */
mfxU16 GopPicSize;
/*! Distance between I- or P (or GPB) - key frames; if it is zero, the GOP structure is unspecified. Note: If GopRefDist = 1,
there are no regular B-frames used (only P or GPB); if mfxExtCodingOption3::GPB is ON, GPB frames (B without backward
references) are used instead of P. */
mfxU16 GopRefDist;
/*! ORs of the GopOptFlag enumerator indicate the additional flags for the GOP specification. */
mfxU16 GopOptFlag;
/*! For H.264, specifies IDR-frame interval in terms of I-frames.
For example:
@li If IdrInterval = 0, then every I-frame is an IDR-frame.
@li If IdrInterval = 1, then every other I-frame is an IDR-frame.
For HEVC, if IdrInterval = 0, then only first I-frame is an IDR-frame. For example:
@li If IdrInterval = 1, then every I-frame is an IDR-frame.
@li If IdrInterval = 2, then every other I-frame is an IDR-frame.
For MPEG2, IdrInterval defines sequence header interval in terms of I-frames. For example:
@li If IdrInterval = 0 (default), then the sequence header is inserted once at the beginning of the stream.
@li If IdrInterval = N, then the sequence header is inserted before every Nth I-frame.
If GopPicSize or GopRefDist is zero, IdrInterval is undefined. */
mfxU16 IdrInterval;
mfxU16 RateControlMethod; /*! Rate control method; see the RateControlMethod enumerator for details. */
union {
/*! Initial size of the Video Buffering Verifier (VBV) buffer.
@note In this context, KB is 1000 bytes and Kbps is 1000 bps. */
mfxU16 InitialDelayInKB;
/*! Quantization Parameter (QP) for I-frames for constant QP mode (CQP). Zero QP is not valid and means that the default value is assigned by the library.
Non-zero QPI might be clipped to supported QPI range.
@note In the HEVC design, a further adjustment to QPs can occur based on bit depth.
Adjusted QPI value = QPI - (6 * (BitDepthLuma - 8)) for BitDepthLuma in the range [8,14].
For HEVC_MAIN10, we minus (6*(10-8)=12) on our side and continue.
@note Default QPI value is implementation dependent and subject to change without additional notice in this document. */
mfxU16 QPI;
mfxU16 Accuracy; /*!< Specifies accuracy range in the unit of tenth of percent. */
};
mfxU16 BufferSizeInKB; /*!< Represents the maximum possible size of any compressed frames. */
union {
/*! Constant bitrate TargetKbps. Used to estimate the targeted frame size by dividing the frame rate by the bitrate. */
mfxU16 TargetKbps;
/*! Quantization Parameter (QP) for P-frames for constant QP mode (CQP). Zero QP is not valid and means that the default value is assigned by the library.
Non-zero QPP might be clipped to supported QPI range.
@note In the HEVC design, a further adjustment to QPs can occur based on bit depth.
Adjusted QPP value = QPP - (6 * (BitDepthLuma - 8)) for BitDepthLuma in the range [8,14].
For HEVC_MAIN10, we minus (6*(10-8)=12) on our side and continue.
@note Default QPP value is implementation dependent and subject to change without additional notice in this document. */
mfxU16 QPP;
mfxU16 ICQQuality; /*!< Used by the Intelligent Constant Quality (ICQ) bitrate control algorithm. Values are in the 1 to 51 range, where 1 corresponds the best quality. */
};
union {
/*! The maximum bitrate at which the encoded data enters the Video Buffering Verifier (VBV) buffer. */
mfxU16 MaxKbps;
/*! Quantization Parameter (QP) for B-frames for constant QP mode (CQP). Zero QP is not valid and means that the default value is assigned by the library.
Non-zero QPI might be clipped to supported QPB range.
@note In the HEVC design, a further adjustment to QPs can occur based on bit depth.
Adjusted QPB value = QPB - (6 * (BitDepthLuma - 8)) for BitDepthLuma in the range [8,14].
For HEVC_MAIN10, we minus (6*(10-8)=12) on our side and continue.
@note Default QPB value is implementation dependent and subject to change without additional notice in this document. */
mfxU16 QPB;
mfxU16 Convergence; /*!< Convergence period in the unit of 100 frames. */
};
/*! Number of slices in each video frame. Each slice contains one or more macro-block rows. If NumSlice equals zero, the encoder may choose any slice partitioning
allowed by the codec standard. See also mfxExtCodingOption2::NumMbPerSlice. */
mfxU16 NumSlice;
/*! Max number of all available reference frames (for AVC/HEVC, NumRefFrame defines DPB size). If NumRefFrame = 0, this parameter is not specified.
See also NumRefActiveP, NumRefActiveBL0, and NumRefActiveBL1 in the mfxExtCodingOption3 structure, which set a number of active references. */
mfxU16 NumRefFrame;
/*! If not zero, specifies that ENCODE takes the input surfaces in the encoded order and uses explicit frame type control.
The application must still provide GopRefDist and mfxExtCodingOption2::BRefType so the library can pack headers and build reference
lists correctly. */
mfxU16 EncodedOrder;
};
struct { /* Decoding Options */
/*! For AVC and HEVC, used to instruct the decoder to return output frames in the decoded order. Must be zero for all other decoders.
When enabled, correctness of mfxFrameData::TimeStamp and FrameOrder for output surface is not guaranteed, the application should ignore them. */
mfxU16 DecodedOrder;
/*! Instructs DECODE to output extended picture structure values for additional display attributes. See the PicStruct description for details. */
mfxU16 ExtendedPicStruct;
/*! Time stamp calculation method. See the TimeStampCalc description for details. */
mfxU16 TimeStampCalc;
/*! Nonzero value indicates that slice groups are present in the bitstream. Used only by AVC decoder. */
mfxU16 SliceGroupsPresent;
/*! Nonzero value specifies the maximum required size of the decoded picture buffer in frames for AVC and HEVC decoders. */
mfxU16 MaxDecFrameBuffering;
/*! For decoders supporting dynamic resolution change (VP9), set this option to ON to allow MFXVideoDECODE_DecodeFrameAsync
return MFX_ERR_REALLOC_SURFACE. See the CodingOptionValue enumerator for values of this option. Use the Query API
function to check if this feature is supported. */
mfxU16 EnableReallocRequest;
/*! Special parameter for AV1 decoder. Indicates presence/absence of film grain parameters in bitstream.
Also controls decoding behavior for streams with film grain parameters. MFXVideoDECODE_DecodeHeader returns nonzero FilmGrain
for streams with film grain parameters and zero for streams w/o them. Decoding with film grain requires additional output surfaces.
If FilmGrain` is non-zero then MFXVideoDECODE_QueryIOSurf will request more surfaces in case of external allocated video memory at decoder output.
FilmGrain is passed to MFXVideoDECODE_Init function to control decoding operation for AV1 streams with film grain parameters.
If FilmGrain is nonzero decoding of each frame require two output surfaces (one for reconstructed frame and one for output frame with film grain applied).
The decoder returns MFX_ERR_MORE_SURFACE from MFXVideoDECODE_DecodeFrameAsync if it has insufficient output surfaces to decode frame.
Application can forcibly disable the feature passing zero value of `FilmGrain` to `MFXVideoDECODE_Init`.
In this case the decoder will output reconstructed frames w/o film grain applied.
Application can retrieve film grain parameters for a frame by attaching extended buffer mfxExtAV1FilmGrainParam to mfxFrameSurface1.
If stream has no film grain parameters `FilmGrain` passed to `MFXVideoDECODE_Init` is ignored by the decoder. */
mfxU16 FilmGrain;
/*! If not zero, it forces SDK to attempt to decode bitstream even if a decoder may not support all features associated with given CodecLevel. Decoder may produce visual artifacts. Only AVC decoder supports this field. */
mfxU16 IgnoreLevelConstrain;
/*! This flag is used to disable output of main decoding channel. When it's ON SkipOutput = MFX_CODINGOPTION_ON decoder outputs only video processed channels. For pure decode this flag should be always disabled. */
mfxU16 SkipOutput;
mfxU16 reserved2[4];
};
struct { /* JPEG Decoding Options */
/*! Specify the chroma sampling format that has been used to encode a JPEG picture. See the ChromaFormat enumerator for details. */
mfxU16 JPEGChromaFormat;
/*! Rotation option of the output JPEG picture. See the Rotation enumerator for details. */
mfxU16 Rotation;
/*! Specify the color format that has been used to encode a JPEG picture. See the JPEGColorFormat enumerator for details. */
mfxU16 JPEGColorFormat;
/*! Specify JPEG scan type for decoder. See the JPEGScanType enumerator for details. */
mfxU16 InterleavedDec;
mfxU8 SamplingFactorH[4]; /*!< Horizontal sampling factor. */
mfxU8 SamplingFactorV[4]; /*!< Vertical sampling factor. */
mfxU16 reserved3[5];
};
struct { /* JPEG Encoding Options */
/*! Specify interleaved or non-interleaved scans. If it is equal to MFX_SCANTYPE_INTERLEAVED then the image is encoded as interleaved,
all components are encoded in one scan. See the JPEG Scan Type enumerator for details. */
mfxU16 Interleaved;
/*! Specifies the image quality if the application does not specified quantization table.
The value is from 1 to 100 inclusive. "100" is the best quality. */
mfxU16 Quality;
/*! Specifies the number of MCU in the restart interval. "0" means no restart interval. */
mfxU16 RestartInterval;
mfxU16 reserved5[10];
};
};
} mfxInfoMFX;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! Specifies configurations for video processing. A zero value in any of the fields indicates
that the corresponding field is not explicitly specified. */
typedef struct {
mfxU32 reserved[8];
mfxFrameInfo In; /*!< Input format for video processing. */
mfxFrameInfo Out; /*!< Output format for video processing. */
} mfxInfoVPP;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*! Configuration parameters for encoding, decoding, transcoding, and video processing. */
typedef struct {
/*! Unique component ID that will be passed by the library to mfxFrameAllocRequest. Useful in pipelines where several
components of the same type share the same allocator. */
mfxU32 AllocId;
mfxU32 reserved[2];
mfxU16 reserved3;
/*! Specifies how many asynchronous operations an application performs before the application explicitly synchronizes the result.
If zero, the value is not specified. */
mfxU16 AsyncDepth;
union {
mfxInfoMFX mfx; /*!< Configurations related to encoding, decoding, and transcoding. See the definition of the mfxInfoMFX structure for details. */
mfxInfoVPP vpp; /*!< Configurations related to video processing. See the definition of the mfxInfoVPP structure for details. */
};
/*! Specifies the content protection mechanism. See the Protected enumerator for a list of supported protection schemes. */
mfxU16 Protected;
/*! Input and output memory access types for functions. See the enumerator IOPattern for details.
The Query API functions return the natively supported IOPattern if the Query input argument is NULL.
This parameter is a mandated input for QueryIOSurf and Init API functions. The output pattern must be specified for DECODE.
The input pattern must be specified for ENCODE. Both input and output pattern must be specified for VPP. */
mfxU16 IOPattern;
mfxExtBuffer** ExtParam; /*!< The number of extra configuration structures attached to this structure. */
mfxU16 NumExtParam; /*!< Points to an array of pointers to the extra configuration structures. See the ExtendedBufferID enumerator
for a list of extended configurations.
The list of extended buffers should not contain duplicated entries, such as entries of the same type.
If the mfxVideoParam structure is used to query library capability, then the list of extended buffers attached to the input
and output mfxVideoParam structure should be equal, that is, it should contain the same number of extended
buffers of the same type. */
mfxU16 reserved2;
} mfxVideoParam;
MFX_PACK_END()
/*! The IOPattern enumerator itemizes memory access patterns for API functions. Use bit-ORed values to specify an input access
pattern and an output access pattern. */
enum {
MFX_IOPATTERN_IN_VIDEO_MEMORY = 0x01, /*!< Input to functions is a video memory surface. */
MFX_IOPATTERN_IN_SYSTEM_MEMORY = 0x02, /*!< Input to functions is a linear buffer directly in system memory or in system memory through an external allocator. */
MFX_IOPATTERN_OUT_VIDEO_MEMORY = 0x10, /*!< Output to functions is a video memory surface. */
MFX_IOPATTERN_OUT_SYSTEM_MEMORY = 0x20 /*!< Output to functions is a linear buffer directly in system memory or in system memory through an external allocator. */
};
/*! The CodecFormatFourCC enumerator itemizes codecs in the FourCC format. */
enum {
MFX_CODEC_AVC =MFX_MAKEFOURCC('A','V','C',' '), /*!< AVC, H.264, or MPEG-4, part 10 codec. */
MFX_CODEC_HEVC =MFX_MAKEFOURCC('H','E','V','C'), /*!< HEVC codec. */
MFX_CODEC_MPEG2 =MFX_MAKEFOURCC('M','P','G','2'), /*!< MPEG-2 codec. */
MFX_CODEC_VC1 =MFX_MAKEFOURCC('V','C','1',' '), /*!< VC-1 codec. */
MFX_CODEC_CAPTURE =MFX_MAKEFOURCC('C','A','P','T'), /*!< */
MFX_CODEC_VP9 =MFX_MAKEFOURCC('V','P','9',' '), /*!< VP9 codec. */
MFX_CODEC_AV1 =MFX_MAKEFOURCC('A','V','1',' ') /*!< AV1 codec. */
};
/*!
The CodecProfile enumerator itemizes codec profiles for all codecs.
CodecLevel
*/
enum {
MFX_PROFILE_UNKNOWN =0, /*!< Unspecified profile. */
MFX_LEVEL_UNKNOWN =0, /*!< Unspecified level. */
/*! @{ */
/* Combined with H.264 profile these flags impose additional constrains. See H.264 specification for the list of constrains. */
MFX_PROFILE_AVC_CONSTRAINT_SET0 = (0x100 << 0),
MFX_PROFILE_AVC_CONSTRAINT_SET1 = (0x100 << 1),
MFX_PROFILE_AVC_CONSTRAINT_SET2 = (0x100 << 2),
MFX_PROFILE_AVC_CONSTRAINT_SET3 = (0x100 << 3),
MFX_PROFILE_AVC_CONSTRAINT_SET4 = (0x100 << 4),
MFX_PROFILE_AVC_CONSTRAINT_SET5 = (0x100 << 5),
/*! @} */
/*! @{ */
/* H.264 Profiles. */
MFX_PROFILE_AVC_BASELINE =66,
MFX_PROFILE_AVC_MAIN =77,
MFX_PROFILE_AVC_EXTENDED =88,
MFX_PROFILE_AVC_HIGH =100,
MFX_PROFILE_AVC_HIGH10 =110,
MFX_PROFILE_AVC_HIGH_422 =122,
MFX_PROFILE_AVC_CONSTRAINED_BASELINE =MFX_PROFILE_AVC_BASELINE + MFX_PROFILE_AVC_CONSTRAINT_SET1,
MFX_PROFILE_AVC_CONSTRAINED_HIGH =MFX_PROFILE_AVC_HIGH + MFX_PROFILE_AVC_CONSTRAINT_SET4
+ MFX_PROFILE_AVC_CONSTRAINT_SET5,
MFX_PROFILE_AVC_PROGRESSIVE_HIGH =MFX_PROFILE_AVC_HIGH + MFX_PROFILE_AVC_CONSTRAINT_SET4,
/*! @} */
/*! @{ */
/* H.264 level 1-1.3 */
MFX_LEVEL_AVC_1 =10,
MFX_LEVEL_AVC_1b =9,
MFX_LEVEL_AVC_11 =11,
MFX_LEVEL_AVC_12 =12,
MFX_LEVEL_AVC_13 =13,
/*! @} */
/*! @{ */
/* H.264 level 2-2.2 */
MFX_LEVEL_AVC_2 =20,
MFX_LEVEL_AVC_21 =21,
MFX_LEVEL_AVC_22 =22,
/*! @} */
/*! @{ */
/* H.264 level 3-3.2 */
MFX_LEVEL_AVC_3 =30,
MFX_LEVEL_AVC_31 =31,
MFX_LEVEL_AVC_32 =32,
/*! @} */
/*! @{ */
/* H.264 level 4-4.2 */
MFX_LEVEL_AVC_4 =40,
MFX_LEVEL_AVC_41 =41,
MFX_LEVEL_AVC_42 =42,
/*! @} */
/*! @{ */
/* H.264 level 5-5.2 */
MFX_LEVEL_AVC_5 =50,
MFX_LEVEL_AVC_51 =51,
MFX_LEVEL_AVC_52 =52,
/*! @} */
/*! @{ */
/* H.264 level 6-6.2 */
MFX_LEVEL_AVC_6 =60,
MFX_LEVEL_AVC_61 =61,
MFX_LEVEL_AVC_62 =62,
/*! @} */
/*! @{ */
/* MPEG2 Profiles. */
MFX_PROFILE_MPEG2_SIMPLE =0x50,
MFX_PROFILE_MPEG2_MAIN =0x40,
MFX_PROFILE_MPEG2_HIGH =0x10,
/*! @} */
/*! @{ */
/* MPEG2 Levels. */
MFX_LEVEL_MPEG2_LOW =0xA,
MFX_LEVEL_MPEG2_MAIN =0x8,
MFX_LEVEL_MPEG2_HIGH =0x4,
MFX_LEVEL_MPEG2_HIGH1440 =0x6,
/*! @} */
/*! @{ */
/* VC-1 Profiles. */
MFX_PROFILE_VC1_SIMPLE =(0+1),
MFX_PROFILE_VC1_MAIN =(4+1),
MFX_PROFILE_VC1_ADVANCED =(12+1),
/*! @} */
/*! @{ */
/* VC-1 Level Low (simple & main profiles) */
MFX_LEVEL_VC1_LOW =(0+1),
MFX_LEVEL_VC1_MEDIAN =(2+1),
MFX_LEVEL_VC1_HIGH =(4+1),
/*! @} */
/*! @{ */
/* VC-1 advanced profile levels */
MFX_LEVEL_VC1_0 =(0x00+1),
MFX_LEVEL_VC1_1 =(0x01+1),
MFX_LEVEL_VC1_2 =(0x02+1),
MFX_LEVEL_VC1_3 =(0x03+1),
MFX_LEVEL_VC1_4 =(0x04+1),
/*! @} */
/*! @{ */
/* HEVC profiles */
MFX_PROFILE_HEVC_MAIN =1,
MFX_PROFILE_HEVC_MAIN10 =2,
MFX_PROFILE_HEVC_MAINSP =3,
MFX_PROFILE_HEVC_REXT =4,
MFX_PROFILE_HEVC_SCC =9,
/*! @} */
/*! @{ */
/* HEVC levels */
MFX_LEVEL_HEVC_1 = 10,
MFX_LEVEL_HEVC_2 = 20,
MFX_LEVEL_HEVC_21 = 21,
MFX_LEVEL_HEVC_3 = 30,
MFX_LEVEL_HEVC_31 = 31,
MFX_LEVEL_HEVC_4 = 40,
MFX_LEVEL_HEVC_41 = 41,
MFX_LEVEL_HEVC_5 = 50,
MFX_LEVEL_HEVC_51 = 51,
MFX_LEVEL_HEVC_52 = 52,
MFX_LEVEL_HEVC_6 = 60,
MFX_LEVEL_HEVC_61 = 61,
MFX_LEVEL_HEVC_62 = 62,
/*! @} */
/*! @{ */
/* HEVC tiers */
MFX_TIER_HEVC_MAIN = 0,
MFX_TIER_HEVC_HIGH = 0x100,
/*! @} */
/*! @{ */
/* VP9 Profiles */
MFX_PROFILE_VP9_0 = 1,
MFX_PROFILE_VP9_1 = 2,
MFX_PROFILE_VP9_2 = 3,
MFX_PROFILE_VP9_3 = 4,
/*! @} */
/*! @{ */
/* AV1 Profiles */
MFX_PROFILE_AV1_MAIN = 1,
MFX_PROFILE_AV1_HIGH = 2,
MFX_PROFILE_AV1_PRO = 3,
/*! @} */
/*! @{ */
/* AV1 Levels */
MFX_LEVEL_AV1_2 = 20,
MFX_LEVEL_AV1_21 = 21,
MFX_LEVEL_AV1_22 = 22,
MFX_LEVEL_AV1_23 = 23,
MFX_LEVEL_AV1_3 = 30,
MFX_LEVEL_AV1_31 = 31,
MFX_LEVEL_AV1_32 = 32,
MFX_LEVEL_AV1_33 = 33,
MFX_LEVEL_AV1_4 = 40,
MFX_LEVEL_AV1_41 = 41,
MFX_LEVEL_AV1_42 = 42,
MFX_LEVEL_AV1_43 = 43,
MFX_LEVEL_AV1_5 = 50,
MFX_LEVEL_AV1_51 = 51,
MFX_LEVEL_AV1_52 = 52,
MFX_LEVEL_AV1_53 = 53,
MFX_LEVEL_AV1_6 = 60,
MFX_LEVEL_AV1_61 = 61,
MFX_LEVEL_AV1_62 = 62,
MFX_LEVEL_AV1_63 = 63,
MFX_LEVEL_AV1_7 = 70,
MFX_LEVEL_AV1_71 = 71,
MFX_LEVEL_AV1_72 = 72,
MFX_LEVEL_AV1_73 = 73,
/*! @} */
};
/*! The GopOptFlag enumerator itemizes special properties in the GOP (Group of Pictures) sequence. */
enum {
/*!
The encoder generates closed GOP if this flag is set. Frames in this GOP do not use frames in previous GOP as reference.
The encoder generates open GOP if this flag is not set. In this GOP frames prior to the first frame of GOP in display order may use
frames from previous GOP as reference. Frames subsequent to the first frame of GOP in display order do not use frames from previous
GOP as reference.
The AVC encoder ignores this flag if IdrInterval in mfxInfoMFX structure is set to 0, i.e. if every GOP starts from IDR frame.
In this case, GOP is encoded as closed.
This flag does not affect long-term reference frames.
*/
MFX_GOP_CLOSED =1,
/*!
The encoder must strictly follow the given GOP structure as defined by parameter GopPicSize, GopRefDist etc in the mfxVideoParam structure.
Otherwise, the encoder can adapt the GOP structure for better efficiency, whose range is constrained by parameter GopPicSize and
GopRefDist etc. See also description of AdaptiveI and AdaptiveB fields in the mfxExtCodingOption2 structure.
*/
MFX_GOP_STRICT =2
};
/*! The TargetUsage enumerator itemizes a range of numbers from MFX_TARGETUSAGE_1, best quality, to MFX_TARGETUSAGE_7, best speed.
It indicates trade-offs between quality and speed. The application can use any number in the range. The actual number of supported
target usages depends on implementation. If specified target usage is not supported, the encoder will use the closest supported value. */
enum {
MFX_TARGETUSAGE_1 =1, /*!< Best quality */
MFX_TARGETUSAGE_2 =2,
MFX_TARGETUSAGE_3 =3,
MFX_TARGETUSAGE_4 =4, /*!< Balanced quality and speed. */
MFX_TARGETUSAGE_5 =5,
MFX_TARGETUSAGE_6 =6,
MFX_TARGETUSAGE_7 =7, /*!< Best speed */
MFX_TARGETUSAGE_UNKNOWN =0, /*!< Unspecified target usage. */
MFX_TARGETUSAGE_BEST_QUALITY =MFX_TARGETUSAGE_1, /*!< Best quality. */
MFX_TARGETUSAGE_BALANCED =MFX_TARGETUSAGE_4, /*!< Balanced quality and speed. */
MFX_TARGETUSAGE_BEST_SPEED =MFX_TARGETUSAGE_7 /*!< Best speed. */
};
/*! The RateControlMethod enumerator itemizes bitrate control methods. */
enum {
MFX_RATECONTROL_CBR =1, /*!< Use the constant bitrate control algorithm. */
MFX_RATECONTROL_VBR =2, /*!< Use the variable bitrate control algorithm. */
MFX_RATECONTROL_CQP =3, /*!< Use the constant quantization parameter algorithm. */
MFX_RATECONTROL_AVBR =4, /*!< Use the average variable bitrate control algorithm. */
MFX_RATECONTROL_RESERVED1 =5,
MFX_RATECONTROL_RESERVED2 =6,
MFX_RATECONTROL_RESERVED3 =100,
MFX_RATECONTROL_RESERVED4 =7,
/*!
Use the VBR algorithm with look ahead. It is a special bitrate control mode in the AVC encoder that has been designed
to improve encoding quality. It works by performing extensive analysis of several dozen frames before the actual encoding and as a side
effect significantly increases encoding delay and memory consumption.
The only available rate control parameter in this mode is mfxInfoMFX::TargetKbps. Two other parameters, MaxKbps and InitialDelayInKB,
are ignored. To control LA depth the application can use mfxExtCodingOption2::LookAheadDepth parameter.
This method is not HRD compliant.
*/
MFX_RATECONTROL_LA =8,
/*!
Use the Intelligent Constant Quality algorithm. This algorithm improves subjective video quality of encoded stream. Depending on content,
it may or may not decrease objective video quality. Only one control parameter is used - quality factor, specified by mfxInfoMFX::ICQQuality.
*/
MFX_RATECONTROL_ICQ =9,
/*!
Use the Video Conferencing Mode algorithm. This algorithm is similar to the VBR and uses the same set of parameters mfxInfoMFX::InitialDelayInKB,
TargetKbpsandMaxKbps. It is tuned for IPPP GOP pattern and streams with strong temporal correlation between frames.
It produces better objective and subjective video quality in these conditions than other bitrate control algorithms.
It does not support interlaced content, B-frames and produced stream is not HRD compliant.
*/
MFX_RATECONTROL_VCM =10,
/*!
Use Intelligent Constant Quality algorithm with look ahead. Quality factor is specified by mfxInfoMFX::ICQQuality.
To control LA depth the application can use mfxExtCodingOption2::LookAheadDepth parameter.
This method is not HRD compliant.
*/
MFX_RATECONTROL_LA_ICQ =11,
/*!
MFX_RATECONTROL_LA_EXT has been removed
*/
/*! Use HRD compliant look ahead rate control algorithm. */
MFX_RATECONTROL_LA_HRD =13,
/*!
Use the variable bitrate control algorithm with constant quality. This algorithm trying to achieve the target subjective quality with
the minimum number of bits, while the bitrate constraint and HRD compliance are satisfied. It uses the same set of parameters
as VBR and quality factor specified by mfxExtCodingOption3::QVBRQuality.
*/
MFX_RATECONTROL_QVBR =14,
};
/*!
The TrellisControl enumerator is used to control trellis quantization in AVC encoder. The application can turn it on
or off for any combination of I-, P- and B-frames by combining different enumerator values. For example, MFX_TRELLIS_I | MFX_TRELLIS_B
turns it on for I- and B-frames.
@note Due to performance reason on some target usages trellis quantization is always turned off and this control is ignored by the encoder.
*/
enum {
MFX_TRELLIS_UNKNOWN =0, /*!< Default value, it is up to the encoder to turn trellis quantization on or off. */
MFX_TRELLIS_OFF =0x01, /*!< Turn trellis quantization off for all frame types. */
MFX_TRELLIS_I =0x02, /*!< Turn trellis quantization on for I-frames. */
MFX_TRELLIS_P =0x04, /*!< Turn trellis quantization on for P-frames. */
MFX_TRELLIS_B =0x08 /*!< Turn trellis quantization on for B-frames. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Specifies additional options for encoding.
The application can attach this extended buffer to the mfxVideoParam structure to configure initialization.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_CODING_OPTION. */
mfxU16 reserved1;
mfxU16 RateDistortionOpt; /*!< Set this flag if rate distortion optimization is needed. See the CodingOptionValue enumerator for values of this option. */
mfxU16 MECostType; /*!< Motion estimation cost type. This value is reserved and must be zero. */
mfxU16 MESearchType; /*!< Motion estimation search algorithm. This value is reserved and must be zero. */
mfxI16Pair MVSearchWindow; /*!< Rectangular size of the search window for motion estimation. This parameter is reserved and must be (0, 0). */
MFX_DEPRECATED mfxU16 EndOfSequence; /* Deprecated */
mfxU16 FramePicture; /*!< Set this flag to encode interlaced fields as interlaced frames. This flag does not affect progressive input frames. See the CodingOptionValue enumerator for values of this option. */
mfxU16 CAVLC; /*!< If set, CAVLC is used; if unset, CABAC is used for encoding. See the CodingOptionValue enumerator for values of this option. */
mfxU16 reserved2[2];
/*!
Set this flag to insert the recovery point SEI message at the beginning of every intra refresh cycle. See the description of
IntRefType in mfxExtCodingOption2 structure for details on how to enable and configure intra refresh.
If intra refresh is not enabled then this flag is ignored.
See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 RecoveryPointSEI;
/*!
Set this flag to instruct the MVC encoder to output each view in separate bitstream buffer. See the CodingOptionValue enumerator
for values of this option and the Multi-View Video Coding section for more details about usage of this flag.
*/
mfxU16 ViewOutput;
/*!
If this option is turned ON, then AVC encoder produces an HRD conformant bitstream. If it is turned OFF, then the AVC encoder may (but not necessarily) violate HRD conformance. That is, this option can force the encoder to produce an HRD conformant stream, but
cannot force it to produce a non-conformant stream.
See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 NalHrdConformance;
/*!
If set, encoder puts all SEI messages in the singe NAL unit. It includes messages provided by application and created
by encoder. It is a three-states option. See CodingOptionValue enumerator for values of this option. The three states are:
@li UNKNOWN Put each SEI in its own NAL unit.
@li ON Put all SEI messages in the same NAL unit.
@li OFF The same as unknown.
*/
mfxU16 SingleSeiNalUnit;
/*!
If set and VBR rate control method is used, then VCL HRD parameters are written in bitstream with values identical to the values of the NAL HRD parameters.
See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 VuiVclHrdParameters;
mfxU16 RefPicListReordering; /*!< Set this flag to activate reference picture list reordering. This value is reserved and must be zero. */
mfxU16 ResetRefList; /*!< Set this flag to reset the reference list to non-IDR I-frames of a GOP sequence. See the CodingOptionValue enumerator for values of this option. */
/*!
Set this flag to write the reference picture marking repetition SEI message into the output bitstream.
See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 RefPicMarkRep;
/*!
Set this flag to instruct the AVC encoder to output bitstreams immediately after the encoder encodes a field,
in the field-encoding mode. See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 FieldOutput;
mfxU16 IntraPredBlockSize; /*!< Minimum block size of intra-prediction. This value is reserved and must be zero. */
mfxU16 InterPredBlockSize; /*!< Minimum block size of inter-prediction. This value is reserved and must be zero. */
mfxU16 MVPrecision; /*!< Specify the motion estimation precision. This parameter is reserved and must be zero. */
mfxU16 MaxDecFrameBuffering; /*!< Specifies the maximum number of frames buffered in a DPB. A value of zero means unspecified. */
mfxU16 AUDelimiter; /*!< Set this flag to insert the Access Unit Delimiter NAL. See the CodingOptionValue enumerator for values of this option. */
MFX_DEPRECATED mfxU16 EndOfStream; /* Deprecated */
/*!
Set this flag to insert the picture timing SEI with pic_struct syntax element. See sub-clauses D.1.2 and D.2.2 of the ISO/IEC 14496-10
specification for the definition of this syntax element. See the CodingOptionValue enumerator for values of this option.
The default value is ON.
*/
mfxU16 PicTimingSEI;
mfxU16 VuiNalHrdParameters; /*!< Set this flag to insert NAL HRD parameters in the VUI header. See the CodingOptionValue enumerator for values of this option. */
} mfxExtCodingOption;
MFX_PACK_END()
/*! The BRefControl enumerator is used to control usage of B-frames as reference in AVC encoder. */
enum {
MFX_B_REF_UNKNOWN = 0, /*!< Default value, it is up to the encoder to use B-frames as reference. */
MFX_B_REF_OFF = 1, /*!< Do not use B-frames as reference. */
MFX_B_REF_PYRAMID = 2 /*!< Arrange B-frames in so-called "B pyramid" reference structure. */
};
/*! The LookAheadDownSampling enumerator is used to control down sampling in look ahead bitrate control mode in AVC encoder. */
enum {
MFX_LOOKAHEAD_DS_UNKNOWN = 0, /*!< Default value, it is up to the encoder what down sampling value to use. */
MFX_LOOKAHEAD_DS_OFF = 1, /*!< Do not use down sampling, perform estimation on original size frames. This is the slowest setting that produces the best quality. */
MFX_LOOKAHEAD_DS_2x = 2, /*!< Down sample frames two times before estimation. */
MFX_LOOKAHEAD_DS_4x = 3 /*!< Down sample frames four times before estimation. This option may significantly degrade quality. */
};
/*! The BPSEIControl enumerator is used to control insertion of buffering period SEI in the encoded bitstream. */
enum {
MFX_BPSEI_DEFAULT = 0x00, /*!< encoder decides when to insert BP SEI. */
MFX_BPSEI_IFRAME = 0x01 /*!< BP SEI should be inserted with every I-frame */
};
/*! The SkipFrame enumerator is used to define usage of mfxEncodeCtrl::SkipFrame parameter. */
enum {
MFX_SKIPFRAME_NO_SKIP = 0, /*!< Frame skipping is disabled, mfxEncodeCtrl::SkipFrame is ignored. */
MFX_SKIPFRAME_INSERT_DUMMY = 1, /*!< Skipping is allowed, when mfxEncodeCtrl::SkipFrame is set encoder inserts into bitstream frame
where all macroblocks are encoded as skipped. Only non-reference P- and B-frames can be skipped.
If GopRefDist = 1 and mfxEncodeCtrl::SkipFrame is set for reference P-frame, it will be encoded
as non-reference. */
MFX_SKIPFRAME_INSERT_NOTHING = 2, /*!< Similar to MFX_SKIPFRAME_INSERT_DUMMY, but when mfxEncodeCtrl::SkipFrame is set encoder inserts nothing into bitstream. */
MFX_SKIPFRAME_BRC_ONLY = 3, /*!< mfxEncodeCtrl::SkipFrame indicates number of missed frames before the current frame. Affects only BRC, current frame will be encoded as usual. */
};
/*! The IntraRefreshTypes enumerator itemizes types of intra refresh. */
enum {
MFX_REFRESH_NO = 0, /*!< Encode without refresh. */
MFX_REFRESH_VERTICAL = 1, /*!< Vertical refresh, by column of MBs. */
MFX_REFRESH_HORIZONTAL = 2, /*!< Horizontal refresh, by rows of MBs. */
MFX_REFRESH_SLICE = 3 /*!< Horizontal refresh by slices without overlapping. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used with the mfxExtCodingOption structure to specify additional options for encoding.
The application can attach this extended buffer to the mfxVideoParam structure to configure initialization and to the mfxEncodeCtrl during runtime.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_CODING_OPTION2. */
/*!
Specifies intra refresh type. See the IntraRefreshTypes. The major goal of intra refresh is improvement of error resilience without
significant impact on encoded bitstream size caused by I-frames. The encoder achieves this by encoding part of each frame in the refresh
cycle using intra MBs.
This parameter is valid during initialization and
runtime. When used with temporal scalability, intra refresh applied only to base layer.
MFX_REFRESH_NO No refresh.
MFX_REFRESH_VERTICAL Vertical refresh, by column of MBs.
MFX_REFRESH_HORIZONTAL Horizontal refresh, by rows of MBs.
MFX_REFRESH_SLICE Horizontal refresh by slices without overlapping.
MFX_REFRESH_SLICE Library ignores IntRefCycleSize (size of refresh cycle equals number slices).
*/
mfxU16 IntRefType;
/*!
Specifies number of pictures within refresh cycle starting from 2. 0 and 1 are invalid values. This parameter is valid only during initialization.
*/
mfxU16 IntRefCycleSize;
/*!
Specifies QP difference for inserted intra MBs. Signed values are in the -51 to 51 range. This parameter is valid during initialization and runtime.
*/
mfxI16 IntRefQPDelta;
/*!
Specify maximum encoded frame size in byte. This parameter is used in VBR based bitrate control modes and ignored in others.
The encoder tries to keep frame size below specified limit but minor overshoots are possible to preserve visual quality.
This parameter is valid during initialization and runtime. It is recommended to set MaxFrameSize to 5x-10x target frame size
((TargetKbps*1000)/(8* FrameRateExtN/FrameRateExtD)) for I-frames and 2x-4x target frame size for P- and B-frames.
*/
mfxU32 MaxFrameSize;
/*!
Specify maximum slice size in bytes. If this parameter is specified other controls over number of slices are ignored.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported.
*/
mfxU32 MaxSliceSize;
/*!
Modifies bitrate to be in the range imposed by the encoder. The default value is ON, that is, bitrate is limited. Setting this flag to OFF may lead to violation of HRD conformance.Specifying bitrate below the encoder range might significantly affect quality.
If set to ON, this option takes effect in non CQP modes:
if TargetKbps is not in the range imposed by the encoder, it will be changed to be in the range.
This parameter is valid only during initialization. Flag works with MFX_CODEC_AVC only, it is ignored with other codecs.
See the CodingOptionValue
enumerator for values of this option.
@deprecated Deprecated in API version 2.9
*/
MFX_DEPRECATED mfxU16 BitrateLimit; /* Deprecated */
/*!
Setting this flag enables macroblock level bitrate control that generally improves subjective visual quality. Enabling this flag may
have negative impact on performance and objective visual quality metric. See the CodingOptionValue enumerator for values of this option.
The default value depends on target usage settings.
*/
mfxU16 MBBRC;
/*!
Set this option to ON to enable external BRC. See the CodingOptionValue enumerator for values of this option.
Use the Query API function to check if this feature is supported.
*/
mfxU16 ExtBRC;
/*!
Specifies the depth of the look ahead rate control algorithm. The depth value is the number of frames that the encoder analyzes before encoding. Values are in the 10 to 100 range, inclusive.
To instruct the encoder to use the default value the application should zero this field.
*/
mfxU16 LookAheadDepth;
/*!
Used to control trellis quantization in AVC encoder. See TrellisControl enumerator for values of this option.
This parameter is valid only during initialization.
*/
mfxU16 Trellis;
/*!
Controls picture parameter set repetition in AVC encoder. Set this flag to ON to repeat PPS with each frame.
See the CodingOptionValue enumerator for values of this option. The default value is ON. This parameter is valid only during initialization.
*/
mfxU16 RepeatPPS;
/*!
Controls usage of B-frames as reference. See BRefControl enumerator for values of this option.
This parameter is valid only during initialization.
*/
mfxU16 BRefType;
/*!
Controls insertion of I-frames by the encoder. Set this flag to ON to allow changing of frame type from P and B to I.
This option is ignored if GopOptFlag in mfxInfoMFX structure is equal to MFX_GOP_STRICT. See the CodingOptionValue enumerator
for values of this option. This parameter is valid only during initialization.
*/
mfxU16 AdaptiveI;
/*!
Controls changing of frame type from B to P. Set this flag to ON enable changing of frame type from B to P. This option is ignored if
GopOptFlag in mfxInfoMFX structure is equal to MFX_GOP_STRICT. See the CodingOptionValue enumerator for values of this option.
This parameter is valid only during initialization.
*/
mfxU16 AdaptiveB;
/*!
Controls down sampling in look ahead bitrate control mode. See LookAheadDownSampling enumerator for values
of this option. This parameter is valid only during initialization.
*/
mfxU16 LookAheadDS;
/*!
Specifies suggested slice size in number of macroblocks. The library can adjust this number based on platform capability.
If this option is specified, that is, if it is not equal to zero, the library ignores mfxInfoMFX::NumSlice parameter.
*/
mfxU16 NumMbPerSlice;
/*!
Enables usage of mfxEncodeCtrl::SkipFrame parameter. See the SkipFrame enumerator for values of this option.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported.
*/
mfxU16 SkipFrame;
mfxU8 MinQPI; /*!< Minimum allowed QP value for I-frame types. Valid range is 1 to 51 inclusive. Zero means default value, that is, no limitations on QP.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported. */
mfxU8 MaxQPI; /*!< Maximum allowed QP value for I-frame types. Valid range is 1 to 51 inclusive. Zero means default value, that is, no limitations on QP.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported. */
mfxU8 MinQPP; /*!< Minimum allowed QP value for P-frame types. Valid range is 1 to 51 inclusive. Zero means default value, that is, no limitations on QP.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported. */
mfxU8 MaxQPP; /*!< Maximum allowed QP value for P-frame types. Valid range is 1 to 51 inclusive. Zero means default value, that is, no limitations on QP.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported. */
mfxU8 MinQPB; /*!< Minimum allowed QP value for B-frame types. Valid range is 1 to 51 inclusive. Zero means default value, that is, no limitations on QP.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported. */
mfxU8 MaxQPB; /*!< Maximum allowed QP value for B-frame types. Valid range is 1 to 51 inclusive. Zero means default value, that is, no limitations on QP.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported. */
/*!
Sets fixed_frame_rate_flag in VUI.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported.
*/
mfxU16 FixedFrameRate;
/*! Disables deblocking.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported.
*/
mfxU16 DisableDeblockingIdc;
/*!
Completely disables VUI in the output bitstream.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported.
*/
mfxU16 DisableVUI;
/*!
Controls insertion of buffering period SEI in the encoded bitstream. It should be one of the following values:
MFX_BPSEI_DEFAULT Encoder decides when to insert BP SEI,
MFX_BPSEI_IFRAME BP SEI should be inserted with every I-frame.
*/
mfxU16 BufferingPeriodSEI;
/*!
Set this flag to ON to enable per-frame reporting of Mean Absolute Difference. This parameter is valid only during initialization.
*/
mfxU16 EnableMAD;
/*!
Set this flag to ON to use raw frames for reference instead of reconstructed frames. This parameter is valid during
initialization and runtime (only if was turned ON during initialization).
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported.
*/
mfxU16 UseRawRef;
} mfxExtCodingOption2;
MFX_PACK_END()
/*! The WeightedPred enumerator itemizes weighted prediction modes. */
enum {
MFX_WEIGHTED_PRED_UNKNOWN = 0, /*!< Allow encoder to decide. */
MFX_WEIGHTED_PRED_DEFAULT = 1, /*!< Use default weighted prediction. */
MFX_WEIGHTED_PRED_EXPLICIT = 2, /*!< Use explicit weighted prediction. */
MFX_WEIGHTED_PRED_IMPLICIT = 3 /*!< Use implicit weighted prediction (for B-frames only). */
};
/*! The ScenarioInfo enumerator itemizes scenarios for the encoding session. */
enum {
MFX_SCENARIO_UNKNOWN = 0,
MFX_SCENARIO_DISPLAY_REMOTING = 1,
MFX_SCENARIO_VIDEO_CONFERENCE = 2,
MFX_SCENARIO_ARCHIVE = 3,
MFX_SCENARIO_LIVE_STREAMING = 4,
MFX_SCENARIO_CAMERA_CAPTURE = 5,
MFX_SCENARIO_VIDEO_SURVEILLANCE = 6,
MFX_SCENARIO_GAME_STREAMING = 7,
MFX_SCENARIO_REMOTE_GAMING = 8
};
/*! The ContentInfo enumerator itemizes content types for the encoding session. */
enum {
MFX_CONTENT_UNKNOWN = 0,
MFX_CONTENT_FULL_SCREEN_VIDEO = 1,
MFX_CONTENT_NON_VIDEO_SCREEN = 2,
#ifdef ONEVPL_EXPERIMENTAL
MFX_CONTENT_NOISY_VIDEO = 3
#endif
};
/*! The PRefType enumerator itemizes models of reference list construction and DPB management when GopRefDist=1. */
enum {
MFX_P_REF_DEFAULT = 0, /*!< Allow encoder to decide. */
MFX_P_REF_SIMPLE = 1, /*!< Regular sliding window used for DPB removal process. */
MFX_P_REF_PYRAMID = 2 /*!< Let N be the max reference list's size. Encoder treats each N's frame as a 'strong'
reference and the others as 'weak' references. The encoder uses a 'weak' reference only for
prediction of the next frame and removes it from DPB immediately after use. 'Strong' references are removed from
DPB by a sliding window. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used with mfxExtCodingOption and mfxExtCodingOption2 structures to specify additional options for encoding.
The application can attach this extended buffer to the mfxVideoParam structure to configure initialization and to the mfxEncodeCtrl during runtime.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_CODING_OPTION3. */
mfxU16 NumSliceI; /*!< The number of slices for I-frames.
@note Not all codecs and implementations support these values. Use the Query API function to check if this feature is supported */
mfxU16 NumSliceP; /*!< The number of slices for P-frames.
@note Not all codecs and implementations support these values. Use the Query API function to check if this feature is supported */
mfxU16 NumSliceB; /*!< The number of slices for B-frames.
@note Not all codecs and implementations support these values. Use the Query API function to check if this feature is supported */
/*!
When rate control method is MFX_RATECONTROL_VBR, MFX_RATECONTROL_LA, MFX_RATECONTROL_LA_HRD, or MFX_RATECONTROL_QVBR this parameter
specifies the maximum bitrate averaged over a sliding window specified by WinBRCSize. For MFX_RATECONTROL_CBR this parameter is ignored and
equals TargetKbps.
*/
mfxU16 WinBRCMaxAvgKbps;
/*!
When rate control method is MFX_RATECONTROL_CBR, MFX_RATECONTROL_VBR, MFX_RATECONTROL_LA, MFX_RATECONTROL_LA_HRD, or MFX_RATECONTROL_QVBR
this parameter specifies sliding window size in frames. Set this parameter to zero to disable sliding window.
*/
mfxU16 WinBRCSize;
/*! When rate control method is MFX_RATECONTROL_QVBR, this parameter specifies quality factor.
Values are in the 1 to 51 range, where 1 corresponds to the best quality.
*/
mfxU16 QVBRQuality;
/*!
Set this flag to ON to enable per-macroblock QP control. Rate control method must be MFX_RATECONTROL_CQP. See the CodingOptionValue
enumerator for values of this option. This parameter is valid only during initialization.
*/
mfxU16 EnableMBQP;
/*!
Distance between the beginnings of the intra-refresh cycles in frames. Zero means no distance between cycles.
*/
mfxU16 IntRefCycleDist;
/*!
Set this flag to ON to enable the ENC mode decision algorithm to bias to fewer B Direct/Skip types. Applies only to B-frames,
all other frames will ignore this setting. See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 DirectBiasAdjustment;
/*!
Enables global motion bias. See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 GlobalMotionBiasAdjustment;
/*!
Values are:
@li 0: Set MV cost to be 0.
@li 1: Scale MV cost to be 1/2 of the default value.
@li 2: Scale MV cost to be 1/4 of the default value.
@li 3: Scale MV cost to be 1/8 of the default value.
*/
mfxU16 MVCostScalingFactor;
/*!
Set this flag to ON to enable usage of mfxExtMBDisableSkipMap. See the CodingOptionValue enumerator for values of this option.
This parameter is valid only during initialization.
*/
mfxU16 MBDisableSkipMap;
mfxU16 WeightedPred; /*!< Weighted prediction mode. See the WeightedPred enumerator for values of these options. */
mfxU16 WeightedBiPred; /*!< Weighted prediction mode. See the WeightedPred enumerator for values of these options. */
/*!
Instructs encoder whether aspect ratio info should present in VUI parameters. See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 AspectRatioInfoPresent;
/*!
Instructs encoder whether overscan info should present in VUI parameters. See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 OverscanInfoPresent;
/*!
ON indicates that the cropped decoded pictures output are suitable for display using overscan. OFF indicates that the cropped decoded
pictures output contain visually important information in the entire region out to the edges of the cropping rectangle of the picture.
See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 OverscanAppropriate;
/*!
Instructs encoder whether frame rate info should present in VUI parameters. See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 TimingInfoPresent;
/*!
Instructs encoder whether bitstream restriction info should present in VUI parameters. See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 BitstreamRestriction;
/*!
Corresponds to AVC syntax element low_delay_hrd_flag (VUI). See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 LowDelayHrd;
/*!
When set to OFF, no sample outside the picture boundaries and no sample at a fractional sample position for which the sample value
is derived using one or more samples outside the picture boundaries is used for inter prediction of any sample.
When set to ON, one or more samples outside picture boundaries may be used in inter prediction.
See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 MotionVectorsOverPicBoundaries;
mfxU16 reserved1[2];
mfxU16 ScenarioInfo; /*!< Provides a hint to encoder about the scenario for the encoding session. See the ScenarioInfo enumerator for values of this option. */
mfxU16 ContentInfo; /*!< Provides a hint to encoder about the content for the encoding session. See the ContentInfo enumerator for values of this option. */
mfxU16 PRefType; /*!< When GopRefDist=1, specifies the model of reference list construction and DPB management. See the PRefType enumerator for values of this option. */
/*!
Instructs encoder whether internal fade detection algorithm should be used for calculation of weigh/offset values for pred_weight_table
unless application provided mfxExtPredWeightTable for this frame. See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 FadeDetection;
mfxU16 reserved2[2];
/*!
Set this flag to OFF to make HEVC encoder use regular P-frames instead of GPB. See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 GPB;
/*!
Same as mfxExtCodingOption2::MaxFrameSize but affects only I-frames. MaxFrameSizeI must be set if MaxFrameSizeP is set.
If MaxFrameSizeI is not specified or greater than spec limitation, spec limitation will be applied to the sizes of I-frames.
*/
mfxU32 MaxFrameSizeI;
/*!
Same as mfxExtCodingOption2::MaxFrameSize but affects only P/B-frames. If MaxFrameSizeP equals 0, the library sets MaxFrameSizeP
equal to MaxFrameSizeI. If MaxFrameSizeP is not specified or greater than spec limitation, spec limitation will be applied to the
sizes of P/B-frames.
*/
mfxU32 MaxFrameSizeP;
mfxU32 reserved3[3];
/*!
Enables QPOffset control. See the CodingOptionValue enumerator for values of this option.
*/
mfxU16 EnableQPOffset;
/*!
Specifies QP offset per pyramid layer when EnableQPOffset is set to ON and RateControlMethod is CQP.
For B-pyramid, B-frame QP = QPB + QPOffset[layer].
For P-pyramid, P-frame QP = QPP + QPOffset[layer].
*/
mfxI16 QPOffset[8]; /* FrameQP = QPX + QPOffset[pyramid_layer]; QPX = QPB for B-pyramid, QPP for P-pyramid */
mfxU16 NumRefActiveP[8]; /*!< Max number of active references for P-frames. Array index is pyramid layer. */
mfxU16 NumRefActiveBL0[8]; /*!< Max number of active references for B-frames in reference picture list 0. Array index is pyramid layer. */
mfxU16 NumRefActiveBL1[8]; /*!< Max number of active references for B-frames in reference picture list 1. Array index is pyramid layer. */
mfxU16 reserved6;
/*!
For HEVC if this option is turned ON, the transform_skip_enabled_flag will be set to 1 in PPS. OFF specifies that transform_skip_enabled_flag will be set to 0.
*/
mfxU16 TransformSkip;
/*!
Minus 1 specifies target encoding chroma format (see ChromaFormatIdc enumerator). May differ from the source format.
TargetChromaFormatPlus1 = 0 specifies the default target chroma format which is equal to source (mfxVideoParam::mfx::FrameInfo::ChromaFormat + 1),
except RGB4 source format. In case of RGB4 source format default target , chroma format is 4:2:0 (instead of 4:4:4)
for the purpose of backward compatibility.
*/
mfxU16 TargetChromaFormatPlus1;
/*!
Target encoding bit-depth for luma samples. May differ from source bit-depth. 0 specifies a default target bit-depth that is equal to
source (mfxVideoParam::mfx::FrameInfo::BitDepthLuma).
*/
mfxU16 TargetBitDepthLuma;
/*!
Target encoding bit-depth for chroma samples. May differ from source bit-depth. 0 specifies a default target bit-depth that is equal to
source (mfxVideoParam::mfx::FrameInfo::BitDepthChroma).
*/
mfxU16 TargetBitDepthChroma;
mfxU16 BRCPanicMode; /*!< Controls panic mode in AVC and MPEG2 encoders. */
/*!
When rate control method is MFX_RATECONTROL_VBR, MFX_RATECONTROL_QVBR or MFX_RATECONTROL_VCM this parameter specifies frame size
tolerance. Set this parameter to MFX_CODINGOPTION_ON to allow strictly obey average frame size set by MaxKbps, for example cases when
MaxFrameSize == (MaxKbps*1000)/(8* FrameRateExtN/FrameRateExtD). Also MaxFrameSizeI and MaxFrameSizeP can be set separately.
*/
mfxU16 LowDelayBRC;
/*!
Set this flag to ON to enable usage of mfxExtMBForceIntra for AVC encoder. See the CodingOptionValue enumerator
for values of this option. This parameter is valid only during initialization.
*/
mfxU16 EnableMBForceIntra;
/*!
If this flag is set to ON, BRC may decide a larger P- or B-frame size than what MaxFrameSizeP dictates when the scene change is detected.
It may benefit the video quality. AdaptiveMaxFrameSize feature is not supported with LowPower ON or if the value of MaxFrameSizeP = 0.
*/
mfxU16 AdaptiveMaxFrameSize;
/*!
Controls AVC encoder attempts to predict from small partitions. Default value allows encoder to choose preferred mode.
MFX_CODINGOPTION_ON forces encoder to favor quality and MFX_CODINGOPTION_OFF forces encoder to favor performance.
*/
mfxU16 RepartitionCheckEnable;
mfxU16 reserved5[3];
mfxU16 EncodedUnitsInfo; /*!< Set this flag to ON to make encoded units info available in mfxExtEncodedUnitsInfo. */
/*!
If this flag is set to ON, the HEVC encoder uses the NAL unit type provided by the application in the mfxEncodeCtrl::MfxNalUnitType field.
This parameter is valid only during initialization.
@note Not all codecs and implementations support this value. Use the Query API function to check if this feature is supported.
*/
mfxU16 EnableNalUnitType;
union {
MFX_DEPRECATED mfxU16 ExtBrcAdaptiveLTR; /* Deprecated */
/*!
If this flag is set to ON, encoder will mark, modify, or remove LTR frames based on encoding parameters and content
properties. Turn OFF to prevent Adaptive marking of Long Term Reference Frames.
*/
mfxU16 AdaptiveLTR;
};
/*!
If this flag is set to ON, encoder adaptively selects one of implementation-defined quantization matrices for each frame.
Non-default quantization matrices aim to improve subjective visual quality under certain conditions.
Their number and definitions are API implementation specific.
If this flag is set to OFF, default quantization matrix is used for all frames.
This parameter is valid only during initialization.
*/
mfxU16 AdaptiveCQM;
/*!
If this flag is set to ON, encoder adaptively selects list of reference frames to improve encoding quality.
Enabling of the flag can increase computation complexity and introduce additional delay.
If this flag is set to OFF, regular reference frames are used for encoding.
*/
mfxU16 AdaptiveRef;
#ifdef ONEVPL_EXPERIMENTAL
/*!
The tri-state option specifies hint for the library to execute encoding tools processing on CPU.
It may give better encoding quality, but leads to higher CPU utilization.
The library can ignore MFX_CODINGOPTION_ON if processing on CPU is not supported.
*/
mfxU16 CPUEncToolsProcessing;
mfxU16 reserved[160];
#else
mfxU16 reserved[161];
#endif
} mfxExtCodingOption3;
MFX_PACK_END()
/*! IntraPredBlockSize/InterPredBlockSize specifies the minimum block size of inter-prediction. */
enum {
MFX_BLOCKSIZE_UNKNOWN = 0, /*!< Unspecified. */
MFX_BLOCKSIZE_MIN_16X16 = 1, /*!< 16x16 minimum block size. */
MFX_BLOCKSIZE_MIN_8X8 = 2, /*!< 8x8 minimum block size. May be 16x16 or 8x8. */
MFX_BLOCKSIZE_MIN_4X4 = 3 /*!< 4x4 minimum block size. May be 16x16, 8x8, or 4x4. */
};
/*! The MVPrecision enumerator specifies the motion estimation precision. */
enum {
MFX_MVPRECISION_UNKNOWN = 0,
MFX_MVPRECISION_INTEGER = (1 << 0),
MFX_MVPRECISION_HALFPEL = (1 << 1),
MFX_MVPRECISION_QUARTERPEL = (1 << 2)
};
/*! The CodingOptionValue enumerator defines a three-state coding option setting. */
enum {
MFX_CODINGOPTION_UNKNOWN =0, /*!< Unspecified. */
MFX_CODINGOPTION_ON =0x10, /*!< Coding option set. */
MFX_CODINGOPTION_OFF =0x20, /*!< Coding option not set. */
MFX_CODINGOPTION_ADAPTIVE =0x30 /*!< Reserved. */
};
/*! The BitstreamDataFlag enumerator uses bit-ORed values to itemize additional information about the bitstream buffer. */
enum {
MFX_BITSTREAM_NO_FLAG = 0x0000, /*!< The bitstream doesn't contain any flags. */
/*!
The bitstream buffer contains a complete frame or complementary field pair of data for the bitstream. For decoding, this means
that the decoder can proceed with this buffer without waiting for the start of the next frame, which effectively reduces decoding latency.
If this flag is set, but the bitstream buffer contains incomplete frame or pair of field, then decoder will produce corrupted output.
*/
MFX_BITSTREAM_COMPLETE_FRAME = 0x0001,
/*!
The bitstream buffer contains the end of the stream. For decoding,
this means that the application does not have any additional bitstream data to send to decoder.
*/
MFX_BITSTREAM_EOS = 0x0002
};
/*! The ExtendedBufferID enumerator itemizes and defines identifiers (BufferId) for extended buffers or video processing algorithm identifiers. */
enum {
/*!
This extended buffer defines additional encoding controls. See the mfxExtCodingOption structure for details.
The application can attach this buffer to the structure for encoding initialization.
*/
MFX_EXTBUFF_CODING_OPTION = MFX_MAKEFOURCC('C','D','O','P'),
/*!
This extended buffer defines sequence header and picture header for encoders and decoders. See the mfxExtCodingOptionSPSPPS
structure for details. The application can attach this buffer to the mfxVideoParam structure for encoding initialization,
and for obtaining raw headers from the decoders and encoders.
*/
MFX_EXTBUFF_CODING_OPTION_SPSPPS = MFX_MAKEFOURCC('C','O','S','P'),
/*!
This extended buffer defines a list of VPP algorithms that applications should not use. See the mfxExtVPPDoNotUse structure
for details. The application can attach this buffer to the mfxVideoParam structure for video processing initialization.
*/
MFX_EXTBUFF_VPP_DONOTUSE = MFX_MAKEFOURCC('N','U','S','E'),
/*!
This extended buffer defines auxiliary information at the VPP output. See the mfxExtVppAuxData structure for details. The application
can attach this buffer to the mfxEncodeCtrl structure for per-frame encoding control.
*/
MFX_EXTBUFF_VPP_AUXDATA = MFX_MAKEFOURCC('A','U','X','D'),
/*!
The extended buffer defines control parameters for the VPP denoise filter algorithm. See the mfxExtVPPDenoise2 structure for details.
The application can attach this buffer to the mfxVideoParam structure for video processing initialization.
*/
MFX_EXTBUFF_VPP_DENOISE2 = MFX_MAKEFOURCC('D','N','I','2'),
MFX_DEPRECATED_ENUM_FIELD_INSIDE(MFX_EXTBUFF_VPP_DENOISE) = MFX_MAKEFOURCC('D','N','I','S'), /*!< Deprecated in 2.2 API version.*/
MFX_EXTBUFF_VPP_SCENE_ANALYSIS = MFX_MAKEFOURCC('S','C','L','Y'), /*!< Reserved for future use. */
MFX_DEPRECATED_ENUM_FIELD_INSIDE(MFX_EXTBUFF_VPP_SCENE_CHANGE) = MFX_EXTBUFF_VPP_SCENE_ANALYSIS, /* Deprecated. */
/*!
The extended buffer defines control parameters for the VPP ProcAmp filter algorithm. See the mfxExtVPPProcAmp structure for details.
The application can attach this buffer to the mfxVideoParam structure for video processing initialization or to the mfxFrameData
structure in the mfxFrameSurface1 structure of output surface for per-frame processing configuration.
*/
MFX_EXTBUFF_VPP_PROCAMP = MFX_MAKEFOURCC('P','A','M','P'),
/*!
The extended buffer defines control parameters for the VPP detail filter algorithm. See the mfxExtVPPDetail structure for details.
The application can attach this buffer to the structure for video processing initialization.
*/
MFX_EXTBUFF_VPP_DETAIL = MFX_MAKEFOURCC('D','E','T',' '),
/*!
This extended buffer defines video signal type. See the mfxExtVideoSignalInfo structure for details. The application can attach this
buffer to the mfxVideoParam structure for encoding initialization, and for retrieving such information from the decoders. If video
signal info changes per frame, the application can attach this buffer to the mfxFrameData structure for video processing.
*/
MFX_EXTBUFF_VIDEO_SIGNAL_INFO = MFX_MAKEFOURCC('V','S','I','N'),
/*!
This extended buffer defines video signal type. See the mfxExtVideoSignalInfo structure for details. The application can attach this
buffer to the mfxVideoParam structure for the input of video processing if the input video signal information changes in sequence
base.
*/
MFX_EXTBUFF_VIDEO_SIGNAL_INFO_IN = MFX_MAKEFOURCC('V','S','I','I'),
/*!
This extended buffer defines video signal type. See the mfxExtVideoSignalInfo structure for details. The application can attach this
buffer to the mfxVideoParam structure for the output of video processing if the output video signal information changes in sequence
base.
*/
MFX_EXTBUFF_VIDEO_SIGNAL_INFO_OUT = MFX_MAKEFOURCC('V','S','I','O'),
/*!
This extended buffer defines a list of VPP algorithms that applications should use. See the mfxExtVPPDoUse structure for details.
The application can attach this buffer to the structure for video processing initialization.
*/
MFX_EXTBUFF_VPP_DOUSE = MFX_MAKEFOURCC('D','U','S','E'),
/*!
This extended buffer defines additional encoding controls for reference list. See the mfxExtAVCRefListCtrl structure for details.
The application can attach this buffer to the mfxVideoParam structure for encoding & decoding initialization, or the mfxEncodeCtrl
structure for per-frame encoding configuration.
*/
MFX_EXTBUFF_AVC_REFLIST_CTRL = MFX_MAKEFOURCC('R','L','S','T'),
/*!
This extended buffer defines control parameters for the VPP frame rate conversion algorithm. See the mfxExtVPPFrameRateConversion structure
for details. The application can attach this buffer to the mfxVideoParam structure for video processing initialization.
*/
MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION = MFX_MAKEFOURCC('F','R','C',' '),
/*!
This extended buffer configures the H.264 picture timing SEI message. See the mfxExtPictureTimingSEI structure for details.
The application can attach this buffer to the mfxVideoParam structure for encoding initialization, or the mfxEncodeCtrl structure
for per-frame encoding configuration.
*/
MFX_EXTBUFF_PICTURE_TIMING_SEI = MFX_MAKEFOURCC('P','T','S','E'),
/*!
This extended buffer configures the structure of temporal layers inside the encoded H.264 bitstream. See the mfxExtAvcTemporalLayers
structure for details. The application can attach this buffer to the mfxVideoParam structure for encoding initialization.
*/
MFX_EXTBUFF_AVC_TEMPORAL_LAYERS = MFX_MAKEFOURCC('A','T','M','L'),
/*!
This extended buffer defines additional encoding controls. See the mfxExtCodingOption2 structure for details.
The application can attach this buffer to the structure for encoding initialization.
*/
MFX_EXTBUFF_CODING_OPTION2 = MFX_MAKEFOURCC('C','D','O','2'),
/*!
This extended buffer defines control parameters for the VPP image stabilization filter algorithm. See the mfxExtVPPImageStab structure
for details. The application can attach this buffer to the mfxVideoParam structure for video processing initialization.
*/
MFX_EXTBUFF_VPP_IMAGE_STABILIZATION = MFX_MAKEFOURCC('I','S','T','B'),
/*!
This extended buffer is used to retrieve encoder capability. See the mfxExtEncoderCapability structure for details.
The application can attach this buffer to the mfxVideoParam structure before calling MFXVideoENCODE_Query function.
*/
MFX_EXTBUFF_ENCODER_CAPABILITY = MFX_MAKEFOURCC('E','N','C','P'),
/*!
This extended buffer is used to control encoder reset behavior and also to query possible encoder reset outcome.
See the mfxExtEncoderResetOption structure for details. The application can attach this buffer to the mfxVideoParam structure
before calling MFXVideoENCODE_Query or MFXVideoENCODE_Reset functions.
*/
MFX_EXTBUFF_ENCODER_RESET_OPTION = MFX_MAKEFOURCC('E','N','R','O'),
/*!
This extended buffer is used by the encoder to report additional information about encoded picture.
See the mfxExtAVCEncodedFrameInfo structure for details. The application can attach this buffer to the mfxBitstream structure
before calling MFXVideoENCODE_EncodeFrameAsync function.
*/
MFX_EXTBUFF_ENCODED_FRAME_INFO = MFX_MAKEFOURCC('E','N','F','I'),
/*!
This extended buffer is used to control composition of several input surfaces in the one output. In this mode,
the VPP skips any other filters. The VPP returns error if any mandatory filter is specified and filter skipped warning
for optional filter. The only supported filters are deinterlacing and interlaced scaling.
*/
MFX_EXTBUFF_VPP_COMPOSITE = MFX_MAKEFOURCC('V','C','M','P'),
/*!
This extended buffer is used to control transfer matrix and nominal range of YUV frames.
The application should provide it during initialization.
*/
MFX_EXTBUFF_VPP_VIDEO_SIGNAL_INFO = MFX_MAKEFOURCC('V','V','S','I'),
/*!
This extended buffer is used by the application to specify different Region Of Interests during encoding.
The application should provide it at initialization or at runtime.
*/
MFX_EXTBUFF_ENCODER_ROI = MFX_MAKEFOURCC('E','R','O','I'),
/*!
This extended buffer is used by the application to specify different deinterlacing algorithms.
*/
MFX_EXTBUFF_VPP_DEINTERLACING = MFX_MAKEFOURCC('V','P','D','I'),
/*!
This extended buffer specifies reference lists for the encoder.
*/
MFX_EXTBUFF_AVC_REFLISTS = MFX_MAKEFOURCC('R','L','T','S'),
/*!
See the mfxExtDecVideoProcessing structure for details.
*/
MFX_EXTBUFF_DEC_VIDEO_PROCESSING = MFX_MAKEFOURCC('D','E','C','V'),
/*!
The extended buffer defines control parameters for the VPP field-processing algorithm. See the mfxExtVPPFieldProcessing
structure for details. The application can attach this buffer to the mfxVideoParam structure for video processing initialization
or to the mfxFrameData structure during runtime.
*/
MFX_EXTBUFF_VPP_FIELD_PROCESSING = MFX_MAKEFOURCC('F','P','R','O'),
/*!
This extended buffer defines additional encoding controls. See the mfxExtCodingOption3 structure for details.
The application can attach this buffer to the structure for encoding initialization.
*/
MFX_EXTBUFF_CODING_OPTION3 = MFX_MAKEFOURCC('C','D','O','3'),
/*!
This extended buffer defines chroma samples location information. See the mfxExtChromaLocInfo structure for details.
The application can attach this buffer to the mfxVideoParam structure for encoding initialization.
*/
MFX_EXTBUFF_CHROMA_LOC_INFO = MFX_MAKEFOURCC('C','L','I','N'),
/*!
This extended buffer defines per-macroblock QP. See the mfxExtMBQP structure for details.
The application can attach this buffer to the mfxEncodeCtrl structure for per-frame encoding configuration.
*/
MFX_EXTBUFF_MBQP = MFX_MAKEFOURCC('M','B','Q','P'),
/*!
This extended buffer defines per-macroblock force intra flag. See the mfxExtMBForceIntra structure for details.
The application can attach this buffer to the mfxEncodeCtrl structure for per-frame encoding configuration.
*/
MFX_EXTBUFF_MB_FORCE_INTRA = MFX_MAKEFOURCC('M','B','F','I'),
/*!
This extended buffer defines additional encoding controls for HEVC tiles. See the mfxExtHEVCTiles structure for details.
The application can attach this buffer to the mfxVideoParam structure for encoding initialization.
*/
MFX_EXTBUFF_HEVC_TILES = MFX_MAKEFOURCC('2','6','5','T'),
/*!
This extended buffer defines macroblock map for current frame which forces specified macroblocks to be non skip. See the
mfxExtMBDisableSkipMap structure for details. The application can attach this buffer to the mfxEncodeCtrl structure for
per-frame encoding configuration.
*/
MFX_EXTBUFF_MB_DISABLE_SKIP_MAP = MFX_MAKEFOURCC('M','D','S','M'),
/*!
See the mfxExtHEVCParam structure for details.
*/
MFX_EXTBUFF_HEVC_PARAM = MFX_MAKEFOURCC('2','6','5','P'),
/*!
This extended buffer is used by decoders to report additional information about decoded frame. See the
mfxExtDecodedFrameInfo structure for more details.
*/
MFX_EXTBUFF_DECODED_FRAME_INFO = MFX_MAKEFOURCC('D','E','F','I'),
/*!
See the mfxExtTimeCode structure for more details.
*/
MFX_EXTBUFF_TIME_CODE = MFX_MAKEFOURCC('T','M','C','D'),
/*!
This extended buffer specifies the region to encode. The application can attach this buffer to the
mfxVideoParam structure during HEVC encoder initialization.
*/
MFX_EXTBUFF_HEVC_REGION = MFX_MAKEFOURCC('2','6','5','R'),
/*!
See the mfxExtPredWeightTable structure for details.
*/
MFX_EXTBUFF_PRED_WEIGHT_TABLE = MFX_MAKEFOURCC('E','P','W','T'),
/*!
See the mfxExtDirtyRect structure for details.
*/
MFX_EXTBUFF_DIRTY_RECTANGLES = MFX_MAKEFOURCC('D','R','O','I'),
/*!
See the mfxExtMoveRect structure for details.
*/
MFX_EXTBUFF_MOVING_RECTANGLES = MFX_MAKEFOURCC('M','R','O','I'),
/*!
See the mfxExtCodingOptionVPS structure for details.
*/
MFX_EXTBUFF_CODING_OPTION_VPS = MFX_MAKEFOURCC('C','O','V','P'),
/*!
See the mfxExtVPPRotation structure for details.
*/
MFX_EXTBUFF_VPP_ROTATION = MFX_MAKEFOURCC('R','O','T',' '),
/*!
See the mfxExtEncodedSlicesInfo structure for details.
*/
MFX_EXTBUFF_ENCODED_SLICES_INFO = MFX_MAKEFOURCC('E','N','S','I'),
/*!
See the mfxExtVPPScaling structure for details.
*/
MFX_EXTBUFF_VPP_SCALING = MFX_MAKEFOURCC('V','S','C','L'),
/*!
This extended buffer defines additional encoding controls for reference list. See the mfxExtAVCRefListCtrl structure for details.
The application can attach this buffer to the mfxVideoParam structure for encoding & decoding initialization, or
the mfxEncodeCtrl structure for per-frame encoding configuration.
*/
MFX_EXTBUFF_HEVC_REFLIST_CTRL = MFX_EXTBUFF_AVC_REFLIST_CTRL,
/*!
This extended buffer specifies reference lists for the encoder.
*/
MFX_EXTBUFF_HEVC_REFLISTS = MFX_EXTBUFF_AVC_REFLISTS,
/*!
This extended buffer configures the structure of temporal layers inside the encoded H.264 bitstream. See the mfxExtAvcTemporalLayers
structure for details. The application can attach this buffer to the mfxVideoParam structure for encoding initialization.
*/
MFX_EXTBUFF_HEVC_TEMPORAL_LAYERS = MFX_EXTBUFF_AVC_TEMPORAL_LAYERS,
/*!
See the mfxExtVPPMirroring structure for details.
*/
MFX_EXTBUFF_VPP_MIRRORING = MFX_MAKEFOURCC('M','I','R','R'),
/*!
See the mfxExtMVOverPicBoundaries structure for details.
*/
MFX_EXTBUFF_MV_OVER_PIC_BOUNDARIES = MFX_MAKEFOURCC('M','V','P','B'),
/*!
See the mfxExtVPPColorFill structure for details.
*/
MFX_EXTBUFF_VPP_COLORFILL = MFX_MAKEFOURCC('V','C','L','F'),
/*!
This extended buffer is used by decoders to report error information before frames get decoded.
See the mfxExtDecodeErrorReport structure for more details.
*/
MFX_EXTBUFF_DECODE_ERROR_REPORT = MFX_MAKEFOURCC('D', 'E', 'R', 'R'),
/*!
See the mfxExtColorConversion structure for details.
*/
MFX_EXTBUFF_VPP_COLOR_CONVERSION = MFX_MAKEFOURCC('V', 'C', 'S', 'C'),
/*!
This extended buffer configures HDR SEI message. See the mfxExtContentLightLevelInfo structure for details.
*/
MFX_EXTBUFF_CONTENT_LIGHT_LEVEL_INFO = MFX_MAKEFOURCC('L', 'L', 'I', 'S'),
/*!
This extended buffer configures HDR SEI message. See the mfxExtMasteringDisplayColourVolume structure for details. If color volume changes
per frame, the application can attach this buffer to the mfxFrameData structure for video processing.
*/
MFX_EXTBUFF_MASTERING_DISPLAY_COLOUR_VOLUME = MFX_MAKEFOURCC('D', 'C', 'V', 'S'),
/*!
This extended buffer configures HDR SEI message. See the mfxExtMasteringDisplayColourVolume structure for details. The application can
attach this buffer to the mfxVideoParam structure for the input of video processing if the mastering display color volume changes per
sequence. In this case, this buffer should be together with MFX_EXTBUFF_CONTENT_LIGHT_LEVEL_INFO to indicate the light level and mastering
color volume of the input of video processing. If color Volume changes per frame instead of per sequence, the application can attach
MFX_EXTBUFF_MASTERING_DISPLAY_COLOUR_VOLUME to mfxFrameData for frame based processing.
*/
MFX_EXTBUFF_MASTERING_DISPLAY_COLOUR_VOLUME_IN = MFX_MAKEFOURCC('D', 'C', 'V', 'I'),
/*!
This extended buffer configures HDR SEI message. See the mfxExtMasteringDisplayColourVolume structure for details. The application can
attach this buffer to the mfxVideoParam structure for the output of video processing if the mastering display color volume changes per
sequence. If color volume changes per frame instead of per sequence, the application can attach the buffer with MFX_EXTBUFF_MASTERING_
DISPLAY_COLOUR_VOLUME to mfxFrameData for frame based processing.
*/
MFX_EXTBUFF_MASTERING_DISPLAY_COLOUR_VOLUME_OUT = MFX_MAKEFOURCC('D', 'C', 'V', 'O'),
/*!
See the mfxExtEncodedUnitsInfo structure for details.
*/
MFX_EXTBUFF_ENCODED_UNITS_INFO = MFX_MAKEFOURCC('E', 'N', 'U', 'I'),
/*!
This video processing algorithm identifier is used to enable MCTF via mfxExtVPPDoUse and together with mfxExtVppMctf
*/
MFX_EXTBUFF_VPP_MCTF = MFX_MAKEFOURCC('M', 'C', 'T', 'F'),
/*!
Extends mfxVideoParam structure with VP9 segmentation parameters. See the mfxExtVP9Segmentation structure for details.
*/
MFX_EXTBUFF_VP9_SEGMENTATION = MFX_MAKEFOURCC('9', 'S', 'E', 'G'),
/*!
Extends mfxVideoParam structure with parameters for VP9 temporal scalability. See the mfxExtVP9TemporalLayers structure for details.
*/
MFX_EXTBUFF_VP9_TEMPORAL_LAYERS = MFX_MAKEFOURCC('9', 'T', 'M', 'L'),
/*!
Extends mfxVideoParam structure with VP9-specific parameters. See the mfxExtVP9Param structure for details.
*/
MFX_EXTBUFF_VP9_PARAM = MFX_MAKEFOURCC('9', 'P', 'A', 'R'),
/*!
See the mfxExtAVCRoundingOffset structure for details.
*/
MFX_EXTBUFF_AVC_ROUNDING_OFFSET = MFX_MAKEFOURCC('R','N','D','O'),
/*!
See the mfxExtPartialBitstreamParam structure for details.
*/
MFX_EXTBUFF_PARTIAL_BITSTREAM_PARAM = MFX_MAKEFOURCC('P','B','O','P'),
/*!
See the mfxExtEncoderIPCMArea structure for details.
*/
MFX_EXTBUFF_ENCODER_IPCM_AREA = MFX_MAKEFOURCC('P', 'C', 'M', 'R'),
/*!
See the mfxExtInsertHeaders structure for details.
*/
MFX_EXTBUFF_INSERT_HEADERS = MFX_MAKEFOURCC('S', 'P', 'R', 'E'),
/*!
See the mfxExtDeviceAffinityMask structure for details.
*/
MFX_EXTBUFF_DEVICE_AFFINITY_MASK = MFX_MAKEFOURCC('D', 'A', 'F', 'M'),
/*!
See the mfxExtInCrops structure for details.
*/
MFX_EXTBUFF_CROPS = MFX_MAKEFOURCC('C', 'R', 'O', 'P'),
/*!
See the mfxExtAV1BitstreamParam structure for more details.
*/
MFX_EXTBUFF_AV1_BITSTREAM_PARAM = MFX_MAKEFOURCC('A', '1', 'B', 'S'),
/*!
See the mfxExtAV1ResolutionParam structure for more details.
*/
MFX_EXTBUFF_AV1_RESOLUTION_PARAM = MFX_MAKEFOURCC('A', '1', 'R', 'S'),
/*!
See the mfxExtAV1TileParam structure for more details.
*/
MFX_EXTBUFF_AV1_TILE_PARAM = MFX_MAKEFOURCC('A', '1', 'T', 'L'),
/*!
See the mfxExtAV1Segmentation structure for more details.
*/
MFX_EXTBUFF_AV1_SEGMENTATION = MFX_MAKEFOURCC('1', 'S', 'E', 'G'),
/*!
See the mfxExtAV1FilmGrainParam structure for more details.
*/
MFX_EXTBUFF_AV1_FILM_GRAIN_PARAM = MFX_MAKEFOURCC('A','1','F','G'),
/*!
See the mfxExtHyperModeParam structure for more details.
*/
MFX_EXTBUFF_HYPER_MODE_PARAM = MFX_MAKEFOURCC('H', 'Y', 'P', 'M'),
/*!
See the mfxExtTemporalLayers structure for more details.
*/
MFX_EXTBUFF_UNIVERSAL_TEMPORAL_LAYERS = MFX_MAKEFOURCC('U', 'T', 'M', 'P'),
/*!
This extended buffer defines additional encoding controls for reference list. See the mfxExtRefListCtrl structure for details.
The application can attach this buffer to the mfxVideoParam structure for encoding & decoding initialization, or
the mfxEncodeCtrl structure for per-frame encoding configuration.
*/
MFX_EXTBUFF_UNIVERSAL_REFLIST_CTRL = MFX_EXTBUFF_AVC_REFLIST_CTRL,
#ifdef ONEVPL_EXPERIMENTAL
/*!
See the mfxExtEncodeStats structure for details.
*/
MFX_EXTBUFF_ENCODESTATS = MFX_MAKEFOURCC('E','N','S','B'),
#endif
/*!
See the mfxExtVPP3DLut structure for more details.
*/
MFX_EXTBUFF_VPP_3DLUT = MFX_MAKEFOURCC('T','D','L','T'),
/*!
See the mfxExtAllocationHints structure for more details.
*/
MFX_EXTBUFF_ALLOCATION_HINTS = MFX_MAKEFOURCC('A','L','C','H'),
#ifdef ONEVPL_EXPERIMENTAL
/*!
See the mfxExtSyncSubmission structure for more details.
*/
MFX_EXTBUFF_SYNCSUBMISSION = MFX_MAKEFOURCC('S','Y','N','C'),
/*!
See the mfxExtVPPPercEncPrefilter structure for details.
*/
MFX_EXTBUFF_VPP_PERC_ENC_PREFILTER = MFX_MAKEFOURCC('V','P','E','F'),
/*!
See the mfxExtTuneEncodeQuality structure for details.
*/
MFX_EXTBUFF_TUNE_ENCODE_QUALITY = MFX_MAKEFOURCC('T','U','N','E'),
#endif
};
/* VPP Conf: Do not use certain algorithms */
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
Tells the VPP not to use certain filters in pipeline. See "Configurable VPP filters" table for complete
list of configurable filters. The user can attach this structure to the mfxVideoParam structure when initializing video processing.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_DONOTUSE. */
mfxU32 NumAlg; /*!< Number of filters (algorithms) not to use */
mfxU32* AlgList; /*!< Pointer to a list of filters (algorithms) not to use */
} mfxExtVPPDoNotUse;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
A hint structure that configures the VPP denoise filter algorithm.
@deprecated Deprecated in API version 2.5. Use mfxExtVPPDenoise2 instead.
*/
MFX_DEPRECATED typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_DENOISE. */
mfxU16 DenoiseFactor; /*!< Indicates the level of noise to remove. Value range of 0 to 100 (inclusive). */
} mfxExtVPPDenoise;
MFX_PACK_END()
/*! The mfxDenoiseMode enumerator specifies the mode of denoise. */
typedef enum {
MFX_DENOISE_MODE_DEFAULT = 0, /*!< Default denoise mode. The library selects the most appropriate denoise mode. */
MFX_DENOISE_MODE_VENDOR = 1000, /*!< The enumeration to separate common denoise mode above and vendor specific. */
MFX_DENOISE_MODE_INTEL_HVS_AUTO_BDRATE = MFX_DENOISE_MODE_VENDOR + 1, /*!< Indicates auto BD rate improvement in pre-processing before video encoding,
ignore Strength.*/
MFX_DENOISE_MODE_INTEL_HVS_AUTO_SUBJECTIVE = MFX_DENOISE_MODE_VENDOR + 2, /*!< Indicates auto subjective quality improvement in pre-processing before video encoding,
ignore Strength.*/
MFX_DENOISE_MODE_INTEL_HVS_AUTO_ADJUST = MFX_DENOISE_MODE_VENDOR + 3, /*!< Indicates auto adjust subjective quality in post-processing (after decoding) for video playback,
ignore Strength.*/
MFX_DENOISE_MODE_INTEL_HVS_PRE_MANUAL = MFX_DENOISE_MODE_VENDOR + 4, /*!< Indicates manual mode for pre-processing before video encoding,
allow to adjust the denoise strength manually.*/
MFX_DENOISE_MODE_INTEL_HVS_POST_MANUAL = MFX_DENOISE_MODE_VENDOR + 5, /*!< Indicates manual mode for post-processing for video playback,
allow to adjust the denoise strength manually.*/
} mfxDenoiseMode;
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
A hint structure that configures the VPP denoise filter algorithm.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_DENOISE2. */
mfxDenoiseMode Mode; /*!< Indicates the mode of denoise. mfxDenoiseMode enumerator. */
mfxU16 Strength; /*!< Denoise strength in manual mode. Value of 0-100 (inclusive) indicates the strength of denoise.
The strength of denoise controls degree of possible changes of pixel values; the bigger the strength
the larger the change is. */
mfxU16 reserved[15];
} mfxExtVPPDenoise2;
MFX_PACK_END()
/*! The mfx3DLutChannelMapping enumerator specifies the channel mapping of 3DLUT. */
typedef enum {
MFX_3DLUT_CHANNEL_MAPPING_DEFAULT = 0, /*!< Default 3DLUT channel mapping. The library selects the most appropriate 3DLUT channel mapping. */
MFX_3DLUT_CHANNEL_MAPPING_RGB_RGB = 1, /*!< 3DLUT RGB channels map to RGB channels. */
MFX_3DLUT_CHANNEL_MAPPING_YUV_RGB = 2, /*!< 3DLUT YUV channels map to RGB channels. */
MFX_3DLUT_CHANNEL_MAPPING_VUY_RGB = 3, /*!< 3DLUT VUY channels map to RGB channels. */
} mfx3DLutChannelMapping;
/*! The mfx3DLutMemoryLayout enumerator specifies the memory layout of 3DLUT. */
typedef enum {
MFX_3DLUT_MEMORY_LAYOUT_DEFAULT = 0, /*!< Default 3DLUT memory layout. The library selects the most appropriate 3DLUT memory layout.*/
MFX_3DLUT_MEMORY_LAYOUT_VENDOR = 0x1000, /*!< The enumeration to separate default above and vendor specific.*/
/*!
Intel specific memory layout. The enumerator indicates the attributes and memory layout of 3DLUT.
3DLUT size is 17(the number of elements per dimension), 4 channels(3 valid channels, 1 channel is reserved), every channel must be 16-bit unsigned integer.
3DLUT contains 17x17x32 entries with holes that are not filled. Take RGB as example, the nodes RxGx17 to RxGx31 are not filled, are "don't care" bits, and not accessed for the 17x17x17 nodes.
*/
MFX_3DLUT_MEMORY_LAYOUT_INTEL_17LUT = MFX_3DLUT_MEMORY_LAYOUT_VENDOR + 1,
/*!
Intel specific memory layout. The enumerator indicates the attributes and memory layout of 3DLUT.
3DLUT size is 33(the number of elements per dimension), 4 channels(3 valid channels, 1 channel is reserved), every channel must be 16-bit unsigned integer.
3DLUT contains 33x33x64 entries with holes that are not filled. Take RGB as example, the nodes RxGx33 to RxGx63 are not filled, are "don't care" bits, and not accessed for the 33x33x33 nodes.
*/
MFX_3DLUT_MEMORY_LAYOUT_INTEL_33LUT = MFX_3DLUT_MEMORY_LAYOUT_VENDOR + 2,
/*!
Intel specific memory layout. The enumerator indicates the attributes and memory layout of 3DLUT.
3DLUT size is 65(the number of elements per dimension), 4 channels(3 valid channels, 1 channel is reserved), every channel must be 16-bit unsigned integer.
3DLUT contains 65x65x128 entries with holes that are not filled. Take RGB as example, the nodes RxGx65 to RxGx127 are not filled, are "don't care" bits, and not accessed for the 65x65x65 nodes.
*/
MFX_3DLUT_MEMORY_LAYOUT_INTEL_65LUT = MFX_3DLUT_MEMORY_LAYOUT_VENDOR + 3,
} mfx3DLutMemoryLayout;
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
A hint structure that configures the data channel.
*/
typedef struct {
mfxDataType DataType; /*!< Data type, mfxDataType enumerator.*/
mfxU32 Size; /*!< Size of Look up table, the number of elements per dimension.*/
union
{
mfxU8* Data; /*!< The pointer to 3DLUT data, 8 bit unsigned integer.*/
mfxU16* Data16; /*!< The pointer to 3DLUT data, 16 bit unsigned integer.*/
};
mfxU32 reserved[4]; /*!< Reserved for future extension.*/
} mfxChannel;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
A hint structure that configures 3DLUT system buffer.
*/
typedef struct {
mfxChannel Channel[3]; /*!< 3 Channels, can be RGB or YUV, mfxChannel structure.*/
mfxU32 reserved[8]; /*!< Reserved for future extension.*/
} mfx3DLutSystemBuffer;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
A hint structure that configures 3DLUT video buffer.
*/
typedef struct {
mfxDataType DataType; /*!< Data type, mfxDataType enumerator.*/
mfx3DLutMemoryLayout MemLayout; /*!< Indicates 3DLUT memory layout. mfx3DLutMemoryLayout enumerator.*/
mfxMemId MemId; /*!< Memory ID for holding the lookup table data. One MemID is dedicated for one instance of VPP.*/
mfxU32 reserved[8]; /*!< Reserved for future extension.*/
} mfx3DLutVideoBuffer;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
A hint structure that configures 3DLUT filter.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_3DLUT..*/
mfx3DLutChannelMapping ChannelMapping; /*!< Indicates 3DLUT channel mapping. mfx3DLutChannelMapping enumerator.*/
mfxResourceType BufferType; /*!< Indicates 3DLUT buffer type. mfxResourceType enumerator, can be system memory, VA surface, DX11 texture/buffer etc.*/
union
{
mfx3DLutSystemBuffer SystemBuffer; /*!< The 3DLUT system buffer. mfx3DLutSystemBuffer structure describes the details of the buffer.*/
mfx3DLutVideoBuffer VideoBuffer; /*!< The 3DLUT video buffer. mfx3DLutVideoBuffer describes the details of 3DLUT video buffer.*/
};
mfxU32 reserved[4]; /*!< Reserved for future extension.*/
} mfxExtVPP3DLut;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
A hint structure that configures the VPP detail/edge enhancement filter algorithm.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_DETAIL. */
mfxU16 DetailFactor; /*!< Indicates the level of details to be enhanced. Value range of 0 to 100 (inclusive). */
} mfxExtVPPDetail;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/*!
A hint structure that configures the VPP ProcAmp filter algorithm.
The structure parameters will be clipped to their corresponding range and rounded by their corresponding increment.
@note There are no default values for fields in this structure, all settings must be explicitly specified every time this
buffer is submitted for processing.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_PROCAMP. */
mfxF64 Brightness; /*!< The brightness parameter is in the range of -100.0F to 100.0F, in increments of 0.1F.
Setting this field to 0.0F will disable brightness adjustment. */
mfxF64 Contrast; /*!< The contrast parameter in the range of 0.0F to 10.0F, in increments of 0.01F, is used for manual
contrast adjustment. Setting this field to 1.0F will disable contrast adjustment. If the parameter
is negative, contrast will be adjusted automatically. */
mfxF64 Hue; /*!< The hue parameter is in the range of -180F to 180F, in increments of 0.1F. Setting this field to 0.0F
will disable hue adjustment. */
mfxF64 Saturation; /*!< The saturation parameter is in the range of 0.0F to 10.0F, in increments of 0.01F.
Setting this field to 1.0F will disable saturation adjustment. */
} mfxExtVPPProcAmp;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/*!
Returns statistics collected during encoding.
*/
typedef struct {
mfxU32 reserved[16];
mfxU32 NumFrame; /*!< Number of encoded frames. */
mfxU64 NumBit; /*!< Number of bits for all encoded frames. */
mfxU32 NumCachedFrame; /*!< Number of internally cached frames. */
} mfxEncodeStat;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Returns statistics collected during decoding.
*/
typedef struct {
mfxU32 reserved[16];
mfxU32 NumFrame; /*!< Number of total decoded frames. */
mfxU32 NumSkippedFrame; /*!< Number of skipped frames. */
mfxU32 NumError; /*!< Number of errors recovered. */
mfxU32 NumCachedFrame; /*!< Number of internally cached frames. */
} mfxDecodeStat;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Returns statistics collected during video processing.
*/
typedef struct {
mfxU32 reserved[16];
mfxU32 NumFrame; /*!< Total number of frames processed. */
mfxU32 NumCachedFrame; /*!< Number of internally cached frames. */
} mfxVPPStat;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Returns auxiliary data generated by the video processing pipeline.
The encoding process may use the auxiliary data by attaching this structure to the mfxEncodeCtrl structure.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_AUXDATA. */
union{
struct{
MFX_DEPRECATED mfxU32 SpatialComplexity; /* Deprecated */
MFX_DEPRECATED mfxU32 TemporalComplexity; /* Deprecated */
};
struct{
/*!
Detected picture structure - top field first, bottom field first, progressive or unknown if video processor cannot
detect picture structure. See the PicStruct enumerator for definition of these values.
*/
mfxU16 PicStruct;
mfxU16 reserved[3];
};
};
MFX_DEPRECATED mfxU16 SceneChangeRate; /* Deprecated */
mfxU16 RepeatedFrame; /*!< The flag signalizes that the frame is identical to the previous one. */
} mfxExtVppAuxData;
MFX_PACK_END()
/*! The PayloadCtrlFlags enumerator itemizes additional payload properties. */
enum {
MFX_PAYLOAD_CTRL_SUFFIX = 0x00000001 /*!< Insert this payload into HEVC Suffix SEI NAL-unit. */
};
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
Describes user data payload in MPEG-2 or SEI message payload in H.264.
For encoding, these payloads can be
inserted into the bitstream. The payload buffer must contain a valid formatted payload.
For H.264, this is the sei_message() as
specified in the section 7.3.2.3.1 'Supplemental enhancement information message syntax' of the ISO/IEC 14496-10 specification.
For MPEG-2,
this is the section 6.2.2.2.2 'User data' of the ISO/IEC 13818-2 specification, excluding the user data start_code.
For decoding,
these payloads can be retrieved as the decoder parses the bitstream and caches them in an internal buffer.
@internal
+-----------+-------------------------------------------+
| **Codec** | **Supported Types** |
+===========+===========================================+
| MPEG2 | 0x01B2 //User Data |
+-----------+-------------------------------------------+
| AVC | 02 //pan_scan_rect |
| | 03 //filler_payload |
| | 04 //user_data_registered_itu_t_t35 |
| | 05 //user_data_unregistered |
| | 06 //recovery_point |
| | 09 //scene_info |
| | 13 //full_frame_freeze |
| | 14 //full_frame_freeze_release |
| | 15 //full_frame_snapshot |
| | 16 //progressive_refinement_segment_start |
| | 17 //progressive_refinement_segment_end |
| | 19 //film_grain_characteristics |
| | 20 //deblocking_filter_display_preference |
| | 21 //stereo_video_info |
| | 45 //frame_packing_arrangement |
+-----------+-------------------------------------------+
| HEVC | All |
+-----------+-------------------------------------------+
@endinternal
*/
typedef struct {
mfxU32 CtrlFlags; /*!< Additional payload properties. See the PayloadCtrlFlags enumerator for details. */
mfxU32 reserved[3];
mfxU8 *Data; /*!< Pointer to the actual payload data buffer. */
mfxU32 NumBit; /*!< Number of bits in the payload data */
mfxU16 Type; /*!< MPEG-2 user data start code or H.264 SEI message type. */
mfxU16 BufSize; /*!< Payload buffer size in bytes. */
} mfxPayload;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
Contains parameters for per-frame based encoding control.
*/
typedef struct {
mfxExtBuffer Header; /*!< This extension buffer doesn't have assigned buffer ID. Ignored. */
mfxU32 reserved[4];
mfxU16 reserved1;
/*!
Type of NAL unit that contains encoding frame. All supported values are defined by MfxNalUnitType enumerator. Other values
defined in ITU-T H.265 specification are not supported.
The encoder uses this field only if application sets mfxExtCodingOption3::EnableNalUnitType option to ON during encoder initialization.
@note Only encoded order is supported. If application specifies this value in display order or uses value inappropriate for current frame or
invalid value, then the encoder silently ignores it.
*/
mfxU16 MfxNalUnitType;
mfxU16 SkipFrame; /*!< Indicates that current frame should be skipped or the number of missed frames before the current frame. See mfxExtCodingOption2::SkipFrame for details. */
mfxU16 QP; /*!< If nonzero, this value overwrites the global QP value for the current frame in the constant QP mode. */
/*!
Encoding frame type. See the FrameType enumerator for details. If the encoder works in the encoded order, the application must
specify the frame type. If the encoder works in the display order, only key frames are enforceable.
*/
mfxU16 FrameType;
mfxU16 NumExtParam; /*!< Number of extra control buffers. */
mfxU16 NumPayload; /*!< Number of payload records to insert into the bitstream. */
mfxU16 reserved2;
/*!
Pointer to an array of pointers to external buffers that provide additional information or control to the encoder for this
frame or field pair. A typical use is to pass the VPP auxiliary data generated by the video processing pipeline to the encoder.
See the ExtendedBufferID for the list of extended buffers.
*/
mfxExtBuffer **ExtParam;
/*!
Pointer to an array of pointers to user data (MPEG-2) or SEI messages (H.264) for insertion into the bitstream. For field pictures,
odd payloads are associated with the first field and even payloads are associated with the second field. See the mfxPayload structure
for payload definitions.
*/
mfxPayload **Payload;
} mfxEncodeCtrl;
MFX_PACK_END()
/*! The ExtMemBufferType enumerator specifies the buffer type. It is a bit-ORed value of the following. */
enum {
MFX_MEMTYPE_PERSISTENT_MEMORY =0x0002 /*!< Memory page for persistent use. */
};
/* Frame Memory Types */
#define MFX_MEMTYPE_BASE(x) (0x90ff & (x))
/*!
The ExtMemFrameType enumerator specifies the memory type of frame. It is a bit-ORed value of the following.
\verbatim embed:rst
For information on working with video memory surfaces, see the :ref:`Working with Hardware Acceleration section<hw-acceleration>`.
\endverbatim
*/
enum {
MFX_MEMTYPE_DXVA2_DECODER_TARGET =0x0010, /*!< Frames are in video memory and belong to video decoder render targets. */
MFX_MEMTYPE_DXVA2_PROCESSOR_TARGET =0x0020, /*!< Frames are in video memory and belong to video processor render targets. */
MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET = MFX_MEMTYPE_DXVA2_DECODER_TARGET, /*!< Frames are in video memory and belong to video decoder render targets. */
MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET = MFX_MEMTYPE_DXVA2_PROCESSOR_TARGET,/*!< Frames are in video memory and belong to video processor render targets. */
MFX_MEMTYPE_SYSTEM_MEMORY =0x0040, /*!< The frames are in system memory. */
MFX_MEMTYPE_RESERVED1 =0x0080, /*!< */
MFX_MEMTYPE_FROM_ENCODE = 0x0100, /*!< Allocation request comes from an ENCODE function */
MFX_MEMTYPE_FROM_DECODE = 0x0200, /*!< Allocation request comes from a DECODE function */
MFX_MEMTYPE_FROM_VPPIN = 0x0400, /*!< Allocation request comes from a VPP function for input frame allocation */
MFX_MEMTYPE_FROM_VPPOUT = 0x0800, /*!< Allocation request comes from a VPP function for output frame allocation */
MFX_MEMTYPE_FROM_ENC = 0x2000, /*!< Allocation request comes from an ENC function */
MFX_MEMTYPE_FROM_PAK = 0x4000, /* Reserved */
MFX_MEMTYPE_INTERNAL_FRAME = 0x0001, /*!< Allocation request for internal frames */
MFX_MEMTYPE_EXTERNAL_FRAME = 0x0002, /*!< Allocation request for I/O frames */
MFX_MEMTYPE_EXPORT_FRAME = 0x0008, /*!< Application requests frame handle export to some associated object. For Linux frame handle can be
considered to be exported to DRM Prime FD, DRM FLink or DRM FrameBuffer Handle. Specifics of export
types and export procedure depends on external frame allocator implementation */
MFX_MEMTYPE_SHARED_RESOURCE = MFX_MEMTYPE_EXPORT_FRAME, /*!< For DX11 allocation use shared resource bind flag. */
MFX_MEMTYPE_VIDEO_MEMORY_ENCODER_TARGET = 0x1000 /*!< Frames are in video memory and belong to video encoder render targets. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Describes multiple frame allocations when initializing encoders, decoders, and video preprocessors.
A range specifies the number of video frames. Applications are free to allocate additional frames. In all cases, the minimum number of
frames must be at least NumFrameMin or the called API function will return an error.
*/
typedef struct {
union {
mfxU32 AllocId; /*!< Unique (within the session) ID of component requested the allocation. */
mfxU32 reserved[1];
};
mfxU32 reserved3[3];
mfxFrameInfo Info; /*!< Describes the properties of allocated frames. */
mfxU16 Type; /*!< Allocated memory type. See the ExtMemFrameType enumerator for details. */
mfxU16 NumFrameMin; /*!< Minimum number of allocated frames. */
mfxU16 NumFrameSuggested; /*!< Suggested number of allocated frames. */
mfxU16 reserved2;
} mfxFrameAllocRequest;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
Describes the response to multiple frame allocations. The calling API function returns the number of
video frames actually allocated and pointers to their memory IDs.
*/
typedef struct {
mfxU32 AllocId; /*!< Unique (within the session) ID of component requested the allocation. */
mfxU32 reserved[3];
mfxMemId *mids; /*!< Pointer to the array of the returned memory IDs. The application allocates or frees this array. */
mfxU16 NumFrameActual; /*!< Number of frames actually allocated. */
mfxU16 reserved2;
} mfxFrameAllocResponse;
MFX_PACK_END()
/*! The FrameType enumerator itemizes frame types. Use bit-ORed values to specify all that apply. */
enum {
MFX_FRAMETYPE_UNKNOWN =0x0000, /*!< Frame type is unspecified. */
MFX_FRAMETYPE_I =0x0001, /*!< This frame or the first field is encoded as an I-frame/field. */
MFX_FRAMETYPE_P =0x0002, /*!< This frame or the first field is encoded as an P-frame/field. */
MFX_FRAMETYPE_B =0x0004, /*!< This frame or the first field is encoded as an B-frame/field. */
MFX_FRAMETYPE_S =0x0008, /*!< This frame or the first field is either an SI- or SP-frame/field. */
MFX_FRAMETYPE_REF =0x0040, /*!< This frame or the first field is encoded as a reference. */
MFX_FRAMETYPE_IDR =0x0080, /*!< This frame or the first field is encoded as an IDR. */
MFX_FRAMETYPE_xI =0x0100, /*!< The second field is encoded as an I-field. */
MFX_FRAMETYPE_xP =0x0200, /*!< The second field is encoded as an P-field. */
MFX_FRAMETYPE_xB =0x0400, /*!< The second field is encoded as an S-field. */
MFX_FRAMETYPE_xS =0x0800, /*!< The second field is an SI- or SP-field. */
MFX_FRAMETYPE_xREF =0x4000, /*!< The second field is encoded as a reference. */
MFX_FRAMETYPE_xIDR =0x8000 /*!< The second field is encoded as an IDR. */
};
/*!
The MfxNalUnitType enumerator specifies NAL unit types supported by the HEVC encoder.
*/
enum {
MFX_HEVC_NALU_TYPE_UNKNOWN = 0, /*!< The encoder will decide what NAL unit type to use. */
MFX_HEVC_NALU_TYPE_TRAIL_N = ( 0+1), /*!< See Table 7-1 of the ITU-T H.265 specification for the definition of these type. */
MFX_HEVC_NALU_TYPE_TRAIL_R = ( 1+1), /*!< See Table 7-1 of the ITU-T H.265 specification for the definition of these type. */
MFX_HEVC_NALU_TYPE_RADL_N = ( 6+1), /*!< See Table 7-1 of the ITU-T H.265 specification for the definition of these type. */
MFX_HEVC_NALU_TYPE_RADL_R = ( 7+1), /*!< See Table 7-1 of the ITU-T H.265 specification for the definition of these type. */
MFX_HEVC_NALU_TYPE_RASL_N = ( 8+1), /*!< See Table 7-1 of the ITU-T H.265 specification for the definition of these type. */
MFX_HEVC_NALU_TYPE_RASL_R = ( 9+1), /*!< See Table 7-1 of the ITU-T H.265 specification for the definition of these type. */
MFX_HEVC_NALU_TYPE_IDR_W_RADL = (19+1), /*!< See Table 7-1 of the ITU-T H.265 specification for the definition of these type. */
MFX_HEVC_NALU_TYPE_IDR_N_LP = (20+1), /*!< See Table 7-1 of the ITU-T H.265 specification for the definition of these type. */
MFX_HEVC_NALU_TYPE_CRA_NUT = (21+1) /*!< See Table 7-1 of the ITU-T H.265 specification for the definition of these type. */
};
/*! The mfxSkipMode enumerator describes the decoder skip-mode options. */
typedef enum {
MFX_SKIPMODE_NOSKIP=0, /*! Do not skip any frames. */
MFX_SKIPMODE_MORE=1, /*! Skip more frames. */
MFX_SKIPMODE_LESS=2 /*! Skip less frames. */
} mfxSkipMode;
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
Attach this structure as part of the extended buffers to configure the encoder during MFXVideoENCODE_Init. The sequence or picture
parameters specified by this structure overwrite any parameters specified by the structure or any other attached extended buffers attached.
For H.264, SPSBuffer and PPSBuffer must point to valid bitstreams that contain the sequence parameter set and picture parameter set,
respectively.
For MPEG-2, SPSBuffer must point to valid bitstreams that contain the sequence header followed by any sequence header extension. The PPSBuffer pointer is ignored.
The encoder imports parameters from these buffers. If the encoder does not support the specified parameters,
the encoder does not initialize and returns the status code MFX_ERR_INCOMPATIBLE_VIDEO_PARAM.
Check with the MFXVideoENCODE_Query function for the support of this multiple segment encoding feature. If this feature is not supported,
the query returns MFX_ERR_UNSUPPORTED.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_CODING_OPTION_SPSPPS. */
mfxU8 *SPSBuffer; /*!< Pointer to a valid bitstream that contains the SPS (sequence parameter set for H.264 or sequence header
followed by any sequence header extension for MPEG-2) buffer. Can be NULL to skip specifying the SPS. */
mfxU8 *PPSBuffer; /*!< Pointer to a valid bitstream that contains the PPS (picture parameter set for H.264 or picture header
followed by any picture header extension for MPEG-2) buffer. Can be NULL to skip specifying the PPS. */
mfxU16 SPSBufSize; /*!< Size of the SPS in bytes. */
mfxU16 PPSBufSize; /*!< Size of the PPS in bytes. */
mfxU16 SPSId; /*!< SPS identifier. The value is reserved and must be zero. */
mfxU16 PPSId; /*!< PPS identifier. The value is reserved and must be zero. */
} mfxExtCodingOptionSPSPPS;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/*!
Attach this structure as part of the extended buffers to configure the encoder during MFXVideoENCODE_Init. The sequence or picture
parameters specified by this structure overwrite any parameters specified by the structure or any other attached extended buffers attached.
If the encoder does not support the specified parameters, the encoder does not initialize and returns the status code
MFX_ERR_INCOMPATIBLE_VIDEO_PARAM.
Check with the MFXVideoENCODE_Query function for the support of this multiple segment encoding feature. If this feature is not supported,
the query returns MFX_ERR_UNSUPPORTED.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_CODING_OPTION_VPS. */
union {
mfxU8 *VPSBuffer; /*!< Pointer to a valid bitstream that contains the VPS (video parameter set for HEVC) buffer. */
mfxU64 reserved1;
};
mfxU16 VPSBufSize; /*!< Size of the VPS in bytes. */
mfxU16 VPSId; /*!< VPS identifier; the value is reserved and must be zero. */
mfxU16 reserved[6];
} mfxExtCodingOptionVPS;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Defines the video signal information.
For H.264, see Annex E of the ISO/IEC 14496-10 specification for the definition of these parameters.
For MPEG-2, see section 6.3.6 of the ITU* H.262 specification for the definition of these parameters. The field VideoFullRange is ignored.
For VC-1, see section 6.1.14.5 of the SMPTE* 421M specification. The fields VideoFormat and VideoFullRange are ignored.
@note If ColourDescriptionPresent is zero, the color description information (including ColourPrimaries, TransferCharacteristics,
and MatrixCoefficients) does not present in the bitstream.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VIDEO_SIGNAL_INFO. */
mfxU16 VideoFormat;
mfxU16 VideoFullRange;
mfxU16 ColourDescriptionPresent;
mfxU16 ColourPrimaries;
mfxU16 TransferCharacteristics;
mfxU16 MatrixCoefficients;
} mfxExtVideoSignalInfo;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
Tells the VPP to include certain filters in the pipeline.
Each filter may be included in the pipeline in one of two different ways:
@li Adding a filter ID to this structure. In this method,
the default filter parameters are used.
@li Attaching a filter configuration structure directly to the mfxVideoParam structure.
In this method, adding filter ID to the mfxExtVPPDoUse structure is optional.
See Table "Configurable VPP filters" for complete list of
configurable filters, their IDs, and configuration structures.
The user can attach this structure to the mfxVideoParam structure when initializing video processing.
@note MFX_EXTBUFF_VPP_COMPOSITE cannot be enabled using mfxExtVPPDoUse because default parameters are undefined for this filter.
The application must attach the appropriate filter configuration structure directly to the mfxVideoParam structure to enable it.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_DOUSE. */
mfxU32 NumAlg; /*!< Number of filters (algorithms) to use */
mfxU32 *AlgList; /*!< Pointer to a list of filters (algorithms) to use */
} mfxExtVPPDoUse;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Configures reference frame options for the H.264 encoder.
\verbatim embed:rst
See the :ref:`Reference List Selection <sec_reference_list_selection>` and :ref:`Long Term Reference Frame <sec_long_term_reference_frame>` sections for more details.
\endverbatim
@note Not all implementations of the encoder support LongTermIdx and ApplyLongTermIdx fields in this structure. The application must use
query mode 1 to determine if such functionality is supported. To do this, the application must attach this extended buffer to the
mfxVideoParam structure and call the MFXVideoENCODE_Query function. If the function returns MFX_ERR_NONE and these fields were set to one,
then the functionality is supported. If the function fails or sets fields to zero, then the functionality is not supported.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_AVC_REFLIST_CTRL. */
mfxU16 NumRefIdxL0Active; /*!< Specify the number of reference frames in the active reference list L0. This number should be less or equal to the NumRefFrame parameter from encoding initialization. */
mfxU16 NumRefIdxL1Active; /*!< Specify the number of reference frames in the active reference list L1. This number should be less or equal to the NumRefFrame parameter from encoding initialization. */
struct {
/*! @{
@name Reference Lists
The following structure members are used by the reference lists contained in the parent structure. */
mfxU32 FrameOrder; /*!< Together FrameOrder and PicStruct fields are used to identify reference picture. Use FrameOrder = MFX_FRAMEORDER_UNKNOWN to mark unused entry. */
mfxU16 PicStruct; /*!< Together FrameOrder and PicStruct fields are used to identify reference picture. Use FrameOrder = MFX_FRAMEORDER_UNKNOWN to mark unused entry. */
mfxU16 ViewId; /*!< Reserved and must be zero. */
mfxU16 LongTermIdx; /*!< Index that should be used by the encoder to mark long-term reference frame. */
mfxU16 reserved[3]; /*!< Reserved */
/*! @} */
} PreferredRefList[32], /*!< Reference list that specifies the list of frames that should be used to predict the current frame. */
RejectedRefList[16], /*!< Reference list that specifies the list of frames that should not be used for prediction. */
LongTermRefList[16]; /*!< Reference list that specifies the list of frames that should be marked as long-term reference frame. */
mfxU16 ApplyLongTermIdx;/*!< If it is equal to zero, the encoder assigns long-term index according to internal algorithm.
If it is equal to one, the encoder uses LongTermIdx value as long-term index. */
mfxU16 reserved[15];
} mfxExtAVCRefListCtrl;
MFX_PACK_END()
/*! The FrcAlgm enumerator itemizes frame rate conversion algorithms. See description of mfxExtVPPFrameRateConversion structure for more details. */
enum {
MFX_FRCALGM_PRESERVE_TIMESTAMP = 0x0001, /*!< Frame dropping/repetition based frame rate conversion algorithm with preserved original
time stamps. Any inserted frames will carry MFX_TIMESTAMP_UNKNOWN. */
MFX_FRCALGM_DISTRIBUTED_TIMESTAMP = 0x0002, /*!< Frame dropping/repetition based frame rate conversion algorithm with distributed time stamps.
The algorithm distributes output time stamps evenly according to the output frame rate. */
MFX_FRCALGM_FRAME_INTERPOLATION = 0x0004 /*!< Frame rate conversion algorithm based on frame interpolation. This flag may be combined with
MFX_FRCALGM_PRESERVE_TIMESTAMP or MFX_FRCALGM_DISTRIBUTED_TIMESTAMP flags. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Configures the VPP frame rate conversion filter. The user can attach this structure to the
mfxVideoParam structure when initializing, resetting, or querying capability of video processing.
On some platforms the advanced frame rate conversion algorithm (the algorithm based on frame interpolation) is not supported. To query its support,
the application should add the MFX_FRCALGM_FRAME_INTERPOLATION flag to the Algorithm value in the mfxExtVPPFrameRateConversion structure, attach it to the
structure, and call the MFXVideoVPP_Query function. If the filter is supported, the function returns a MFX_ERR_NONE status and copies the content of the
input structure to the output structure. If an advanced filter is not supported, then a simple filter will be used and the function returns
MFX_WRN_INCOMPATIBLE_VIDEO_PARAM, copies content of the input structure to the output structure, and corrects the Algorithm value.
If advanced FRC algorithm is not supported, both MFXVideoVPP_Init and MFXVideoVPP_Reset functions return the MFX_WRN_INCOMPATIBLE_VIDEO_PARAM status.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION. */
mfxU16 Algorithm; /*!< See the FrcAlgm enumerator for a list of frame rate conversion algorithms. */
mfxU16 reserved;
mfxU32 reserved2[15];
} mfxExtVPPFrameRateConversion;
MFX_PACK_END()
/*! The ImageStabMode enumerator itemizes image stabilization modes. See description of mfxExtVPPImageStab structure for more details. */
enum {
MFX_IMAGESTAB_MODE_UPSCALE = 0x0001, /*!< Upscale mode. */
MFX_IMAGESTAB_MODE_BOXING = 0x0002 /*!< Boxing mode. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
A hint structure that configures the VPP image stabilization filter.
On some platforms this filter is not supported. To query its support, the application should use the same approach that it uses
to configure VPP filters: adding the filter ID to the mfxExtVPPDoUse structure or by attaching the mfxExtVPPImageStab structure
directly to the mfxVideoParam structure and calling the MFXVideoVPP_Query function.
If this filter is supported, the function returns a MFX_ERR_NONE
status and copies the content of the input structure to the output structure. If the filter is not supported, the function returns MFX_WRN_FILTER_SKIPPED, removes the
filter from the mfxExtVPPDoUse structure, and zeroes the mfxExtVPPImageStab structure.
If the image stabilization filter is not supported, both MFXVideoVPP_Init and MFXVideoVPP_Reset functions return a MFX_WRN_FILTER_SKIPPED status.
The application can retrieve the list of active filters by attaching the mfxExtVPPDoUse structure to the mfxVideoParam structure and calling the
MFXVideoVPP_GetVideoParam function. The application must allocate enough memory for the filter list.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_IMAGE_STABILIZATION. */
mfxU16 Mode; /*!< Image stabilization mode. See ImageStabMode enumerator for values. */
mfxU16 reserved[11];
} mfxExtVPPImageStab;
MFX_PACK_END()
/*!
The InsertHDRPayload enumerator itemizes HDR payloads insertion rules in the encoder,
and indicates if there is valid HDR SEI message in the clip in the decoder.
*/
enum {
MFX_PAYLOAD_OFF = 0, /*!< Do not insert payload when encoding;
Clip does not have valid HDE SEI when decoding. */
MFX_PAYLOAD_IDR = 1 /*!< Insert payload on IDR frames when encoding;
Clip has valid HDE SEI when decoding. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Handle the HDR SEI message.
During encoding: If the application attaches this structure to the mfxEncodeCtrl structure at runtime,
the encoder inserts the HDR SEI message for the current frame and ignores InsertPayloadToggle. If the application attaches this
structure to the mfxVideoParam structure during initialization or reset, the encoder inserts the HDR SEI message based on InsertPayloadToggle.
During video processing: If the application attaches this structure for video processing, InsertPayloadToggle will be ignored.
And DisplayPrimariesX[3], DisplayPrimariesY[3] specify the color primaries where 0,1,2 specifies Red, Green, Blue respectively.
During decoding: If the application attaches this structure to the mfxFrameSurface1 structure at runtime
which will seed to the MFXVideoDECODE_DecodeFrameAsync() as surface_work parameter,
the decoder will parse the HDR SEI message if the bitstream include HDR SEI message per frame.
The parsed HDR SEI will be attached to the ExtendBuffer of surface_out parameter of MFXVideoDECODE_DecodeFrameAsync()
with flag `InsertPayloadToggle` to indicate if there is valid HDR SEI message in the clip.
`InsertPayloadToggle` will be set to `MFX_PAYLOAD_IDR` if oneVPL gets valid HDR SEI, otherwise it will be set to `MFX_PAYLOAD_OFF`.
This function is support for HEVC only now.
Encoding or Decoding, Field semantics are defined in ITU-T* H.265 Annex D, AV1 6.7.4 Metadata OBU semantics.
Video processing, `DisplayPrimariesX[3]` and `WhitePointX` are in increments of 0.00002, in the range of [5, 37000]. `DisplayPrimariesY[3]`
and `WhitePointY` are in increments of 0.00002, in the range of [5, 42000]. `MaxDisplayMasteringLuminance` is in units of 1 candela per square meter.
`MinDisplayMasteringLuminance` is in units of 0.0001 candela per square meter.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_MASTERING_DISPLAY_COLOUR_VOLUME. */
mfxU16 reserved[15];
mfxU16 InsertPayloadToggle; /*!< InsertHDRPayload enumerator value. */
mfxU16 DisplayPrimariesX[3]; /*!< Color primaries for a video source. Consist of RGB x coordinates and
define how to convert colors from RGB color space to CIE XYZ color space. */
mfxU16 DisplayPrimariesY[3]; /*!< Color primaries for a video source. Consists of RGB y coordinates and
defines how to convert colors from RGB color space to CIE XYZ color space.*/
mfxU16 WhitePointX; /*!< White point X coordinate. */
mfxU16 WhitePointY; /*!< White point Y coordinate. */
mfxU32 MaxDisplayMasteringLuminance; /*!< Specify maximum luminance of the display on which the content was authored.*/
mfxU32 MinDisplayMasteringLuminance; /*!< Specify minimum luminance of the display on which the content was authored. */
} mfxExtMasteringDisplayColourVolume;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Handle the HDR SEI message.
During encoding: If the application attaches this structure to the mfxEncodeCtrl structure at runtime,
the encoder inserts the HDR SEI message for the current frame and ignores InsertPayloadToggle. If the application
attaches this structure to the mfxVideoParam structure during initialization or reset, the encoder inserts
the HDR SEI message based on InsertPayloadToggle.
During video processing: If the application attaches this structure for video processing, InsertPayloadToggle will be ignored.
During decoding: If the application attaches this structure to the mfxFrameSurface1 structure at runtime
which will seed to the MFXVideoDECODE_DecodeFrameAsync() as surface_work parameter,
the decoder will parse the HDR SEI message if the bitstream include HDR SEI message per frame.
The parsed HDR SEI will be attached to the ExtendBuffer of surface_out parameter of MFXVideoDECODE_DecodeFrameAsync()
with flag `InsertPayloadToggle` to indicate if there is valid HDR SEI message in the clip.
`InsertPayloadToggle` will be set to `MFX_PAYLOAD_IDR` if oneVPL gets valid HDR SEI, otherwise it will be set to `MFX_PAYLOAD_OFF`.
This function is support for HEVC only now.
Field semantics are defined in ITU-T* H.265 Annex D, AV1 6.7.3 Metadata high dynamic range content light level semantics.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to EXTBUFF_CONTENT_LIGHT_LEVEL_INFO. */
mfxU16 reserved[9];
mfxU16 InsertPayloadToggle; /*!< InsertHDRPayload enumerator value. */
mfxU16 MaxContentLightLevel; /*!< Maximum luminance level of the content. Field range is 1 to 65535. */
mfxU16 MaxPicAverageLightLevel; /*!< Maximum average per-frame luminance level of the content. Field range is 1 to 65535. */
} mfxExtContentLightLevelInfo;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Configures the H.264 picture timing SEI message. The encoder ignores it if HRD information in
the stream is absent and the PicTimingSEI option in the mfxExtCodingOption structure is turned off. See mfxExtCodingOption for details.
If the application attaches this structure to the mfxVideoParam structure during initialization, the encoder inserts the picture timing
SEI message based on provided template in every access unit of coded bitstream.
If application attaches this structure to the mfxEncodeCtrl structure at runtime, the encoder inserts the picture timing SEI message
based on provided template in access unit that represents current frame.
These parameters define the picture timing information. An invalid value of 0xFFFF indicates that application does not set the value and
encoder must calculate it.
See Annex D of the ISO*\/IEC* 14496-10 specification for the definition of these parameters.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_PICTURE_TIMING_SEI. */
mfxU32 reserved[14];
struct {
mfxU16 ClockTimestampFlag;
mfxU16 CtType;
mfxU16 NuitFieldBasedFlag;
mfxU16 CountingType;
mfxU16 FullTimestampFlag;
mfxU16 DiscontinuityFlag;
mfxU16 CntDroppedFlag;
mfxU16 NFrames;
mfxU16 SecondsFlag;
mfxU16 MinutesFlag;
mfxU16 HoursFlag;
mfxU16 SecondsValue;
mfxU16 MinutesValue;
mfxU16 HoursValue;
mfxU32 TimeOffset;
} TimeStamp[3];
} mfxExtPictureTimingSEI;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Configures the H.264 temporal layers hierarchy.
If the application attaches it to the mfxVideoParam
structure during initialization, the encoder generates the temporal layers and inserts the prefix NAL unit before each slice to
indicate the temporal and priority IDs of the layer.
This structure can be used with the display-order encoding mode only.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_AVC_TEMPORAL_LAYERS. */
mfxU32 reserved1[4];
mfxU16 reserved2;
mfxU16 BaseLayerPID; /*!< The priority ID of the base layer. The encoder increases the ID for each temporal layer and writes to the prefix NAL unit. */
struct {
mfxU16 Scale; /*!< The ratio between the frame rates of the current temporal layer and the base layer. */
mfxU16 reserved[3];
}Layer[8];
} mfxExtAvcTemporalLayers; /*!< The array of temporal layers; Use Scale=0 to specify absent layers. */
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used to retrieve encoder capability. See the description of mode 4 of the MFXVideoENCODE_Query function
for details on how to use this structure.
@note Not all implementations of the encoder support this extended buffer. The application must use query mode 1 to determine
if the functionality is supported. To do this, the application must attach this extended buffer to the mfxVideoParam structure and
call the MFXVideoENCODE_Query function. If the function returns MFX_ERR_NONE then the functionality is supported.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_ENCODER_CAPABILITY. */
mfxU32 MBPerSec; /*!< Specify the maximum processing rate in macro blocks per second. */
mfxU16 reserved[58];
} mfxExtEncoderCapability;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used to control the encoder behavior during reset. By using this structure, the application
instructs the encoder to start a new coded sequence after reset or to continue encoding of the current sequence.
This structure is also used in mode 3 of the MFXVideoENCODE_Query function to check for reset outcome before actual reset. The application
should set StartNewSequence to the required behavior and call the query function. If the query fails (see status codes below), then reset is not
possible in current encoder state. If the application sets StartNewSequence to MFX_CODINGOPTION_UNKNOWN, then the query function replaces the coding option with the
actual reset type: MFX_CODINGOPTION_ON if the encoder will begin a new sequence after reset or MFX_CODINGOPTION_OFF if the encoder will continue the current sequence.
Using this structure may cause one of the following status codes from the MFXVideoENCODE_Reset and MFXVideoENCODE_Queryfunctions:
@li MFX_ERR_INVALID_VIDEO_PARAM If a reset is not possible. For example, the application sets StartNewSequence to off and requests resolution change.
@li MFX_ERR_INCOMPATIBLE_VIDEO_PARAM If the application requests change that leads to memory allocation. For example, the application sets StartNewSequence to on and
requests resolution change to greater than the initialization value.
@li MFX_ERR_NONE If reset is possible.
The following limited list of parameters can be changed without starting a new coded sequence:
@li The bitrate parameters, TargetKbps and MaxKbps, in the mfxInfoMFX structure.
@li The number of slices, NumSlice, in the mfxInfoMFX structure. Number of slices should be equal to or less than the number of slices during initialization.
@li The number of temporal layers in the mfxExtAvcTemporalLayers structure. Reset should be called immediately before encoding of frame from base layer and
number of reference frames should be large enough for the new temporal layers structure.
@li The quantization parameters, QPI, QPP and QPB, in the mfxInfoMFX structure.
The application should retrieve all cached frames before calling reset. When the Query API function
checks for reset outcome, it expects that this requirement be satisfied. If it is not true and there are some cached frames inside the
encoder, then the query result may differ from the reset result, because the encoder may insert an IDR frame to produce valid coded sequence.
\verbatim embed:rst
See the :ref:`Configuration Change <config-change>` section for more information.
\endverbatim
@note Not all implementations of the encoder support this extended buffer. The application must use query mode 1 to determine if the
functionality is supported. To do this, the application must attach this extended buffer to the mfxVideoParam structure and call the
MFXVideoENCODE_Query function. If the function returns MFX_ERR_NONE, then the functionality is supported.
\verbatim embed:rst
See the :ref:`Streaming and Video Conferencing Features <stream_vid_conf_features>` section for more information.
\endverbatim
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_ENCODER_RESET_OPTION. */
/*!
Instructs encoder to start new sequence after reset. Use one of the CodingOptionValue options:
@li MFX_CODINGOPTION_ON The encoder completely reset internal state and begins new coded sequence after reset, including
insertion of IDR frame, sequence, and picture headers.
@li MFX_CODINGOPTION_OFF The encoder continues encoding of current coded sequence after reset, without insertion of IDR frame.
@li MFX_CODINGOPTION_UNKNOWN Depending on the current encoder state and changes in configuration parameters, the encoder may or may not
start new coded sequence. This value is also used to query reset outcome.
*/
mfxU16 StartNewSequence;
mfxU16 reserved[11];
} mfxExtEncoderResetOption;
MFX_PACK_END()
/*! The LongTermIdx specifies long term index of picture control. */
enum {
MFX_LONGTERM_IDX_NO_IDX = 0xFFFF /*!< Long term index of picture is undefined. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used by the encoder to report additional information about the encoded picture. The application can attach
this buffer to the mfxBitstream structure before calling MFXVideoENCODE_EncodeFrameAsync function. For interlaced content the encoder
requires two such structures. They correspond to fields in encoded order.
@note Not all implementations of the encoder support this extended buffer. The application must use query mode 1 to determine if
the functionality is supported. To do this, the application must attach this extended buffer to the mfxVideoParam structure and
call the MFXVideoENCODE_Query function. If the function returns MFX_ERR_NONE then the functionality is supported.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_ENCODED_FRAME_INFO. */
mfxU32 FrameOrder; /*!< Frame order of encoded picture. */
mfxU16 PicStruct; /*!< Picture structure of encoded picture. */
mfxU16 LongTermIdx; /*!< Long term index of encoded picture if applicable. */
mfxU32 MAD; /*!< Mean Absolute Difference between original pixels of the frame and motion compensated (for inter macroblocks) or
spatially predicted (for intra macroblocks) pixels. Only luma component, Y plane, is used in calculation. */
mfxU16 BRCPanicMode; /*!< Bitrate control was not able to allocate enough bits for this frame. Frame quality may be unacceptably low. */
mfxU16 QP; /*!< Luma QP. */
mfxU32 SecondFieldOffset; /*!< Offset to second field. Second field starts at mfxBitstream::Data + mfxBitstream::DataOffset + mfxExtAVCEncodedFrameInfo::SecondFieldOffset. */
mfxU16 reserved[2];
struct {
/*! @{
@name Reference Lists
The following structure members are used by the reference lists contained in the parent structure. */
mfxU32 FrameOrder; /*!< Frame order of reference picture. */
mfxU16 PicStruct; /*!< Picture structure of reference picture. */
mfxU16 LongTermIdx; /*!< Long term index of reference picture if applicable. */
mfxU16 reserved[4];
/*! @} */
} UsedRefListL0[32], /*!< Reference list that has been used to encode picture. */
UsedRefListL1[32]; /*!< Reference list that has been used to encode picture. */
} mfxExtAVCEncodedFrameInfo;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used to specify input stream details for composition of several input surfaces in the one output.
*/
typedef struct mfxVPPCompInputStream {
mfxU32 DstX; /*!< X coordinate of location of input stream in output surface. */
mfxU32 DstY; /*!< Y coordinate of location of input stream in output surface. */
mfxU32 DstW; /*!< Width of of location of input stream in output surface.*/
mfxU32 DstH; /*!< Height of of location of input stream in output surface.*/
mfxU16 LumaKeyEnable; /*!< Non-zero value enables luma keying for the input stream. Luma keying is used to mark some of the areas
of the frame with specified luma values as transparent. It may, for example, be used for closed captioning. */
mfxU16 LumaKeyMin; /*!< Minimum value of luma key, inclusive. Pixels whose luma values fit in this range are rendered transparent. */
mfxU16 LumaKeyMax; /*!< Maximum value of luma key, inclusive. Pixels whose luma values fit in this range are rendered transparent. */
mfxU16 GlobalAlphaEnable; /*!< Non-zero value enables global alpha blending for this input stream. */
mfxU16 GlobalAlpha; /*!< Alpha value for this stream. Should be in the range of 0 to 255, where 0 is transparent and 255 is opaque. */
mfxU16 PixelAlphaEnable; /*!< Non-zero value enables per pixel alpha blending for this input stream. The stream should have RGB color format. */
mfxU16 TileId; /*!< Specify the tile this video stream is assigned to. Should be in the range of 0 to NumTiles. Valid only if NumTiles > 0. */
mfxU16 reserved2[17];
} mfxVPPCompInputStream;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
Used to control composition of several input surfaces in one output. In this mode, the VPP skips
any other filters. The VPP returns an error if any mandatory filter is specified and returns the filter skipped warning if an optional filter is specified. The only
supported filters are deinterlacing and interlaced scaling. The only supported combinations of input and output color formats are:
- RGB to RGB,
- NV12 to NV12,
- RGB and NV12 to NV12, for per the pixel alpha blending use case.
The VPP returns MFX_ERR_MORE_DATA for additional input until an output is ready. When the output is ready, the VPP returns MFX_ERR_NONE.
The application must process the output frame after synchronization.
The composition process is controlled by:
- mfxFrameInfo::CropXYWH in the input surface defines the location of the picture in the input frame.
- InputStream[i].DstXYWH defines the location of the cropped input picture in the output frame.
- mfxFrameInfo::CropXYWH in the output surface defines the actual part of the output frame. All pixels in the output frame outside this region will be filled by the specified color.
If the application uses the composition process on video streams with different frame sizes, the application should provide maximum frame size in the
mfxVideoParam structure during the initialization, reset, or query operations.
If the application uses the composition process, the MFXVideoVPP_QueryIOSurf function returns the cumulative number of input surfaces, that is, the number
required to process all input video streams. The function sets the frame size in the mfxFrameAllocRequest equal to the size provided by the
application in the mfxVideoParam structure.
The composition process supports all types of surfaces.
All input surfaces should have the same type and color format, except for the per pixel alpha blending case, where it is allowable to mix NV12 and RGB
surfaces.
There are three different blending use cases:
- <b>Luma keying.</b> All input surfaces should have the NV12 color format specified during VPP initialization. Part of each surface, including the
first one, may be rendered transparent by using LumaKeyEnable, LumaKeyMin, and LumaKeyMax values.
- <b>Global alpha blending.</b> All input surfaces should have the same color format, NV12 or RGB, specified during VPP initialization. Each input surface, including the first one, can be blended with underlying surfaces by using GlobalAlphaEnable and
GlobalAlpha values.
- <b>Per-pixel alpha blending.</b> It is allowed to mix NV12 and RGB input surfaces. Each RGB input surface, including the first one,
can be blended with underlying surfaces by using PixelAlphaEnable value.
It is not allowed to mix different blending use cases in the same function call.
In the special case where the destination region of the output surface defined by output crops is fully covered with destination sub-regions of the
surfaces, the fast compositing mode can be enabled. The main use case for this mode is a video-wall scenario with a fixed destination surface
partition into sub-regions of potentially different size.
In order to trigger this mode, the application must cluster input surfaces into tiles, defining at least one tile by setting the NumTiles
field to be greater than 0, and assigning surfaces to the corresponding tiles by setting the TileId field to the value within the 0 to NumTiles range per
input surface. Tiles should also satisfy the following additional constraints:
- Each tile should not have more than 8 surfaces assigned to it.
- Tile bounding boxes, as defined by the enclosing rectangles of a union of a surfaces assigned to this tile, should not intersect.
Background color may be changed dynamically through Reset. There is no default value. YUV black is (0;128;128) or (16;128;128) depending
on the sample range. The library uses a YUV or RGB triple depending on output color format.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_COMPOSITE. */
/* background color*/
union {
mfxU16 Y; /*!< Y value of the background color. */
mfxU16 R; /*!< R value of the background color. */
};
union {
mfxU16 U; /*!< U value of the background color. */
mfxU16 G; /*!< G value of the background color. */
};
union {
mfxU16 V; /*!< V value of the background color. */
mfxU16 B; /*!< B value of the background color. */
};
mfxU16 NumTiles; /*!< Number of input surface clusters grouped together to enable fast compositing. May be changed dynamically
at runtime through Reset. */
mfxU16 reserved1[23];
mfxU16 NumInputStream; /*!< Number of input surfaces to compose one output. May be changed dynamically at runtime through Reset. Number of surfaces
can be decreased or increased, but should not exceed the number specified during initialization. Query mode 2 should be used
to find the maximum supported number. */
mfxVPPCompInputStream *InputStream; /*!< An array of mfxVPPCompInputStream structures that describe composition of input video streams. It should consist of exactly NumInputStream elements. */
} mfxExtVPPComposite;
MFX_PACK_END()
/*! The TransferMatrix enumerator itemizes color transfer matrices. */
enum {
MFX_TRANSFERMATRIX_UNKNOWN = 0, /*!< Transfer matrix is not specified */
MFX_TRANSFERMATRIX_BT709 = 1, /*!< Transfer matrix from ITU-R BT.709 standard. */
MFX_TRANSFERMATRIX_BT601 = 2 /*!< Transfer matrix from ITU-R BT.601 standard. */
};
/* The NominalRange enumerator itemizes pixel's value nominal range. */
enum {
MFX_NOMINALRANGE_UNKNOWN = 0, /*!< Range is not defined. */
MFX_NOMINALRANGE_0_255 = 1, /*!< Range is from 0 to 255. */
MFX_NOMINALRANGE_16_235 = 2 /*!< Range is from 16 to 235. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used to control transfer matrix and nominal range of YUV frames. The application
should provide this during initialization. Supported for multiple conversions, for example YUV to YUV, YUV to RGB, and RGB to YUV.
@note This structure is used by VPP only and is not compatible with mfxExtVideoSignalInfo.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_VIDEO_SIGNAL_INFO. */
mfxU16 reserved1[4];
union {
struct { // Init
struct {
mfxU16 TransferMatrix; /*!< Transfer matrix. */
mfxU16 NominalRange; /*!< Nominal range. */
mfxU16 reserved2[6];
} In, Out;
};
struct { // Runtime<
mfxU16 TransferMatrix; /*!< Transfer matrix. */
mfxU16 NominalRange; /*!< Nominal range. */
mfxU16 reserved3[14];
};
};
} mfxExtVPPVideoSignalInfo;
MFX_PACK_END()
/*! The ROImode enumerator itemizes QP adjustment mode for ROIs. */
enum {
MFX_ROI_MODE_PRIORITY = 0, /*!< Priority mode. */
MFX_ROI_MODE_QP_DELTA = 1, /*!< QP mode */
MFX_ROI_MODE_QP_VALUE = 2 /*!< Absolute QP */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used by the application to specify different Region Of Interests during encoding. It may be used at
initialization or at runtime.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_ENCODER_ROI. */
mfxU16 NumROI; /*!< Number of ROI descriptions in array. The Query API function mode 2 returns maximum supported value (set it to 256 and
query will update it to maximum supported value). */
mfxU16 ROIMode; /*!< QP adjustment mode for ROIs. Defines if Priority or DeltaQP is used during encoding. */
mfxU16 reserved1[10];
struct {
/*! @{
@name ROI location rectangle
The ROI rectangle definition uses end-point exclusive notation. In other words, the pixel with (Right, Bottom)
coordinates lies immediately outside of the ROI. Left, Top, Right, Bottom should be aligned by codec-specific block boundaries
(should be dividable by 16 for AVC, or by 32 for HEVC). Every ROI with unaligned coordinates will be expanded by the library to minimal-area
block-aligned ROI, enclosing the original one. For example (5, 5, 15, 31) ROI will be expanded to (0, 0, 16, 32) for AVC encoder,
or to (0, 0, 32, 32) for HEVC.
*/
mfxU32 Left; /*!< Left ROI's coordinate. */
mfxU32 Top; /*!< Top ROI's coordinate. */
mfxU32 Right; /*!< Right ROI's coordinate. */
mfxU32 Bottom; /*!< Bottom ROI's coordinate. */
union {
/*! Priority of ROI. Used if ROIMode = MFX_ROI_MODE_PRIORITY.This is an absolute value in the range of -3 to 3,
which will be added to the MB QP. Priority is deprecated mode and is used only for backward compatibility.
Bigger value produces better quality. */
mfxI16 Priority;
/*! Delta QP of ROI. Used if ROIMode = MFX_ROI_MODE_QP_DELTA. This is an absolute value in the range of -51 to 51,
which will be added to the MB QP. Lesser value produces better quality. */
mfxI16 DeltaQP;
};
mfxU16 reserved2[7];
/*! @} */
} ROI[256]; /*!< Array of ROIs. Different ROI may overlap each other. If macroblock belongs to several ROI,
Priority from ROI with lowest index is used. */
} mfxExtEncoderROI;
MFX_PACK_END()
/*! The DeinterlacingMode enumerator itemizes VPP deinterlacing modes. */
enum {
MFX_DEINTERLACING_BOB = 1, /*!< BOB deinterlacing mode. */
MFX_DEINTERLACING_ADVANCED = 2, /*!< Advanced deinterlacing mode. */
MFX_DEINTERLACING_AUTO_DOUBLE = 3, /*!< Auto mode with deinterlacing double frame rate output. */
MFX_DEINTERLACING_AUTO_SINGLE = 4, /*!< Auto mode with deinterlacing single frame rate output. */
MFX_DEINTERLACING_FULL_FR_OUT = 5, /*!< Deinterlace only mode with full frame rate output. */
MFX_DEINTERLACING_HALF_FR_OUT = 6, /*!< Deinterlace only Mode with half frame rate output. */
MFX_DEINTERLACING_24FPS_OUT = 7, /*!< 24 fps fixed output mode. */
MFX_DEINTERLACING_FIXED_TELECINE_PATTERN = 8, /*!< Fixed telecine pattern removal mode. */
MFX_DEINTERLACING_30FPS_OUT = 9, /*!< 30 fps fixed output mode. */
MFX_DEINTERLACING_DETECT_INTERLACE = 10, /*!< Only interlace detection. */
MFX_DEINTERLACING_ADVANCED_NOREF = 11, /*!< Advanced deinterlacing mode without using of reference frames. */
MFX_DEINTERLACING_ADVANCED_SCD = 12, /*!< Advanced deinterlacing mode with scene change detection. */
MFX_DEINTERLACING_FIELD_WEAVING = 13 /*!< Field weaving. */
};
/*! The TelecinePattern enumerator itemizes telecine patterns. */
enum {
MFX_TELECINE_PATTERN_32 = 0, /*!< 3:2 telecine. */
MFX_TELECINE_PATTERN_2332 = 1, /*!< 2:3:3:2 telecine. */
MFX_TELECINE_PATTERN_FRAME_REPEAT = 2, /*!< One frame repeat telecine. */
MFX_TELECINE_PATTERN_41 = 3, /*!< 4:1 telecine. */
MFX_TELECINE_POSITION_PROVIDED = 4 /*!< User must provide position inside a sequence of 5 frames where the artifacts start. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used by the application to specify different deinterlacing algorithms.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_DEINTERLACING. */
mfxU16 Mode; /*!< Deinterlacing algorithm. See the DeinterlacingMode enumerator for details. */
mfxU16 TelecinePattern; /*!< Specifies telecine pattern when Mode = MFX_DEINTERLACING_FIXED_TELECINE_PATTERN. See the TelecinePattern enumerator for details.*/
mfxU16 TelecineLocation; /*!< Specifies position inside a sequence of 5 frames where the artifacts start when TelecinePattern = MFX_TELECINE_POSITION_PROVIDED*/
mfxU16 reserved[9]; /*!< Reserved for future use. */
} mfxExtVPPDeinterlacing;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Specifies reference lists for the encoder. It may be used together with the mfxExtAVCRefListCtrl
structure to create customized reference lists. If both structures are used together, then the encoder takes reference lists from the
mfxExtAVCRefLists structure and modifies them according to the mfxExtAVCRefListCtrl instructions. In case of interlaced coding,
the first mfxExtAVCRefLists structure affects TOP field and the second - BOTTOM field.
@note Not all implementations of the encoder support this structure. The application must use the Query API function to determine if it is supported.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_AVC_REFLISTS. */
mfxU16 NumRefIdxL0Active; /*!< Specify the number of reference frames in the active reference list L0. This number should be less than or
equal to the NumRefFrame parameter from encoding initialization. */
mfxU16 NumRefIdxL1Active; /*!< Specify the number of reference frames in the active reference list L1. This number should be less than or
equal to the NumRefFrame parameter from encoding initialization. */
mfxU16 reserved[2];
/*! Used by the reference lists contained in the parent structure. Together these fields are used to identify reference picture. */
struct mfxRefPic{
mfxU32 FrameOrder; /*!< Use FrameOrder = MFX_FRAMEORDER_UNKNOWN to mark
unused entry. */
mfxU16 PicStruct; /*!< Use PicStruct = MFX_PICSTRUCT_FIELD_TFF for TOP field, PicStruct = MFX_PICSTRUCT_FIELD_BFF for
BOTTOM field. */
mfxU16 reserved[5];
} RefPicList0[32], /*!< Specify L0 reference list. */
RefPicList1[32]; /*!< Specify L1 reference list. */
}mfxExtAVCRefLists;
MFX_PACK_END()
/*! The VPPFieldProcessingMode enumerator is used to control VPP field processing algorithm. */
enum {
MFX_VPP_COPY_FRAME =0x01, /*!< Copy the whole frame. */
MFX_VPP_COPY_FIELD =0x02, /*!< Copy only one field. */
MFX_VPP_SWAP_FIELDS =0x03 /*!< Swap top and bottom fields. */
};
/*! The PicType enumerator itemizes picture type. */
enum {
MFX_PICTYPE_UNKNOWN =0x00, /*!< Picture type is unknown. */
MFX_PICTYPE_FRAME =0x01, /*!< Picture is a frame. */
MFX_PICTYPE_TOPFIELD =0x02, /*!< Picture is a top field. */
MFX_PICTYPE_BOTTOMFIELD =0x04 /*!< Picture is a bottom field. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Configures the VPP field processing algorithm. The application can attach this extended buffer to
the mfxVideoParam structure to configure initialization and/or to the mfxFrameData during runtime. Runtime configuration has priority
over initialization configuration. If the field processing algorithm was activated via the mfxExtVPPDoUse structure and the mfxExtVPPFieldProcessing
extended buffer was not provided during initialization, this buffer must be attached to the mfxFrameData structure of each input surface.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_FIELD_PROCESSING. */
mfxU16 Mode; /*!< Specifies the mode of the field processing algorithm. See the VPPFieldProcessingMode enumerator for values of this option. */
mfxU16 InField; /*!< When Mode is MFX_VPP_COPY_FIELD, specifies input field. See the PicType enumerator for values of this parameter. */
mfxU16 OutField; /*!< When Mode is MFX_VPP_COPY_FIELD, specifies output field. See the PicType enumerator for values of this parameter. */
mfxU16 reserved[25];
} mfxExtVPPFieldProcessing;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
If attached to the mfxVideoParam structure during the Init stage, this buffer will instruct the decoder to resize output frames via the
fixed function resize engine (if supported by hardware), utilizing direct pipe connection and bypassing intermediate memory operations.
The main benefits of this mode of pipeline operation are offloading resize operation to a dedicated engine, thus reducing power
consumption and memory traffic.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_DEC_VIDEO_PROCESSING. */
/*! Input surface description. */
struct mfxIn{
mfxU16 CropX; /*!< X coordinate of region of interest of the input surface. */
mfxU16 CropY; /*!< Y coordinate of region of interest of the input surface. */
mfxU16 CropW; /*!< Width coordinate of region of interest of the input surface. */
mfxU16 CropH; /*!< Height coordinate of region of interest of the input surface. */
mfxU16 reserved[12];
}In; /*!< Input surface description. */
/*! Output surface description. */
struct mfxOut{
mfxU32 FourCC; /*!< FourCC of output surface Note: Should be MFX_FOURCC_NV12. */
mfxU16 ChromaFormat; /*!< Chroma Format of output surface.
@note Should be MFX_CHROMAFORMAT_YUV420 */
mfxU16 reserved1;
mfxU16 Width; /*!< Width of output surface. */
mfxU16 Height; /*!< Height of output surface. */
mfxU16 CropX; /*!< X coordinate of region of interest of the output surface. */
mfxU16 CropY; /*!< Y coordinate of region of interest of the output surface. */
mfxU16 CropW; /*!< Width coordinate of region of interest of the output surface. */
mfxU16 CropH; /*!< Height coordinate of region of interest of the output surface. */
mfxU16 reserved[22];
}Out; /*!< Output surface description. */
mfxU16 reserved[13];
} mfxExtDecVideoProcessing;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Members of this structure define the location of chroma samples information.
See Annex E of the ISO*\/IEC* 14496-10 specification for the definition of these parameters.
@note Not all implementations of the encoder support this structure. The application must use the Query API function to determine if it is supported.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_CHROMA_LOC_INFO. */
mfxU16 ChromaLocInfoPresentFlag;
mfxU16 ChromaSampleLocTypeTopField;
mfxU16 ChromaSampleLocTypeBottomField;
mfxU16 reserved[9];
} mfxExtChromaLocInfo;
MFX_PACK_END()
/*! The MBQPMode enumerator itemizes QP update modes. */
enum {
MFX_MBQP_MODE_QP_VALUE = 0, /*!< QP array contains QP values. */
MFX_MBQP_MODE_QP_DELTA = 1, /*!< QP array contains deltas for QP. */
MFX_MBQP_MODE_QP_ADAPTIVE = 2 /*!< QP array contains deltas for QP or absolute QP values. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Specifies per-MB or per-CU mode and QP or DeltaQP value depending on the mode type.
*/
typedef struct{
union {
/*!
QP for MB or CU. Valid when Mode = MFX_MBQP_MODE_QP_VALUE.
For AVC, the valid range is 1 to 51.
For HEVC, the valid range is 1 to 51. The application's provided QP values should be valid, otherwise invalid QP values may cause undefined behavior.
MBQP map should be aligned for 16x16 block size. The align rule is: (width +15 /16) && (height +15 /16).
For MPEG2, the valid range is 1 to 112. QP corresponds to quantizer_scale of the ISO*\/IEC* 13818-2 specification.
*/
mfxU8 QP;
/*!
Per-macroblock QP delta. Valid when Mode = MFX_MBQP_MODE_QP_DELTA.
*/
mfxI8 DeltaQP;
};
mfxU16 Mode; /*!< Defines QP update mode. Can be equal to MFX_MBQP_MODE_QP_VALUE or MFX_MBQP_MODE_QP_DELTA. */
} mfxQPandMode;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/*!
Specifies per-macroblock QP for current frame if mfxExtCodingOption3::EnableMBQP was turned ON during
encoder initialization. The application can attach this extended buffer to the mfxEncodeCtrl structure during runtime.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_MBQP. */
#ifdef ONEVPL_EXPERIMENTAL
mfxU32 reserved[9];
mfxU32 Pitch; /*!< Distance in bytes between the start of two consecutive rows in the QP array. */
#else
mfxU32 reserved[10];
#endif
mfxU16 Mode; /*!< Defines QP update mode. See MBQPMode enumerator for more details. */
mfxU16 BlockSize; /*!< QP block size, valid for HEVC only during Init and Runtime. */
mfxU32 NumQPAlloc; /*!< Size of allocated by application QP or DeltaQP array. */
union {
/*!
Pointer to a list of per-macroblock QP in raster scan order. In case of interlaced encoding the first half of QP array affects the top
field and the second half of QP array affects the bottom field. Valid when Mode = MFX_MBQP_MODE_QP_VALUE.
For AVC, the valid range is 1 to 51.
For HEVC, the valid range is 1 to 51. Application's provided QP values should be valid. Otherwise invalid QP values may cause undefined behavior.
MBQP map should be aligned for 16x16 block size. The alignment rule is (width +15 /16) && (height +15 /16).
For MPEG2, QP corresponds to quantizer_scale of the ISO*\/IEC* 13818-2 specification and has a valid range of 1 to 112.
*/
mfxU8 *QP;
mfxI8 *DeltaQP; /*!< Pointer to a list of per-macroblock QP deltas in raster scan order.
For block i: QP[i] = BrcQP[i] + DeltaQP[i]. Valid when Mode = MFX_MBQP_MODE_QP_DELTA. */
mfxQPandMode *QPmode; /*!< Block-granularity modes when MFX_MBQP_MODE_QP_ADAPTIVE is set. */
mfxU64 reserved2;
};
} mfxExtMBQP;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Runtime ctrl buffer for SPS/PPS insertion with current encoding frame.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_INSERT_HEADERS. */
mfxU16 SPS; /*!< Tri-state option to insert SPS. */
mfxU16 PPS; /*!< Tri-state option to insert PPS. */
mfxU16 reserved[8];
} mfxExtInsertHeaders;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
Specifies rectangle areas for IPCM coding mode.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_ENCODER_IPCM_AREA. */
mfxU16 reserve1[10];
mfxU16 NumArea; /*! Number of areas */
struct area {
mfxU32 Left; /*!< Left area coordinate. */
mfxU32 Top; /*!< Top area coordinate. */
mfxU32 Right; /*!< Right area coordinate. */
mfxU32 Bottom; /*!< Bottom area coordinate. */
mfxU16 reserved2[8];
} * Areas; /*!< Array of areas. */
} mfxExtEncoderIPCMArea;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/*!
Specifies macroblock map for current frame which forces specified macroblocks to be encoded as intra
if mfxExtCodingOption3::EnableMBForceIntra was turned ON during encoder initialization. The application can attach this extended
buffer to the mfxEncodeCtrl structure during runtime.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_MB_FORCE_INTRA. */
mfxU32 reserved[11];
mfxU32 MapSize; /*!< Macroblock map size. */
union {
mfxU8 *Map; /*!< Pointer to a list of force intra macroblock flags in raster scan order. Each flag is one byte in map. Set flag to 1
to force corresponding macroblock to be encoded as intra. In case of interlaced encoding, the first half of map
affects top field and the second half of map affects the bottom field. */
mfxU64 reserved2;
};
} mfxExtMBForceIntra;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Configures tiles options for the HEVC encoder. The application can attach this extended buffer to the
mfxVideoParam structure to configure initialization.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_HEVC_TILES. */
mfxU16 NumTileRows; /*!< Number of tile rows. */
mfxU16 NumTileColumns; /*!< Number of tile columns. */
mfxU16 reserved[74];
}mfxExtHEVCTiles;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/*!
Specifies macroblock map for current frame which forces specified macroblocks to be non-skip if
mfxExtCodingOption3::MBDisableSkipMap was turned ON during encoder initialization. The application can attach this
extended buffer to the mfxEncodeCtrl structure during runtime.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_MB_DISABLE_SKIP_MAP. */
mfxU32 reserved[11];
mfxU32 MapSize; /*!< Macroblock map size. */
union {
mfxU8 *Map; /*!< Pointer to a list of non-skip macroblock flags in raster scan order. Each flag is one byte in map. Set flag to 1 to force
corresponding macroblock to be non-skip. In case of interlaced encoding, the first half of map affects
the top field and the second half of map affects the bottom field. */
mfxU64 reserved2;
};
} mfxExtMBDisableSkipMap;
MFX_PACK_END()
/*! The GeneralConstraintFlags enumerator uses bit-ORed values to itemize HEVC bitstream indications for specific profiles. Each value
indicates for format range extensions profiles.
To specify HEVC Main 10 Still Picture profile applications have to set mfxInfoMFX::CodecProfile == MFX_PROFILE_HEVC_MAIN10 and
mfxExtHEVCParam::GeneralConstraintFlags == MFX_HEVC_CONSTR_REXT_ONE_PICTURE_ONLY. */
enum {
/* REXT Profile constraint flags*/
MFX_HEVC_CONSTR_REXT_MAX_12BIT = (1 << 0),
MFX_HEVC_CONSTR_REXT_MAX_10BIT = (1 << 1),
MFX_HEVC_CONSTR_REXT_MAX_8BIT = (1 << 2),
MFX_HEVC_CONSTR_REXT_MAX_422CHROMA = (1 << 3),
MFX_HEVC_CONSTR_REXT_MAX_420CHROMA = (1 << 4),
MFX_HEVC_CONSTR_REXT_MAX_MONOCHROME = (1 << 5),
MFX_HEVC_CONSTR_REXT_INTRA = (1 << 6),
MFX_HEVC_CONSTR_REXT_ONE_PICTURE_ONLY = (1 << 7),
MFX_HEVC_CONSTR_REXT_LOWER_BIT_RATE = (1 << 8)
};
/*! The SampleAdaptiveOffset enumerator uses bit-ORed values to itemize corresponding HEVC encoding feature. */
enum {
MFX_SAO_UNKNOWN = 0x00, /*!< Use default value for platform/TargetUsage. */
MFX_SAO_DISABLE = 0x01, /*!< Disable SAO. If set during Init leads to SPS sample_adaptive_offset_enabled_flag = 0.
If set during Runtime, leads to to slice_sao_luma_flag = 0 and slice_sao_chroma_flag = 0
for current frame. */
MFX_SAO_ENABLE_LUMA = 0x02, /*!< Enable SAO for luma (slice_sao_luma_flag = 1). */
MFX_SAO_ENABLE_CHROMA = 0x04 /*!< Enable SAO for chroma (slice_sao_chroma_flag = 1). */
};
/* This struct has 4-byte alignment for binary compatibility with previously released versions of API */
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_HEVC_PARAM. */
mfxU16 PicWidthInLumaSamples; /*!< Specifies the width of each coded picture in units of luma samples. */
mfxU16 PicHeightInLumaSamples; /*!< Specifies the height of each coded picture in units of luma samples. */
mfxU64 GeneralConstraintFlags; /*!< Additional flags to specify exact profile and constraints. See the GeneralConstraintFlags enumerator for values of this field. */
mfxU16 SampleAdaptiveOffset; /*!< Controls SampleAdaptiveOffset encoding feature. See the SampleAdaptiveOffset enumerator for supported values
(bit-ORed). Valid during encoder Init and Runtime. */
mfxU16 LCUSize; /*!< Specifies largest coding unit size (max luma coding block). Valid during encoder Init. */
mfxU16 reserved[116];
} mfxExtHEVCParam;
MFX_PACK_END()
/*! The ErrorTypes enumerator uses bit-ORed values to itemize bitstream error types. */
enum {
MFX_ERROR_NO = 0, /*!< No error in bitstream. */
MFX_ERROR_PPS = (1 << 0), /*!< Invalid/corrupted PPS. */
MFX_ERROR_SPS = (1 << 1), /*!< Invalid/corrupted SPS. */
MFX_ERROR_SLICEHEADER = (1 << 2), /*!< Invalid/corrupted slice header. */
MFX_ERROR_SLICEDATA = (1 << 3), /*!< Invalid/corrupted slice data. */
MFX_ERROR_FRAME_GAP = (1 << 4), /*!< Missed frames. */
MFX_ERROR_JPEG_APP0_MARKER = (1 << 5), /*!< Invalid/corrupted APP0 marker. */
MFX_ERROR_JPEG_APP1_MARKER = (1 << 6), /*!< Invalid/corrupted APP1 marker. */
MFX_ERROR_JPEG_APP2_MARKER = (1 << 7), /*!< Invalid/corrupted APP2 marker. */
MFX_ERROR_JPEG_APP3_MARKER = (1 << 8), /*!< Invalid/corrupted APP3 marker. */
MFX_ERROR_JPEG_APP4_MARKER = (1 << 9), /*!< Invalid/corrupted APP4 marker. */
MFX_ERROR_JPEG_APP5_MARKER = (1 << 10), /*!< Invalid/corrupted APP5 marker. */
MFX_ERROR_JPEG_APP6_MARKER = (1 << 11), /*!< Invalid/corrupted APP6 marker. */
MFX_ERROR_JPEG_APP7_MARKER = (1 << 12), /*!< Invalid/corrupted APP7 marker. */
MFX_ERROR_JPEG_APP8_MARKER = (1 << 13), /*!< Invalid/corrupted APP8 marker. */
MFX_ERROR_JPEG_APP9_MARKER = (1 << 14), /*!< Invalid/corrupted APP9 marker. */
MFX_ERROR_JPEG_APP10_MARKER = (1 << 15), /*!< Invalid/corrupted APP10 marker. */
MFX_ERROR_JPEG_APP11_MARKER = (1 << 16), /*!< Invalid/corrupted APP11 marker. */
MFX_ERROR_JPEG_APP12_MARKER = (1 << 17), /*!< Invalid/corrupted APP12 marker. */
MFX_ERROR_JPEG_APP13_MARKER = (1 << 18), /*!< Invalid/corrupted APP13 marker. */
MFX_ERROR_JPEG_APP14_MARKER = (1 << 19), /*!< Invalid/corrupted APP14 marker. */
MFX_ERROR_JPEG_DQT_MARKER = (1 << 20), /*!< Invalid/corrupted DQT marker. */
MFX_ERROR_JPEG_SOF0_MARKER = (1 << 21), /*!< Invalid/corrupted SOF0 marker. */
MFX_ERROR_JPEG_DHT_MARKER = (1 << 22), /*!< Invalid/corrupted DHT marker. */
MFX_ERROR_JPEG_DRI_MARKER = (1 << 23), /*!< Invalid/corrupted DRI marker. */
MFX_ERROR_JPEG_SOS_MARKER = (1 << 24), /*!< Invalid/corrupted SOS marker. */
MFX_ERROR_JPEG_UNKNOWN_MARKER = (1 << 25), /*!< Unknown Marker. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used by the decoders to report bitstream error information right after DecodeHeader or DecodeFrameAsync.
The application can attach this extended buffer to the mfxBitstream structure at runtime.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_DECODE_ERROR_REPORT. */
mfxU32 ErrorTypes; /*!< Bitstream error types (bit-ORed values). See ErrorTypes enumerator for the list of types. */
mfxU16 reserved[10];
} mfxExtDecodeErrorReport;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used by the decoders to report additional information about a decoded frame. The application can attach this
extended buffer to the mfxFrameSurface1::mfxFrameData structure at runtime.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_DECODED_FRAME_INFO. */
mfxU16 FrameType; /*!< Frame type. See FrameType enumerator for the list of types. */
mfxU16 reserved[59];
} mfxExtDecodedFrameInfo;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used by the library to pass MPEG 2 specific timing information.
See ISO/IEC 13818-2 and ITU-T H.262, MPEG-2 Part 2 for the definition of these parameters.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_TIME_CODE. */
mfxU16 DropFrameFlag; /*!< Indicated dropped frame. */
mfxU16 TimeCodeHours; /*!< Hours. */
mfxU16 TimeCodeMinutes; /*!< Minutes. */
mfxU16 TimeCodeSeconds; /*!< Seconds. */
mfxU16 TimeCodePictures; /*!< Pictures. */
mfxU16 reserved[7];
} mfxExtTimeCode;
MFX_PACK_END()
/*! The HEVCRegionType enumerator itemizes type of HEVC region. */
enum {
MFX_HEVC_REGION_SLICE = 0 /*!< Slice type. */
};
/*! The HEVCRegionEncoding enumerator itemizes HEVC region's encoding. */
enum {
MFX_HEVC_REGION_ENCODING_ON = 0,
MFX_HEVC_REGION_ENCODING_OFF = 1
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Attached to the mfxVideoParam structure during HEVC encoder initialization. Specifies the region to encode.
@note Not all implementations of the encoder support this structure. The application must use the Query API function to determine if it is supported.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_HEVC_REGION. */
mfxU32 RegionId; /*!< ID of region. */
mfxU16 RegionType; /*!< Type of region. See HEVCRegionType enumerator for the list of types. */
mfxU16 RegionEncoding; /*!< Set to MFX_HEVC_REGION_ENCODING_ON to encode only specified region. */
mfxU16 reserved[24];
} mfxExtHEVCRegion;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Specifies weighted prediction table for current frame when all of the following conditions are met:
@li mfxExtCodingOption3::WeightedPred was set to explicit during encoder Init or Reset .
@li The current frame is P-frame or mfxExtCodingOption3::WeightedBiPred was set to explicit during encoder Init or Reset.
@li The current frame is B-frame and is attached to the mfxEncodeCtrl structure.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_PRED_WEIGHT_TABLE. */
mfxU16 LumaLog2WeightDenom; /*!< Base 2 logarithm of the denominator for all luma weighting factors. Value must be in the range of 0 to 7, inclusive. */
mfxU16 ChromaLog2WeightDenom; /*!< Base 2 logarithm of the denominator for all chroma weighting factors. Value must be in the range of 0 to 7, inclusive. */
mfxU16 LumaWeightFlag[2][32]; /*!< LumaWeightFlag[L][R] equal to 1 specifies that the weighting factors for the luma component are specified for R's entry of RefPicList L. */
mfxU16 ChromaWeightFlag[2][32]; /*!< ChromaWeightFlag[L][R] equal to 1 specifies that the weighting factors for the chroma component are specified for R's entry of RefPicList L. */
mfxI16 Weights[2][32][3][2]; /*!< The values of the weights and offsets used in the encoding processing. The value of Weights[i][j][k][m] is
interpreted as: i refers to reference picture list 0 or 1; j refers to reference list entry 0-31;
k refers to data for the luma component when it is 0, the Cb chroma component when it is 1 and
the Cr chroma component when it is 2; m refers to weight when it is 0 and offset when it is 1 */
mfxU16 reserved[58];
} mfxExtPredWeightTable;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used by encoders to set rounding offset parameters for quantization. It is per-frame based encoding control,
and can be attached to some frames and skipped for others. When the extension buffer is set the application can attach it to the mfxEncodeCtrl
during runtime.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_AVC_ROUNDING_OFFSET. */
mfxU16 EnableRoundingIntra; /*!< Enable rounding offset for intra blocks. See the CodingOptionValue enumerator for values of this option. */
mfxU16 RoundingOffsetIntra; /*!< Intra rounding offset. Value must be in the range of 0 to 7, inclusive. */
mfxU16 EnableRoundingInter; /*!< Enable rounding offset for inter blocks. See the CodingOptionValue enumerator for values of this option. */
mfxU16 RoundingOffsetInter; /*!< Inter rounding offset. Value must be in the range of 0 to 7, inclusive. */
mfxU16 reserved[24];
} mfxExtAVCRoundingOffset;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used by the application to specify dirty regions within a frame during encoding. It may be used at initialization or at runtime.
Dirty rectangle definition is using end-point exclusive notation. In other words, the pixel with (Right, Bottom) coordinates lies
immediately outside of the dirty rectangle. Left, Top, Right, Bottom should be aligned by codec-specific block boundaries (should be
dividable by 16 for AVC, or by block size (8, 16, 32 or 64, depends on platform) for HEVC).
Every dirty rectangle with unaligned
coordinates will be expanded to a minimal-area block-aligned dirty rectangle, enclosing the original one.
For example, a (5, 5, 15, 31) dirty rectangle will be expanded to (0, 0, 16, 32) for AVC encoder, or to (0, 0, 32, 32) for HEVC,
if block size is 32.
Dirty rectangle (0, 0, 0, 0) is a valid dirty rectangle and means that the frame is not changed.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_DIRTY_RECTANGLES. */
mfxU16 NumRect; /*!< Number of dirty rectangles. */
mfxU16 reserved1[11];
struct {
/*! @{
@name Dirty rectangle coordinates
The following structure members are used by the Rect array contained in the parent structure.
*/
mfxU32 Left; /*!< Dirty region left coordinate. */
mfxU32 Top; /*!< Dirty region top coordinate. */
mfxU32 Right; /*!< Dirty region right coordinate. */
mfxU32 Bottom; /*!< Dirty region bottom coordinate. */
mfxU16 reserved2[8];
/*! @} */
} Rect[256]; /*!< Array of dirty rectangles. */
} mfxExtDirtyRect;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used by the application to specify moving regions within a frame during encoding.
Destination rectangle location should be aligned to MB boundaries (should be dividable by 16). If not, the encoder
truncates it to MB boundaries, for example, both 17 and 31 will be truncated to 16.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_MOVING_RECTANGLE. */
mfxU16 NumRect; /*!< Number of moving rectangles. */
mfxU16 reserved1[11];
struct {
/*! @{
@name Destination and source rectangle location
The following structure members are used by the Rect array contained in the parent structure.
*/
mfxU32 DestLeft; /*!< Destination rectangle location. */
mfxU32 DestTop; /*!< Destination rectangle location. */
mfxU32 DestRight; /*!< Destination rectangle location. */
mfxU32 DestBottom; /*!< Destination rectangle location. */
mfxU32 SourceLeft; /*!< Source rectangle location. */
mfxU32 SourceTop; /*!< Source rectangle location. */
mfxU16 reserved2[4];
/*! @} */
} Rect[256]; /*!< Array of moving rectangles. */
} mfxExtMoveRect;
MFX_PACK_END()
/*! The Angle enumerator itemizes valid rotation angles. */
enum {
MFX_ANGLE_0 = 0, /*!< 0 degrees. */
MFX_ANGLE_90 = 90, /*!< 90 degrees. */
MFX_ANGLE_180 = 180, /*!< 180 degrees. */
MFX_ANGLE_270 = 270 /*!< 270 degrees. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Configures the VPP Rotation filter algorithm.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_ROTATION. */
mfxU16 Angle; /*!< Rotation angle. See Angle enumerator for supported values. */
mfxU16 reserved[11];
} mfxExtVPPRotation;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/*!
Used by the encoder to report additional information about encoded slices. The application can attach this
buffer to the mfxBitstream structure before calling the MFXVideoENCODE_EncodeFrameAsync function.
@note Not all implementations of the encoder support this extended buffer. The application must use query mode 1 to determine if the
functionality is supported. To do this, the application must attach this extended buffer to the mfxVideoParam structure and call the
MFXVideoENCODE_Query function. If the function returns MFX_ERR_NONE, then the functionality is supported.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_ENCODED_SLICES_INFO. */
mfxU16 SliceSizeOverflow; /*!< When mfxExtCodingOption2::MaxSliceSize is used, indicates the requested slice size was not met for one or more generated slices. */
mfxU16 NumSliceNonCopliant; /*!< When mfxExtCodingOption2::MaxSliceSize is used, indicates the number of generated slices exceeds specification limits. */
mfxU16 NumEncodedSlice; /*!< Number of encoded slices. */
mfxU16 NumSliceSizeAlloc; /*!< SliceSize array allocation size. Must be specified by application. */
union {
mfxU16 *SliceSize; /*!< Slice size in bytes. Array must be allocated by application. */
mfxU64 reserved1;
};
mfxU16 reserved[20];
} mfxExtEncodedSlicesInfo;
MFX_PACK_END()
/*! The ScalingMode enumerator itemizes variants of scaling filter implementation. */
enum {
MFX_SCALING_MODE_DEFAULT = 0, /*!< Default scaling mode. The library selects the most appropriate scaling method. */
MFX_SCALING_MODE_LOWPOWER = 1, /*!< Low power scaling mode which is applicable for library implementations.
The exact scaling algorithm is defined by the library. */
MFX_SCALING_MODE_QUALITY = 2, /*!< The best quality scaling mode. */
MFX_SCALING_MODE_VENDOR = 1000, /*!< The enumeration to separate common scaling controls above and vendor specific. */
MFX_SCALING_MODE_INTEL_GEN_COMPUTE = MFX_SCALING_MODE_VENDOR + 1, /*! The mode to run scaling operation on Execution Units (EUs). */
MFX_SCALING_MODE_INTEL_GEN_VDBOX = MFX_SCALING_MODE_VENDOR + 2, /*! The special optimization mode where scaling operation running on SFC (Scaler & Format Converter) is coupled with VDBOX (also known as Multi-Format Codec fixed-function engine). This mode is applicable for DECODE_VPP domain functions. */
MFX_SCALING_MODE_INTEL_GEN_VEBOX = MFX_SCALING_MODE_VENDOR + 3 /*! The special optimization mode where scaling operation running on SFC is coupled with VEBOX (HW video processing pipe). */
};
/*! The InterpolationMode enumerator specifies type of interpolation method used by VPP scaling filter. */
enum {
MFX_INTERPOLATION_DEFAULT = 0, /*!< Default interpolation mode for scaling. Library selects the most appropriate
scaling method. */
MFX_INTERPOLATION_NEAREST_NEIGHBOR = 1, /*!< Nearest neighbor interpolation method. */
MFX_INTERPOLATION_BILINEAR = 2, /*!< Bilinear interpolation method. */
MFX_INTERPOLATION_ADVANCED = 3 /*!< Advanced interpolation method is defined by each implementation and usually gives best quality. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Configures the VPP Scaling filter algorithm.
Not all combinations of ScalingMode and InterpolationMethod are supported in the library. The application must use the Query API function to determine if a combination is supported.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_SCALING. */
mfxU16 ScalingMode; /*!< Scaling mode. See ScalingMode for values. */
mfxU16 InterpolationMethod; /*!< Interpolation mode for scaling algorithm. See InterpolationMode for values. */
mfxU16 reserved[10];
} mfxExtVPPScaling;
MFX_PACK_END()
typedef mfxExtAVCRefListCtrl mfxExtHEVCRefListCtrl;
typedef mfxExtAVCRefLists mfxExtHEVCRefLists;
typedef mfxExtAvcTemporalLayers mfxExtHEVCTemporalLayers;
typedef mfxExtAVCRefListCtrl mfxExtRefListCtrl;
/* The MirroringType enumerator itemizes mirroring types. */
enum
{
MFX_MIRRORING_DISABLED = 0,
MFX_MIRRORING_HORIZONTAL = 1,
MFX_MIRRORING_VERTICAL = 2
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Configures the VPP Mirroring filter algorithm.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_MIRRORING. */
mfxU16 Type; /*!< Mirroring type. See MirroringType for values. */
mfxU16 reserved[11];
} mfxExtVPPMirroring;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Instructs encoder to use or not use samples over specified picture border for inter prediction. Attached to the mfxVideoParam structure.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_MV_OVER_PIC_BOUNDARIES. */
mfxU16 StickTop; /*!< When set to OFF, one or more samples outside corresponding picture boundary may be used in inter prediction.
See the CodingOptionValue enumerator for values of this option. */
mfxU16 StickBottom; /*!< When set to OFF, one or more samples outside corresponding picture boundary may be used in inter prediction.
See the CodingOptionValue enumerator for values of this option. */
mfxU16 StickLeft; /*!< When set to OFF, one or more samples outside corresponding picture boundary may be used in inter prediction.
See the CodingOptionValue enumerator for values of this option. */
mfxU16 StickRight; /*!< When set to OFF, one or more samples outside corresponding picture boundary may be used in inter prediction.
See the CodingOptionValue enumerator for values of this option. */
mfxU16 reserved[8];
} mfxExtMVOverPicBoundaries;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Configures the VPP ColorFill filter algorithm.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_COLORFILL. */
mfxU16 Enable; /*!< Set to ON makes VPP fill the area between Width/Height and Crop borders.
See the CodingOptionValue enumerator for values of this option. */
mfxU16 reserved[11];
} mfxExtVPPColorFill;
MFX_PACK_END()
/*! The ChromaSiting enumerator defines chroma location. Use bit-OR'ed values to specify the desired location. */
enum {
MFX_CHROMA_SITING_UNKNOWN = 0x0000, /*!< Unspecified. */
MFX_CHROMA_SITING_VERTICAL_TOP = 0x0001, /*!< Chroma samples are co-sited vertically on the top with the luma samples. */
MFX_CHROMA_SITING_VERTICAL_CENTER = 0x0002, /*!< Chroma samples are not co-sited vertically with the luma samples. */
MFX_CHROMA_SITING_VERTICAL_BOTTOM = 0x0004, /*!< Chroma samples are co-sited vertically on the bottom with the luma samples. */
MFX_CHROMA_SITING_HORIZONTAL_LEFT = 0x0010, /*!< Chroma samples are co-sited horizontally on the left with the luma samples. */
MFX_CHROMA_SITING_HORIZONTAL_CENTER = 0x0020 /*!< Chroma samples are not co-sited horizontally with the luma samples. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
A hint structure that tunes the VPP Color Conversion algorithm when
attached to the mfxVideoParam structure during VPP Init.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_COLOR_CONVERSION. */
mfxU16 ChromaSiting; /*!< See ChromaSiting enumerator for details. */
mfxU16 reserved[27];
} mfxExtColorConversion;
MFX_PACK_END()
/*! The VP9ReferenceFrame enumerator itemizes reference frame type by mfxVP9SegmentParam::ReferenceFrame parameter. */
enum {
MFX_VP9_REF_INTRA = 0, /*!< Intra. */
MFX_VP9_REF_LAST = 1, /*!< Last. */
MFX_VP9_REF_GOLDEN = 2, /*!< Golden. */
MFX_VP9_REF_ALTREF = 3 /*!< Alternative reference. */
};
/*!
The SegmentIdBlockSize enumerator indicates the block size represented by each segment_id in segmentation map.
These values are used with the mfxExtVP9Segmentation::SegmentIdBlockSize parameter.
*/
enum {
MFX_VP9_SEGMENT_ID_BLOCK_SIZE_UNKNOWN = 0, /*!< Unspecified block size. */
MFX_VP9_SEGMENT_ID_BLOCK_SIZE_8x8 = 8, /*!< 8x8 block size. */
MFX_VP9_SEGMENT_ID_BLOCK_SIZE_16x16 = 16, /*!< 16x16 block size. */
MFX_VP9_SEGMENT_ID_BLOCK_SIZE_32x32 = 32, /*!< 32x32 block size. */
MFX_VP9_SEGMENT_ID_BLOCK_SIZE_64x64 = 64, /*!< 64x64 block size. */
};
/*!
The SegmentFeature enumerator indicates features enabled for the segment.
These values are used with the mfxVP9SegmentParam::FeatureEnabled parameter.
*/
enum {
MFX_VP9_SEGMENT_FEATURE_QINDEX = 0x0001, /*!< Quantization index delta. */
MFX_VP9_SEGMENT_FEATURE_LOOP_FILTER = 0x0002, /*!< Loop filter level delta. */
MFX_VP9_SEGMENT_FEATURE_REFERENCE = 0x0004, /*!< Reference frame. */
MFX_VP9_SEGMENT_FEATURE_SKIP = 0x0008 /*!< Skip. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Contains features and parameters for the segment.
*/
typedef struct {
mfxU16 FeatureEnabled; /*!< Indicates which features are enabled for the segment. See the SegmentFeature enumerator for values for this
option. Values from the enumerator can be bit-OR'ed. Support of a particular feature depends on underlying
hardware platform. Application can check which features are supported by calling Query. */
mfxI16 QIndexDelta; /*!< Quantization index delta for the segment. Ignored if MFX_VP9_SEGMENT_FEATURE_QINDEX isn't set in FeatureEnabled.
Valid range for this parameter is [-255, 255]. If QIndexDelta is out of this range, it will be ignored.
If QIndexDelta is within valid range, but sum of base quantization index and QIndexDelta is out of [0, 255],
QIndexDelta will be clamped. */
mfxI16 LoopFilterLevelDelta; /*!< Loop filter level delta for the segment. Ignored if MFX_VP9_SEGMENT_FEATURE_LOOP_FILTER is not set in
FeatureEnabled. Valid range for this parameter is [-63, 63]. If LoopFilterLevelDelta is out of this range,
it will be ignored. If LoopFilterLevelDelta is within valid range, but sum of base loop filter level and
LoopFilterLevelDelta is out of [0, 63], LoopFilterLevelDelta will be clamped. */
mfxU16 ReferenceFrame; /*!< Reference frame for the segment. See VP9ReferenceFrame enumerator for values for this option. Ignored
if MFX_VP9_SEGMENT_FEATURE_REFERENCE isn't set in FeatureEnabled. */
mfxU16 reserved[12];
} mfxVP9SegmentParam;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/*!
In the VP9 encoder it is possible to divide a frame into up to 8 segments and apply particular features (like delta for quantization index or for
loop filter level) on a per-segment basis. "Uncompressed header" of every frame indicates if segmentation is enabled for the current frame,
and (if segmentation enabled) contains full information about features applied to every segment. Every "Mode info block" of a coded
frame has segment_id in the range of 0 to 7.
To enable Segmentation, the mfxExtVP9Segmentation structure with correct settings should be passed to the encoder. It can be attached to the
mfxVideoParam structure during initialization or the MFXVideoENCODE_Reset call (static configuration). If the mfxExtVP9Segmentation buffer isn't
attached during initialization, segmentation is disabled for static configuration. If the buffer isn't attached for the Reset call, the encoder
continues to use static configuration for segmentation which was the default before this Reset call. If the mfxExtVP9Segmentation buffer with
NumSegments=0 is provided during initialization or Reset call, segmentation becomes disabled for static configuration.
The buffer can be attached to the mfxEncodeCtrl structure during runtime (dynamic configuration). Dynamic configuration is applied to the
current frame only. After encoding of the current frame, the encoder will switch to the next dynamic configuration or to static configuration if dynamic configuration
is not provided for next frame).
The SegmentIdBlockSize, NumSegmentIdAlloc, and SegmentId parameters represent a segmentation map. Here, the segmentation map is an array of segment_ids (one
byte per segment_id) for blocks of size NxN in raster scan order. The size NxN is specified by the application and is constant for the whole frame.
If mfxExtVP9Segmentation is attached during initialization and/or during runtime, all three parameters should be set to proper values that do not
conflict with each other and with NumSegments. If any of the parameters are not set or any conflict or error in these parameters is detected by the library, the segmentation
map will be discarded.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VP9_SEGMENTATION. */
mfxU16 NumSegments; /*!< Number of segments for frame. Value 0 means that segmentation is disabled. Sending 0 for a
particular frame will disable segmentation for this frame only. Sending 0 to the Reset API function will
disable segmentation permanently. Segmentation can be enabled again by a subsequent Reset call. */
mfxVP9SegmentParam Segment[8]; /*!< Array of mfxVP9SegmentParam structures containing features and parameters for every segment.
Entries with indexes bigger than NumSegments-1 are ignored. See the mfxVP9SegmentParam structure for
definitions of segment features and their parameters. */
mfxU16 SegmentIdBlockSize; /*!< Size of block (NxN) for segmentation map. See SegmentIdBlockSize enumerator for values for this
option. An encoded block that is bigger than SegmentIdBlockSize uses segment_id taken from it's
top-left sub-block from the segmentation map. The application can check if a particular block size is
supported by calling Query. */
mfxU32 NumSegmentIdAlloc; /*!< Size of buffer allocated for segmentation map (in bytes). Application must assure that
NumSegmentIdAlloc is large enough to cover frame resolution with blocks of size SegmentIdBlockSize.
Otherwise the segmentation map will be discarded. */
union {
mfxU8 *SegmentId; /*!< Pointer to the segmentation map buffer which holds the array of segment_ids in raster scan order. The application
is responsible for allocation and release of this memory. The buffer pointed to by SegmentId, provided during
initialization or Reset call should be considered in use until another SegmentId is provided via Reset
call (if any), or until MFXVideoENCODE_Close is called. The buffer pointed to by SegmentId provided with
mfxEncodeCtrl should be considered in use while the input surface is locked by the library. Every segment_id in the
map should be in the range of 0 to NumSegments-1. If some segment_id is out of valid range, the
segmentation map cannot be applied. If the mfxExtVP9Segmentation buffer is attached to the mfxEncodeCtrl structure in
runtime, SegmentId can be zero. In this case, the segmentation map from static configuration will be used. */
mfxU64 reserved1;
};
mfxU16 reserved[52];
} mfxExtVP9Segmentation;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Specifies temporal layer.
*/
typedef struct {
mfxU16 FrameRateScale; /*!< The ratio between the frame rates of the current temporal layer and the base layer. The library treats a particular
temporal layer as "defined" if it has FrameRateScale > 0. If the base layer is defined, it must have FrameRateScale = 1. FrameRateScale of each subsequent layer (if defined) must be a multiple of and greater than the
FrameRateScale value of previous layer. */
mfxU16 TargetKbps; /*!< Target bitrate for the current temporal layer. Ignored if RateControlMethod is CQP. If RateControlMethod is not CQP, the
application must provide TargetKbps for every defined temporal layer. TargetKbps of each subsequent layer (if defined)
must be greater than the TargetKbps value of the previous layer. */
mfxU16 reserved[14];
} mfxVP9TemporalLayer;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
API allows the encoding of VP9 bitstreams that contain several subset bitstreams that differ in frame rates, also called "temporal layers".
When decoding, each temporal layer can be extracted from the coded stream and decoded separately. The mfxExtVP9TemporalLayers structure
configures the temporal layers for the VP9 encoder. It can be attached to the mfxVideoParam structure during initialization or the
MFXVideoENCODE_Reset call. If the mfxExtVP9TemporalLayers buffer isn't attached during initialization, temporal scalability is disabled. If the buffer isn't attached for the Reset call, the encoder continues to use the temporal scalability configuration that was defined before the Reset call.
In the API, temporal layers are ordered by their frame rates in ascending order. Temporal layer 0 (having the lowest frame rate) is called the base layer.
Each subsequent temporal layer includes all previous layers.
The temporal scalability feature requires a minimum number of allocated reference
frames (controlled by the NumRefFrame parameter). If the NumRefFrame value set by the application isn't enough to build the reference structure for the requested
number of temporal layers, the library corrects the NumRefFrame value. The temporal layer structure is reset (re-started) after key-frames.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VP9_TEMPORAL_LAYERS. */
/*!
The array of temporal layers. Layer[0] specifies the base layer.
The library reads layers from the array when they are defined (FrameRateScale > 0).
All layers starting from first layer with FrameRateScale = 0 are ignored. The last layer that is not ignored is considered the "highest layer".
The frame rate of the highest layer is specified in the mfxVideoParam structure. Frame rates of lower layers are calculated using their FrameRateScale.
TargetKbps of the highest layer should be equal to the TargetKbps value specified in the mfxVideoParam structure. If it is not true, TargetKbps of highest temporal layers has priority.
If there are no defined layers in the Layer array, the temporal scalability feature is disabled. For example, to disable temporal scalability in runtime, the application should
pass mfxExtVP9TemporalLayers buffer to Reset with all FrameRateScales set to 0.
*/
mfxVP9TemporalLayer Layer[8];
mfxU16 reserved[60];
} mfxExtVP9TemporalLayers;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Structure attached to the mfxVideoParam structure. Extends the mfxVideoParam structure with VP9-specific parameters. Used by both decoder and encoder.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VP9_PARAM. */
mfxU16 FrameWidth; /*!< Width of the coded frame in pixels. */
mfxU16 FrameHeight; /*!< Height of the coded frame in pixels. */
mfxU16 WriteIVFHeaders; /*!< Set this option to ON to make the encoder insert IVF container headers to the output stream. The NumFrame field of the IVF
sequence header will be zero. It is the responsibility of the application to update the NumFrame field with the correct value. See the
CodingOptionValue enumerator for values of this option. */
mfxI16 reserved1[6];
mfxI16 QIndexDeltaLumaDC; /*!< Specifies an offset for a particular quantization parameter. */
mfxI16 QIndexDeltaChromaAC; /*!< Specifies an offset for a particular quantization parameter. */
mfxI16 QIndexDeltaChromaDC; /*!< Specifies an offset for a particular quantization parameter. */
/*!
Number of tile rows. Should be power of two. The maximum number of tile rows is 4, per the VP9 specification. In addition, the maximum supported number
of tile rows may depend on the underlying library implementation.
Use the Query API function to check if a particular pair of values (NumTileRows, NumTileColumns)
is supported. In VP9, tile rows have dependencies and cannot be encoded or decoded in parallel. Therefore, tile rows are always encoded by the library in
serial mode (one-by-one).
*/
mfxU16 NumTileRows;
/*!
Number of tile columns. Should be power of two. Restricted with maximum and minimum tile width in luma pixels, as defined in the VP9
specification (4096 and 256 respectively). In addition, the maximum supported number of tile columns may depend on the underlying library
implementation.
Use the Query API function to check if a particular pair of values (NumTileRows, NumTileColumns) is supported. In VP9, tile columns do not have
dependencies and can be encoded/decoded in parallel. Therefore, tile columns can be encoded by the library in both parallel and serial modes.
Parallel mode is automatically utilized by the library when NumTileColumns exceeds 1 and does not exceed the number of tile coding engines on the
platform. In other cases, serial mode is used. Parallel mode is capable of encoding more than 1 tile row (within limitations provided by VP9
specification and particular platform). Serial mode supports only tile grids 1xN and Nx1.
*/
mfxU16 NumTileColumns;
mfxU16 reserved[110];
} mfxExtVP9Param;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used to report encoded unit information.
*/
typedef struct {
mfxU16 Type; /*!< Codec-dependent coding unit type (NALU type for AVC/HEVC, start_code for MPEG2 etc). */
mfxU16 reserved1;
mfxU32 Offset; /*!< Offset relative to the associated mfxBitstream::DataOffset. */
mfxU32 Size; /*!< Unit size, including delimiter. */
mfxU32 reserved[5];
} mfxEncodedUnitInfo;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
/*!
If mfxExtCodingOption3::EncodedUnitsInfo was set to MFX_CODINGOPTION_ON during encoder initialization, the mfxExtEncodedUnitsInfo structure is
attached to the mfxBitstream structure during encoding. It is used to report information about coding units in the resulting bitstream.
The number of filled items in UnitInfo is min(NumUnitsEncoded, NumUnitsAlloc).
For counting a minimal amount of encoded units you can use the following algorithm:
@code
nSEI = amountOfApplicationDefinedSEI;
if (CodingOption3.NumSlice[IPB] != 0 || mfxVideoParam.mfx.NumSlice != 0)
ExpectedAmount = 10 + nSEI + Max(CodingOption3.NumSlice[IPB], mfxVideoParam.mfx.NumSlice);
else if (CodingOption2.NumMBPerSlice != 0)
ExpectedAmount = 10 + nSEI + (FrameWidth * FrameHeight) / (256 * CodingOption2.NumMBPerSlice);
else if (CodingOption2.MaxSliceSize != 0)
ExpectedAmount = 10 + nSEI + Round(MaxBitrate / (FrameRate*CodingOption2.MaxSliceSize));
else
ExpectedAmount = 10 + nSEI;
if (mfxFrameInfo.PictStruct != MFX_PICSTRUCT_PROGRESSIVE)
ExpectedAmount = ExpectedAmount * 2;
if (temporalScaleabilityEnabled)
ExpectedAmount = ExpectedAmount * 2;
@endcode
@note Only supported by the AVC encoder.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_ENCODED_UNITS_INFO. */
union {
mfxEncodedUnitInfo *UnitInfo; /*!< Pointer to an array of mfxEncodedUnitsInfo structures whose size is equal to or greater than NumUnitsAlloc. */
mfxU64 reserved1;
};
mfxU16 NumUnitsAlloc; /*!< UnitInfo array size. */
mfxU16 NumUnitsEncoded; /*!< Output field. Number of coding units to report. If NumUnitsEncoded is greater than NumUnitsAlloc, the UnitInfo
array will contain information only for the first NumUnitsAlloc units. User may consider reallocating the
UnitInfo array to avoid this for subsequent frames. */
mfxU16 reserved[22];
} mfxExtEncodedUnitsInfo;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Provides setup for the Motion-Compensated Temporal Filter (MCTF) during the VPP initialization and for control
parameters at runtime. By default, MCTF is off. An application may enable it by adding MFX_EXTBUFF_VPP_MCTF to the mfxExtVPPDoUse buffer or by
attaching mfxExtVppMctf to the mfxVideoParam structure during initialization or reset.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_MCTF. */
mfxU16 FilterStrength; /*!< Value in range of 0 to 20 (inclusive) to indicate the filter strength of MCTF.
The strength of the MCTF process controls the degree of possible change of pixel values eligible for MCTF - the greater the strength value, the larger the change. It is a dimensionless quantity - values in the range of 1 to 20 inclusively imply strength; value 0 stands for AUTO mode and is
valid during initialization or reset only
If an invalid value is given, it is fixed to the default value of 0.
If the field value is in the range of 1 to 20 inclusive, MCTF operates in fixed-strength mode with the given strength of MCTF process.
At runtime, values of 0 and greater than 20 are ignored. */
mfxU16 reserved[27];
} mfxExtVppMctf;
MFX_PACK_END()
/*! Describes type of workload passed to MFXQueryAdapters. */
typedef enum
{
MFX_COMPONENT_ENCODE = 1, /*!< Encode workload. */
MFX_COMPONENT_DECODE = 2, /*!< Decode workload. */
MFX_COMPONENT_VPP = 3 /*!< VPP workload. */
} mfxComponentType;
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
Contains workload description, which is accepted by MFXQueryAdapters function.
*/
typedef struct
{
mfxComponentType Type; /*!< Type of workload: Encode, Decode, VPP. See mfxComponentType enumerator for values. */
mfxVideoParam Requirements; /*!< Detailed description of workload. See mfxVideoParam for details. */
mfxU16 reserved[4];
} mfxComponentInfo;
MFX_PACK_END()
/* Adapter description */
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Contains a description of the graphics adapter for the Legacy mode.
*/
typedef struct
{
mfxPlatform Platform; /*!< Platform type description. See mfxPlatform for details. */
mfxU32 Number; /*!< Value which uniquely characterizes media adapter. On Windows* this number can be used for initialization through
DXVA interface (see <a href="https://docs.microsoft.com/en-us/windows/win32/api/dxgi/nf-dxgi-idxgifactory1-enumadapters1">example</a>). */
mfxU16 reserved[14];
} mfxAdapterInfo;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
Contains description of all graphics adapters available on the current system.
*/
typedef struct
{
mfxAdapterInfo * Adapters; /*!< Pointer to array of mfxAdapterInfo structs allocated by user. */
mfxU32 NumAlloc; /*!< Length of Adapters array. */
mfxU32 NumActual; /*!< Number of Adapters entries filled by MFXQueryAdapters. */
mfxU16 reserved[4];
} mfxAdaptersInfo;
MFX_PACK_END()
/*! The PartialBitstreamOutput enumerator indicates flags of partial bitstream output type. */
enum {
MFX_PARTIAL_BITSTREAM_NONE = 0, /*!< Do not use partial output */
MFX_PARTIAL_BITSTREAM_SLICE = 1, /*!< Partial bitstream output will be aligned to slice granularity */
MFX_PARTIAL_BITSTREAM_BLOCK = 2, /*!< Partial bitstream output will be aligned to user-defined block size granularity */
MFX_PARTIAL_BITSTREAM_ANY = 3 /*!< Partial bitstream output will be return any coded data available at the end of SyncOperation timeout */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Used by an encoder to output parts of the bitstream as soon as they are ready. The application can attach this extended buffer to the
mfxVideoParam structure at initialization. If this option is turned ON (Granularity != MFX_PARTIAL_BITSTREAM_NONE), then the encoder can output
bitstream by part based on the required granularity.
This parameter is valid only during initialization and reset. Absence of this buffer means default or previously configured bitstream output
behavior.
@note Not all codecs and implementations support this feature. Use the Query API function to check if this feature is supported.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_PARTIAL_BITSTREAM_PARAM. */
mfxU32 BlockSize; /*!< Output block granularity for PartialBitstreamGranularity. Valid only for MFX_PARTIAL_BITSTREAM_BLOCK. */
mfxU16 Granularity; /*!< Granularity of the partial bitstream: slice/block/any, all types of granularity state in PartialBitstreamOutput enum. */
mfxU16 reserved[8];
} mfxExtPartialBitstreamParam;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
The mfxExtDeviceAffinityMask structure is used by the application to specify
affinity mask for the device with given device ID. See mfxDeviceDescription
for the device ID definition and sub device indexes. If the implementation
manages CPU threads for some purpose, the user can set the CPU thread affinity
mask by using this structure with DeviceID set to "CPU".
*/
typedef struct {
/*! Extension buffer header. Header.BufferId must be equal to
MFX_EXTBUFF_DEVICE_AFFINITY_MASK. */
mfxExtBuffer Header;
/*! Null terminated string with device ID. In case of CPU affinity mask
it must be equal to "CPU". */
mfxChar DeviceID[MFX_STRFIELD_LEN];
/*! Number of sub devices or threads in case of CPU in the mask. */
mfxU32 NumSubDevices;
/*! Mask array. Every bit represents sub-device (or thread for CPU).
"1" means execution is allowed. "0" means that execution is prohibited on
this sub-device (or thread). Length of the array is equal to the:
"NumSubDevices / 8" and rounded to the closest (from the right) integer.
Bits order within each entry of the mask array is LSB: bit 0 holds data
for sub device with index 0 and bit 8 for sub device with index 8.
Index of sub device is defined by the mfxDeviceDescription structure. */
mfxU8 *Mask;
mfxU32 reserved[4]; /*! Reserved for future use. */
} mfxExtDeviceAffinityMask;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! The structure is used by AV1 encoder with more parameter control to encode frame. */
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_AV1_BITSTREAM_PARAM. */
mfxU16 WriteIVFHeaders; /*!< Tri-state option to control IVF headers insertion, default is ON.
Writing IVF headers is enabled in the encoder when mfxExtAV1BitstreamParam is attached and its value is ON or zero.
Writing IVF headers is disabled by default in the encoder when mfxExtAV1BitstreamParam is not attached. */
mfxU16 reserved[31];
} mfxExtAV1BitstreamParam;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! The structure is used by AV1 encoder with more parameter control to encode frame. */
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_AV1_RESOLUTION_PARAM. */
mfxU32 FrameWidth; /*!< Width of the coded frame in pixels, default value is from mfxFrameInfo. */
mfxU32 FrameHeight; /*!< Height of the coded frame in pixels, default value is from mfxFrameInfo. */
mfxU32 reserved[6];
} mfxExtAV1ResolutionParam;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! The structure is used by AV1 encoder with more parameter control to encode frame. */
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_AV1_TILE_PARAM. */
mfxU16 NumTileRows; /*!< Number of tile rows, default value is 1. */
mfxU16 NumTileColumns; /*!< Number of tile columns, default value is 1. */
mfxU16 NumTileGroups; /*!< Number of tile groups, it will be ignored if the tile groups num is invalid, default value is 1. */
mfxU16 reserved[5];
} mfxExtAV1TileParam;
MFX_PACK_END()
/*!
The AV1 SegmentIdBlockSize enumerator indicates the block size represented by each segment_id in segmentation map.
These values are used with the mfxExtAV1Segmentation::SegmentIdBlockSize parameter.
*/
typedef enum {
MFX_AV1_SEGMENT_ID_BLOCK_SIZE_UNSPECIFIED = 0, /*!< Unspecified block size. */
MFX_AV1_SEGMENT_ID_BLOCK_SIZE_4x4 = 4, /*!< block size 4x4 */
MFX_AV1_SEGMENT_ID_BLOCK_SIZE_8x8 = 8, /*!< block size 8x8 */
MFX_AV1_SEGMENT_ID_BLOCK_SIZE_16x16 = 16, /*!< block size 16x16 */
MFX_AV1_SEGMENT_ID_BLOCK_SIZE_32x32 = 32, /*!< block size 32x32 */
MFX_AV1_SEGMENT_ID_BLOCK_SIZE_64x64 = 64, /*!< block size 64x64 */
MFX_AV1_SEGMENT_ID_BLOCK_SIZE_128x128 = 128 /*!< block size 128x128 */
} mfxAV1SegmentIdBlockSize;
/*!
The AV1 SegmentFeature enumerator indicates features enabled for the segment.
These values are used with the mfxAV1SegmentParam::FeatureEnabled parameter.
*/
enum {
MFX_AV1_SEGMENT_FEATURE_ALT_QINDEX = 0x0001, /*!< use alternate Quantizer. */
MFX_AV1_SEGMENT_FEATURE_ALT_LF_Y_VERT = 0x0002, /*!< use alternate loop filter value on y plane vertical. */
MFX_AV1_SEGMENT_FEATURE_ALT_LF_Y_HORZ = 0x0004, /*!< use alternate loop filter value on y plane horizontal. */
MFX_AV1_SEGMENT_FEATURE_ALT_LF_U = 0x0008, /*!< use alternate loop filter value on u plane. */
MFX_AV1_SEGMENT_FEATURE_ALT_LF_V = 0x0010, /*!< use alternate loop filter value on v plane. */
MFX_AV1_SEGMENT_FEATURE_REFERENCE = 0x0020, /*!< use segment reference frame. */
MFX_AV1_SEGMENT_FEATURE_SKIP = 0x0040, /*!< use segment (0,0) + skip mode. */
MFX_AV1_SEGMENT_FEATURE_GLOBALMV = 0x0080 /*!< use global motion vector. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*!
Contains features and parameters for the segment.
*/
typedef struct {
mfxU16 FeatureEnabled; /*!< Indicates which features are enabled for the segment. See the AV1 SegmentFeature enumerator for values for
this option. Values from the enumerator can be bit-OR'ed. Support of a particular feature depends on underlying
hardware platform. Application can check which features are supported by calling Query. */
mfxI16 AltQIndex; /*!< Quantization index delta for the segment. Ignored if MFX_AV1_SEGMENT_FEATURE_ALT_QINDEX isn't set in FeatureEnabled.
Valid range for this parameter is [-255, 255]. If AltQIndex is out of this range, it will be ignored. If AltQIndex
is within valid range, but sum of base quantization index and AltQIndex is out of [0, 255], AltQIndex will be clamped. */
mfxU16 reserved[30];
} mfxAV1SegmentParam;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*!
In the AV1 encoder it is possible to divide a frame into up to 8 segments and apply particular features (like delta for quantization index or for
loop filter level) on a per-segment basis. "Uncompressed header" of every frame indicates if segmentation is enabled for the current frame,
and (if segmentation enabled) contains full information about features applied to every segment. Every "Mode info block" of a coded
frame has segment_id in the range of 0 to 7.
To enable Segmentation, the mfxExtAV1Segmentation structure with correct settings should be passed to the encoder. It can be attached to the
mfxVideoParam structure during initialization or the MFXVideoENCODE_Reset call (static configuration). If the mfxExtAV1Segmentation buffer isn't
attached during initialization, segmentation is disabled for static configuration. If the buffer isn't attached for the Reset call, the encoder
continues to use static configuration for segmentation which was the default before this Reset call. If the mfxExtAV1Segmentation buffer with
NumSegments=0 is provided during initialization or Reset call, segmentation becomes disabled for static configuration.
The buffer can be attached to the mfxEncodeCtrl structure during runtime (dynamic configuration). Dynamic configuration is applied to the
current frame only. After encoding of the current frame, the encoder will switch to the next dynamic configuration or to static configuration if
dynamic configuration is not provided for next frame).
The SegmentIdBlockSize, NumSegmentIdAlloc, and SegmentId parameters represent a segmentation map. Here, the segmentation map is an array of
segment_ids (one byte per segment_id) for blocks of size NxN in raster scan order. The size NxN is specified by the application and is constant
for the whole frame.
If mfxExtAV1Segmentation is attached during initialization and/or during runtime, all three parameters should be set to proper values that do not
conflict with each other and with NumSegments. If any of the parameters are not set or any conflict or error in these parameters is detected by
the library, the segmentation map will be discarded.
*/
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_AV1_SEGMENTATION. */
mfxU8 NumSegments; /*!< Number of segments for frame. Value 0 means that segmentation is disabled. Sending 0 for a
particular frame will disable segmentation for this frame only. Sending 0 to the Reset API function will
disable segmentation permanently. Segmentation can be enabled again by a subsequent Reset call. */
mfxU8 reserved1[3];
mfxAV1SegmentParam Segment[8]; /*!< Array of mfxAV1SegmentParam structures containing features and parameters for every segment.
Entries with indexes bigger than NumSegments-1 are ignored. See the mfxAV1SegmentParam structure for
definitions of segment features and their parameters. */
mfxU16 SegmentIdBlockSize;/*!< Size of block (NxN) for segmentation map. See AV1 SegmentIdBlockSize enumerator for values for this
option. An encoded block that is bigger than AV1 SegmentIdBlockSize uses segment_id taken from it's
top-left sub-block from the segmentation map. The application can check if a particular block size is
supported by calling Query. */
mfxU16 reserved2;
mfxU32 NumSegmentIdAlloc; /*!< Size of buffer allocated for segmentation map (in bytes). Application must assure that
NumSegmentIdAlloc is large enough to cover frame resolution with blocks of size SegmentIdBlockSize.
Otherwise the segmentation map will be discarded. */
mfxU8 * SegmentIds; /*!< Pointer to the segmentation map buffer which holds the array of segment_ids in raster scan order. The application
is responsible for allocation and release of this memory. The buffer pointed to by SegmentId, provided during
initialization or Reset call should be considered in use until another SegmentId is provided via Reset
call (if any), or until MFXVideoENCODE_Close is called. The buffer pointed to by SegmentId provided with
mfxEncodeCtrl should be considered in use while the input surface is locked by the library. Every segment_id in the
map should be in the range of 0 to NumSegments-1. If some segment_id is out of valid range, the
segmentation map cannot be applied. If the mfxExtAV1Segmentation buffer is attached to the mfxEncodeCtrl structure in
runtime, SegmentId can be zero. In this case, the segmentation map from static configuration will be used. */
mfxU16 reserved[36];
} mfxExtAV1Segmentation;
MFX_PACK_END()
/*! The FilmGrainFlags enumerator itemizes flags in AV1 film grain parameters.
The flags are equivalent to respective syntax elements from film_grain_params() section of uncompressed header. */
enum {
MFX_FILM_GRAIN_NO = 0, /*!< Film grain isn't added to this frame. */
MFX_FILM_GRAIN_APPLY = (1 << 0), /*!< Film grain is added to this frame. */
MFX_FILM_GRAIN_UPDATE = (1 << 1), /*!< New set of film grain parameters is sent for this frame. */
MFX_FILM_GRAIN_CHROMA_SCALING_FROM_LUMA = (1 << 2), /*!< Chroma scaling is inferred from luma scaling. */
MFX_FILM_GRAIN_OVERLAP = (1 << 3), /*!< Overlap between film grain blocks is applied. */
MFX_FILM_GRAIN_CLIP_TO_RESTRICTED_RANGE = (1 << 4) /*!< Clipping to the restricted (studio) range is applied after adding the film grain. */
};
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! Defines film grain point. */
typedef struct {
mfxU8 Value; /*!< The x coordinate for the i-th point of the piece-wise linear scaling function for luma/Cb/Cr component. */
mfxU8 Scaling; /*!< The scaling (output) value for the i-th point of the piecewise linear scaling function for luma/Cb/Cr component. */
} mfxAV1FilmGrainPoint;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! The structure is used by AV-1 decoder to report film grain parameters for decoded frame. */
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_AV1_FILM_GRAIN_PARAM. */
mfxU16 FilmGrainFlags; /*!< Bit map with bit-ORed flags from FilmGrainFlags enum. */
mfxU16 GrainSeed; /*!< Starting value for pseudo-random numbers used during film grain synthesis. */
mfxU8 RefIdx; /*!< Indicate which reference frame contains the film grain parameters to be used for this frame. */
mfxU8 NumYPoints; /*!< The number of points for the piece-wise linear scaling function of the luma component. */
mfxU8 NumCbPoints; /*!< The number of points for the piece-wise linear scaling function of the Cb component. */
mfxU8 NumCrPoints; /*!< The number of points for the piece-wise linear scaling function of the Cr component.*/
mfxAV1FilmGrainPoint PointY[14]; /*!< The array of points for luma component. */
mfxAV1FilmGrainPoint PointCb[10]; /*!< The array of points for Cb component. */
mfxAV1FilmGrainPoint PointCr[10]; /*!< The array of points for Cr component. */
mfxU8 GrainScalingMinus8; /*!< The shift - 8 applied to the values of the chroma component. The grain_scaling_minus_8 can take values of 0..3 and
determines the range and quantization step of the standard deviation of film grain.*/
mfxU8 ArCoeffLag; /*!< The number of auto-regressive coefficients for luma and chroma.*/
mfxU8 ArCoeffsYPlus128[24]; /*!< Auto-regressive coefficients used for the Y plane. */
mfxU8 ArCoeffsCbPlus128[25]; /*!< Auto-regressive coefficients used for the Cb plane. */
mfxU8 ArCoeffsCrPlus128[25]; /*!< The number of points for the piece-wise linear scaling function of the Cr component.*/
mfxU8 ArCoeffShiftMinus6; /*!< The range of the auto-regressive coefficients.
Values of 0, 1, 2, and 3 correspond to the ranges for auto-regressive coefficients of
[-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, 0.25) respectively.*/
mfxU8 GrainScaleShift; /*!< Downscaling factor of the grain synthesis process for the Gaussian random numbers .*/
mfxU8 CbMult; /*!< The multiplier for the Cb component used in derivation of the input index to the Cb component scaling function.*/
mfxU8 CbLumaMult; /*!< The multiplier for the average luma component used in derivation of the input index to the Cb component scaling function. */
mfxU16 CbOffset; /*!< The offset used in derivation of the input index to the Cb component scaling function.*/
mfxU8 CrMult; /*!< The multiplier for the Cr component used in derivation of the input index to the Cr component scaling function.*/
mfxU8 CrLumaMult; /*!< The multiplier for the average luma component used in derivation of the input index to the Cr component scaling function.*/
mfxU16 CrOffset; /*!< The offset used in derivation of the input index to the Cr component scaling function.*/
mfxU16 reserved[43];
} mfxExtAV1FilmGrainParam;
MFX_PACK_END()
#define MFX_SURFACEARRAY_VERSION MFX_STRUCT_VERSION(1, 0)
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*! The structure is reference counted object to return array of surfaces allocated and processed by the library. */
typedef struct mfxSurfaceArray
{
mfxHDL Context; /*!< The context of the memory interface. User should not touch (change, set, null) this pointer. */
mfxStructVersion Version; /*!< The version of the structure. */
mfxU16 reserved[3];
/*! @brief
Increments the internal reference counter of the surface. The surface is not destroyed until the surface is released using the mfxSurfaceArray::Release function.
mfxSurfaceArray::AddRef should be used each time a new link to the surface is created (for example, copy structure) for proper surface management.
@param[in] surface Valid mfxSurfaceArray.
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If surface is NULL. \n
MFX_ERR_INVALID_HANDLE If mfxSurfaceArray->Context is invalid (for example NULL). \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *AddRef)(struct mfxSurfaceArray* surface_array);
/*! @brief
Decrements the internal reference counter of the surface. mfxSurfaceArray::Release should be called after
using the mfxSurfaceArray::AddRef function to add a surface or when allocation logic requires it.
@param[in] surface_array Valid mfxSurfaceArray.
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If surface is NULL. \n
MFX_ERR_INVALID_HANDLE If mfxSurfaceArray->Context is invalid (for example NULL). \n
MFX_ERR_UNDEFINED_BEHAVIOR If Reference Counter of surface is zero before call. \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *Release)(struct mfxSurfaceArray* surface_array);
/*! @brief
Returns current reference counter of mfxSurfaceArray structure.
@param[in] surface Valid surface_array.
@param[out] counter Sets counter to the current reference counter value.
@return
MFX_ERR_NONE If no error. \n
MFX_ERR_NULL_PTR If surface or counter is NULL. \n
MFX_ERR_INVALID_HANDLE If mfxSurfaceArray->Context is invalid (for example NULL). \n
MFX_ERR_UNKNOWN Any internal error.
*/
mfxStatus (MFX_CDECL *GetRefCounter)(struct mfxSurfaceArray* surface_array, mfxU32* counter);
mfxFrameSurface1** Surfaces; /*!< The array of pointers to mfxFrameSurface1. mfxFrameSurface1 surfaces are allocated by the same
agent who allocates mfxSurfaceArray. */
mfxU32 NumSurfaces; /*!<The size of array of pointers to mfxFrameSurface1. */
mfxU32 reserved1;
} mfxSurfaceArray;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*! The structure is used for VPP channels initialization in Decode_VPP component. */
typedef struct {
mfxFrameInfo VPP; /*!< The configuration parameters of VPP filters per each channel. */
mfxU16 Protected; /*!< Specifies the content protection mechanism. */
mfxU16 IOPattern; /*!< Output memory access types for SDK functions. */
mfxExtBuffer** ExtParam; /*!< Points to an array of pointers to the extra configuration structures; see the ExtendedBufferID enumerator for a list of extended configurations. */
mfxU16 NumExtParam; /*!< The number of extra configuration structures attached to the structure. */
mfxU16 reserved1[7];
} mfxVideoChannelParam;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! The structure describes rectangle coordinates that can be used for ROI or for Cropping. */
typedef struct {
mfxU16 Left; /*!< X coordinate of region of top-left corner of rectangle. */
mfxU16 Top; /*!< Y coordinate of region of top-left corner of rectangle. */
mfxU16 Right; /*!< X coordinate of region of bottom-right corner of rectangle. */
mfxU16 Bottom; /*!< Y coordinate of region of bottom-right corner of rectangle. */
} mfxRect;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! The structure contains crop parameters which applied by Decode_VPP component to input surfaces before video processing operation.
It is used for letterboxing operations.
*/
typedef struct {
mfxExtBuffer Header; /*! Extension buffer header. BufferId must be equal to MFX_EXTBUFF_CROPS. */
mfxRect Crops; /*!< Crops parameters for letterboxing operations. */
mfxU32 reserved[4];
}mfxExtInCrops;
MFX_PACK_END()
/*! The mfxHyperMode enumerator describes HyperMode implementation behavior. */
typedef enum {
MFX_HYPERMODE_OFF = 0x0, /*!< Don't use HyperMode implementation. */
MFX_HYPERMODE_ON = 0x1, /*!< Enable HyperMode implementation and return error if some issue on initialization. */
MFX_HYPERMODE_ADAPTIVE = 0x2, /*!< Enable HyperMode implementation and switch to single fallback if some issue on initialization. */
} mfxHyperMode;
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! The structure is used for HyperMode initialization. */
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. BufferId must be equal to MFX_EXTBUFF_HYPER_MODE_PARAM. */
mfxHyperMode Mode; /*!< HyperMode implementation behavior. */
mfxU16 reserved[19];
} mfxExtHyperModeParam;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! The structure is used for universal temporal layer description. */
typedef struct {
mfxU16 FrameRateScale; /*!< The ratio between the frame rates of the current temporal layer and the base layer. The library treats a particular
temporal layer as "defined" if it has FrameRateScale > 0. If the base layer is defined, it must have FrameRateScale = 1.
FrameRateScale of each subsequent layer (if defined) must be a multiple of and greater than the
FrameRateScale value of previous layer. */
mfxU16 reserved[3]; /*!< Reserved for future use. */
union {
/*!< Type of bitrate controls is currently the same across all temporal layers and inherits from common parameters. */
struct {
mfxU32 InitialDelayInKB;/*!< Initial size of the Video Buffering Verifier (VBV) buffer for the current temporal layer.
@note In this context, KB is 1000 bytes and Kbps is 1000 bps. */
mfxU32 BufferSizeInKB; /*!< Represents the maximum possible size of any compressed frames for the current temporal layer. */
mfxU32 TargetKbps; /*!< Target bitrate for the current temporal layer. If RateControlMethod is not CQP, the
application can provide TargetKbps for every defined temporal layer. If TargetKbps per temporal layer is not set then
encoder doesn't apply any special bitrate limitations for the layer. */
mfxU32 MaxKbps; /*!< The maximum bitrate at which the encoded data enters the Video Buffering Verifier (VBV) buffer for the current temporal layer. */
mfxU32 reserved1[16]; /*!< Reserved for future use. */
};
struct {
mfxI32 QPI; /*!< Quantization Parameter (QP) for I-frames for constant QP mode (CQP) for the current temporal layer. Zero QP is not valid and means that the default value is assigned by the library.
Non-zero QPI might be clipped to supported QPI range.
@note Default QPI value is implementation dependent and subject to change without additional notice in this document. */
mfxI32 QPP; /*!< Quantization Parameter (QP) for P-frames for constant QP mode (CQP) for the current temporal layer. Zero QP is not valid and means that the default value is assigned by the library.
Non-zero QPP might be clipped to supported QPI range.
@note Default QPP value is implementation dependent and subject to change without additional notice in this document. */
mfxI32 QPB; /*!< Quantization Parameter (QP) for B-frames for constant QP mode (CQP) for the current temporal layer. Zero QP is not valid and means that the default value is assigned by the library.
Non-zero QPI might be clipped to supported QPB range.
@note Default QPB value is implementation dependent and subject to change without additional notice in this document. */
};
};
mfxU16 reserved2[4]; /*!< Reserved for future use. */
} mfxTemporalLayer;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*! The structure is used for universal temporal layers description. */
typedef struct {
mfxExtBuffer Header; /*! Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_UNIVERSAL_TEMPORAL_LAYERS. */
mfxU16 NumLayers; /*!< The number of temporal layers. */
mfxU16 BaseLayerPID; /*!< The priority ID of the base layer. The encoder increases the ID for each temporal layer and writes to the prefix NAL unit for AVC and HEVC. */
mfxU16 reserved[2]; /*!< Reserved for future use. */
mfxTemporalLayer *Layers; /*!< The array of temporal layers. */
mfxU16 reserved1[8]; /*!< Reserved for future use. */
} mfxExtTemporalLayers;
MFX_PACK_END()
#ifdef ONEVPL_EXPERIMENTAL
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*! The structure is used to get a synchronization object which signalizes about submission of a task to GPU. */
typedef struct {
mfxExtBuffer Header; /*! Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_SYNCSUBMISSION. */
mfxSyncPoint *SubmissionSyncPoint; /*!< SyncPoint object to get a moment of a submission task to GPU. */
mfxU32 reserved1[8]; /*!< Reserved for future use. */
} mfxExtSyncSubmission;
MFX_PACK_END()
#endif
#ifdef ONEVPL_EXPERIMENTAL
MFX_PACK_BEGIN_USUAL_STRUCT()
/*! The structure is used to configure perceptual encoding prefilter in VPP. */
typedef struct {
mfxExtBuffer Header; /*! Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_VPP_PERC_ENC_PREFILTER. */
mfxU16 reserved[252];
} mfxExtVPPPercEncPrefilter;
MFX_PACK_END()
#endif
#ifdef ONEVPL_EXPERIMENTAL
/*! The TuneQuality enumerator specifies tuning option for encode. Multiple tuning options can be combined using bit mask. */
enum {
MFX_ENCODE_TUNE_DEFAULT = 0, /*!< The balanced option to keep quality balanced across all metrics. */
MFX_ENCODE_TUNE_PSNR = 0x1, /*!< The encoder optimizes quality according to Peak Signal-to-Noise Ratio (PSNR) metric. */
MFX_ENCODE_TUNE_SSIM = 0x2, /*!< The encoder optimizes quality according to Structural Similarity Index Measure (SSIM) metric. */
MFX_ENCODE_TUNE_MS_SSIM = 0x4, /*!< The encoder optimizes quality according to Multi-Scale Structural Similarity Index Measure (MS-SSIM) metric. */
MFX_ENCODE_TUNE_VMAF = 0x8, /*!< The encoder optimizes quality according to Video Multi-Method Assessment Fusion (VMAF) metric. */
MFX_ENCODE_TUNE_PERCEPTUAL = 0x10, /*!< The encoder makes perceptual quality optimization. */
};
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*! The structure specifies type of quality optimization used by the encoder. The buffer can also be attached for VPP functions to make correspondent pre-filtering. */
typedef struct {
mfxExtBuffer Header; /*!< Extension buffer header. Header.BufferId must be equal to MFX_EXTBUFF_TUNE_ENCODE_QUALITY. */
mfxU32 TuneQuality; /*!< The control to specify type of encode quality metric(s) to optimize; See correspondent enum. */
mfxExtBuffer** ExtParam; /*!< Points to an array of pointers to the extra configuration structures; see the ExtendedBufferID enumerator for a list of extended configurations. */
mfxU16 NumExtParam; /*!< The number of extra configuration structures attached to the structure. */
mfxU16 reserved[11];
} mfxExtTuneEncodeQuality;
MFX_PACK_END()
#endif
#ifdef ONEVPL_EXPERIMENTAL
/* The mfxAutoSelectImplType enumerator specifies the method for automatically selecting an implementation. */
typedef enum {
MFX_AUTO_SELECT_IMPL_TYPE_UNKNOWN = 0, /*!< Unspecified automatic implementation selection. */
MFX_AUTO_SELECT_IMPL_TYPE_DEVICE_HANDLE = 1, /*!< Select implementation corresponding to device handle. */
} mfxAutoSelectImplType;
MFX_PACK_BEGIN_STRUCT_W_PTR()
/*! Specifies that an implementation should be selected which matches the device handle provided by the application. */
typedef struct {
mfxAutoSelectImplType AutoSelectImplType; /*!< Must be set to MFX_AUTO_SELECT_IMPL_TYPE_DEVICE_HANDLE. */
mfxAccelerationMode AccelMode; /*!< Hardware acceleration mode of provided device handle. */
mfxHandleType DeviceHandleType; /*!< Type of provided device handle. */
mfxHDL DeviceHandle; /*!< System handle to hardware device. */
mfxU16 reserved[8]; /*!< Reserved for future use. */
} mfxAutoSelectImplDeviceHandle;
MFX_PACK_END()
#endif
#ifdef __cplusplus
} // extern "C"
#endif
#endif
Reference in a new issue View git blame Copy permalink