mirror of
https://github.com/ultravideo/uvg266.git
synced 2024-12-04 21:54:05 +00:00
866 lines
26 KiB
C
866 lines
26 KiB
C
#ifndef UVG266_H_
|
|
#define UVG266_H_
|
|
/*****************************************************************************
|
|
* This file is part of uvg266 VVC encoder.
|
|
*
|
|
* Copyright (c) 2021, Tampere University, ITU/ISO/IEC, project contributors
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
*
|
|
* * Redistributions in binary form must reproduce the above copyright notice, this
|
|
* list of conditions and the following disclaimer in the documentation and/or
|
|
* other materials provided with the distribution.
|
|
*
|
|
* * Neither the name of the Tampere University or ITU/ISO/IEC nor the names of its
|
|
* contributors may be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
* INCLUDING NEGLIGENCE OR OTHERWISE ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
****************************************************************************/
|
|
|
|
/**
|
|
* \ingroup Control
|
|
* \file
|
|
* This file defines the public API of uvg266 when used as a library.
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#if defined(UVG_DLL_EXPORTS)
|
|
#if !defined(PIC)
|
|
// Building static uvg266 library.
|
|
#define UVG_PUBLIC
|
|
#elif defined(_WIN32) || defined(__CYGWIN__)
|
|
// Building uvg266 DLL on Windows.
|
|
#define UVG_PUBLIC __declspec(dllexport)
|
|
#elif defined(__GNUC__)
|
|
// Building uvg266 shared library with GCC.
|
|
#define UVG_PUBLIC __attribute__ ((visibility ("default")))
|
|
#else
|
|
#define UVG_PUBLIC
|
|
#endif
|
|
#else
|
|
#if defined(UVG_STATIC_LIB)
|
|
// Using static uvg266 library.
|
|
#define UVG_PUBLIC
|
|
#elif defined(_WIN32) || defined(__CYGWIN__)
|
|
// Using uvg266 DLL on Windows.
|
|
#define UVG_PUBLIC __declspec(dllimport)
|
|
#else
|
|
// Using uvg266 shared library and not on Windows.
|
|
#define UVG_PUBLIC
|
|
#endif
|
|
#endif
|
|
|
|
/**
|
|
* Maximum length of a GoP structure.
|
|
*/
|
|
#define UVG_MAX_GOP_LENGTH 32
|
|
|
|
/**
|
|
* Maximum amount of GoP layers.
|
|
*/
|
|
#define UVG_MAX_GOP_LAYERS 6
|
|
|
|
/**
|
|
* Size of data chunks.
|
|
*/
|
|
#define UVG_DATA_CHUNK_SIZE 4096
|
|
|
|
#ifndef UVG_BIT_DEPTH
|
|
#define UVG_BIT_DEPTH 8
|
|
#endif
|
|
|
|
#if UVG_BIT_DEPTH == 8
|
|
typedef uint8_t uvg_pixel;
|
|
#else
|
|
typedef uint16_t uvg_pixel;
|
|
#endif
|
|
|
|
typedef int16_t uvg_pixel_im; // For intermediate precision (interpolation/bipred).
|
|
|
|
/**
|
|
* \brief Opaque data structure representing one instance of the encoder.
|
|
*/
|
|
typedef struct uvg_encoder uvg_encoder;
|
|
|
|
/**
|
|
* \brief Integer motion estimation algorithms.
|
|
*/
|
|
enum uvg_ime_algorithm {
|
|
UVG_IME_HEXBS = 0,
|
|
UVG_IME_TZ = 1,
|
|
UVG_IME_FULL = 2,
|
|
UVG_IME_FULL8 = 3, //! \since 3.6.0
|
|
UVG_IME_FULL16 = 4, //! \since 3.6.0
|
|
UVG_IME_FULL32 = 5, //! \since 3.6.0
|
|
UVG_IME_FULL64 = 6, //! \since 3.6.0
|
|
UVG_IME_DIA = 7, // Experimental. TODO: change into a proper doc comment
|
|
};
|
|
|
|
/**
|
|
* \brief Interlacing methods.
|
|
* \since 3.2.0
|
|
*/
|
|
enum uvg_interlacing
|
|
{
|
|
UVG_INTERLACING_NONE = 0,
|
|
UVG_INTERLACING_TFF = 1, // top field first
|
|
UVG_INTERLACING_BFF = 2, // bottom field first
|
|
};
|
|
|
|
/**
|
|
* \brief Constrain movement vectors.
|
|
* \since 3.3.0
|
|
*/
|
|
enum uvg_mv_constraint
|
|
{
|
|
UVG_MV_CONSTRAIN_NONE = 0,
|
|
UVG_MV_CONSTRAIN_FRAME = 1, // Don't refer outside the frame.
|
|
UVG_MV_CONSTRAIN_TILE = 2, // Don't refer to other tiles.
|
|
UVG_MV_CONSTRAIN_FRAME_AND_TILE = 3, // Don't refer outside the tile.
|
|
UVG_MV_CONSTRAIN_FRAME_AND_TILE_MARGIN = 4, // Keep enough margin for fractional pixel margins not to refer outside the tile.
|
|
};
|
|
|
|
/**
|
|
* \brief Constrain movement vectors.
|
|
* \since 3.5.0
|
|
*/
|
|
enum uvg_hash
|
|
{
|
|
UVG_HASH_NONE = 0,
|
|
UVG_HASH_CHECKSUM = 1,
|
|
UVG_HASH_MD5 = 2,
|
|
};
|
|
|
|
/**
|
|
* \brief cu split termination mode
|
|
* \since since 3.8.0
|
|
*/
|
|
enum uvg_cu_split_termination
|
|
{
|
|
UVG_CU_SPLIT_TERMINATION_ZERO = 0,
|
|
UVG_CU_SPLIT_TERMINATION_OFF = 1
|
|
};
|
|
|
|
/**
|
|
* \brief me early termination mode
|
|
* \since since 3.8.0
|
|
*/
|
|
enum uvg_me_early_termination
|
|
{
|
|
UVG_ME_EARLY_TERMINATION_OFF = 0,
|
|
UVG_ME_EARLY_TERMINATION_ON = 1,
|
|
UVG_ME_EARLY_TERMINATION_SENSITIVE = 2
|
|
};
|
|
|
|
|
|
/**
|
|
* \brief Format the pixels are read in.
|
|
* This is separate from chroma subsampling, because we might want to read
|
|
* interleaved formats in the future.
|
|
* \since 3.12.0
|
|
*/
|
|
enum uvg_input_format {
|
|
UVG_FORMAT_P400 = 0,
|
|
UVG_FORMAT_P420 = 1,
|
|
UVG_FORMAT_P422 = 2,
|
|
UVG_FORMAT_P444 = 3,
|
|
};
|
|
|
|
/**
|
|
* \brief Chroma subsampling format used for encoding.
|
|
* \since 3.12.0
|
|
*/
|
|
enum uvg_chroma_format {
|
|
UVG_CSP_400 = 0,
|
|
UVG_CSP_420 = 1,
|
|
UVG_CSP_422 = 2,
|
|
UVG_CSP_444 = 3,
|
|
};
|
|
|
|
/**
|
|
* \brief Chroma subsampling format used for encoding.
|
|
* \since 3.15.0
|
|
*/
|
|
enum uvg_slices {
|
|
UVG_SLICES_NONE,
|
|
UVG_SLICES_TILES = (1 << 0), /*!< \brief Put each tile in a slice. */
|
|
UVG_SLICES_WPP = (1 << 1), /*!< \brief Put each row in a slice. */
|
|
};
|
|
|
|
enum uvg_sao {
|
|
UVG_SAO_OFF = 0,
|
|
UVG_SAO_EDGE = 1,
|
|
UVG_SAO_BAND = 2,
|
|
UVG_SAO_FULL = 3
|
|
};
|
|
|
|
enum uvg_alf {
|
|
UVG_ALF_OFF = 0,
|
|
UVG_ALF_NO_CC_ALF = 1,
|
|
UVG_ALF_FULL = 2
|
|
};
|
|
|
|
enum uvg_mts {
|
|
UVG_MTS_OFF = 0,
|
|
UVG_MTS_INTRA = 1,
|
|
UVG_MTS_INTER = 2,
|
|
UVG_MTS_BOTH = 3,
|
|
UVG_MTS_IMPLICIT = 4,
|
|
};
|
|
|
|
|
|
//MTS transform tags
|
|
typedef enum tr_type_t {
|
|
DCT2 = 0,
|
|
DCT8 = 1,
|
|
DST7 = 2,
|
|
NUM_TRANS_TYPE = 3,
|
|
DCT2_MTS = 4
|
|
} tr_type_t;
|
|
|
|
enum uvg_scalinglist {
|
|
UVG_SCALING_LIST_OFF = 0,
|
|
UVG_SCALING_LIST_CUSTOM = 1,
|
|
UVG_SCALING_LIST_DEFAULT = 2,
|
|
};
|
|
|
|
enum uvg_rc_algorithm
|
|
{
|
|
UVG_NO_RC = 0,
|
|
UVG_LAMBDA = 1,
|
|
UVG_OBA = 2,
|
|
};
|
|
|
|
enum uvg_file_format
|
|
{
|
|
UVG_FORMAT_AUTO = 0,
|
|
UVG_FORMAT_Y4M = 1,
|
|
UVG_FORMAT_YUV = 2
|
|
};
|
|
|
|
enum uvg_amvr_resolution
|
|
{
|
|
UVG_IMV_OFF = 0,
|
|
UVG_IMV_FPEL = 1,
|
|
UVG_IMV_4PEL = 2,
|
|
UVG_IMV_HPEL = 3
|
|
};
|
|
|
|
enum uvg_roi_format
|
|
{
|
|
UVG_ROI_TXT = 0,
|
|
UVG_ROI_BIN = 1
|
|
};
|
|
|
|
// Map from input format to chroma format.
|
|
#define UVG_FORMAT2CSP(format) ((enum uvg_chroma_format)format)
|
|
|
|
/**
|
|
* \brief GoP picture configuration.
|
|
*/
|
|
typedef struct uvg_gop_config {
|
|
double qp_factor;
|
|
int8_t qp_offset; /*!< \brief QP offset */
|
|
int8_t poc_offset; /*!< \brief POC offset */
|
|
int8_t layer; /*!< \brief Current layer */
|
|
int8_t is_ref; /*!< \brief Flag if this picture is used as a reference */
|
|
int8_t ref_pos_count;/*!< \brief Reference picture count */
|
|
int8_t ref_pos[16]; /*!< \brief reference picture offset list */
|
|
int8_t ref_neg_count;/*!< \brief Reference picture count */
|
|
int8_t ref_neg[16]; /*!< \brief reference picture offset list */
|
|
double qp_model_offset;
|
|
double qp_model_scale;
|
|
} uvg_gop_config;
|
|
|
|
/**
|
|
* \brief Struct which contains all configuration data
|
|
*
|
|
* Functions config_alloc, config_init and config_destroy must be used to
|
|
* maintain ABI compatibility. Do not copy this struct, as the size might
|
|
* change.
|
|
*/
|
|
typedef struct uvg_config
|
|
{
|
|
int32_t qp; /*!< \brief Quantization parameter */
|
|
int32_t intra_period; /*!< \brief the period of intra frames in stream */
|
|
|
|
/** \brief How often the VPS, SPS and PPS are re-sent
|
|
*
|
|
* -1: never
|
|
* 0: first frame only
|
|
* 1: every intra frame
|
|
* 2: every other intra frame
|
|
* 3: every third intra frame
|
|
* and so on
|
|
*/
|
|
int32_t vps_period;
|
|
|
|
int32_t width; /*!< \brief frame width, must be a multiple of 8 */
|
|
int32_t height; /*!< \brief frame height, must be a multiple of 8 */
|
|
int32_t framerate_num; /*!< \brief Framerate numerator */
|
|
int32_t framerate_denom; /*!< \brief Framerate denominator */
|
|
int32_t lmcs_enable; /*!< \brief Flag to enable luma mapping with chroma scaling - filter */
|
|
int32_t deblock_enable; /*!< \brief Flag to enable deblocking filter */
|
|
enum uvg_sao sao_type; /*!< \brief Flag to enable sample adaptive offset filter */
|
|
enum uvg_alf alf_type; /*!< \brief Flag to enable adaptive loop filter */
|
|
int32_t alf_info_in_ph_flag; /*!< \brief Flag to enable if ALF is applied to all slices in picture */
|
|
int32_t alf_slice_enable_flag[3/*MAX_NUM_COMPONENT*/];
|
|
int32_t alf_non_linear_luma; /*!< \brief Flag to enable non linear alf for luma */
|
|
int32_t alf_non_linear_chroma; /*!< \brief Flag to enable non linear alf for chroma */
|
|
int32_t alf_allow_predefined_filters;
|
|
int32_t rdoq_enable; /*!< \brief Flag to enable RD optimized quantization. */
|
|
int32_t signhide_enable; /*!< \brief Flag to enable sign hiding. */
|
|
int32_t rdo; /*!< \brief RD-calculation level (0..2) */
|
|
int32_t full_intra_search; /*!< \brief If true, don't skip modes in intra search. */
|
|
int32_t trskip_enable; /*!< \brief Flag to enable transform skip. */
|
|
int32_t chroma_trskip_enable; /*!< \brief Flag to enable transform skip for chroma blocks. */
|
|
int32_t trskip_max_size; /*!< \brief Transform skip max block size. */
|
|
enum uvg_mts mts; /*< \brief flag to enable multiple transform selection*/
|
|
int32_t mts_implicit; /*< \brief flag to enable implicit multiple transform selection*/
|
|
int32_t tr_depth_intra; /*!< \brief Maximum transform depth for intra. */
|
|
enum uvg_ime_algorithm ime_algorithm; /*!< \brief Integer motion estimation algorithm. */
|
|
int32_t fme_level; /*!< \brief Fractional pixel motion estimation level (0: disabled, 1: enabled). */
|
|
int8_t source_scan_type; /*!< \brief Source scan type (0: progressive, 1: top field first, 2: bottom field first).*/
|
|
int32_t bipred; /*!< \brief Bi-prediction (0: disabled, 1: enabled). */
|
|
int32_t deblock_beta; /*!< \brief (deblocking) beta offset (div 2), range -6...6 */
|
|
int32_t deblock_tc; /*!< \brief (deblocking) tc offset (div 2), range -6...6 */
|
|
struct
|
|
{
|
|
int32_t sar_width; /*!< \brief the horizontal size of the sample aspect ratio (in arbitrary units) */
|
|
int32_t sar_height; /*!< \brief the vertical size of the sample aspect ratio (in the same arbitrary units as sar_width). */
|
|
int8_t overscan; /*!< \brief Crop overscan setting */
|
|
int8_t videoformat; /*!< \brief Video format */
|
|
int8_t fullrange; /*!< \brief Flag to indicate full-range */
|
|
int8_t colorprim; /*!< \brief Color primaries */
|
|
int8_t transfer; /*!< \brief Transfer characteristics */
|
|
int8_t colormatrix; /*!< \brief Color matrix coefficients */
|
|
int32_t chroma_loc; /*!< \brief Chroma sample location */
|
|
} vui;
|
|
int32_t aud_enable; /*!< \brief Flag to use access unit delimiters */
|
|
int32_t ref_frames; /*!< \brief number of reference frames to use */
|
|
char * cqmfile; /*!< \brief Pointer to custom quantization matrices filename */
|
|
|
|
int32_t tiles_width_count; /*!< \brief number of tiles separation in x direction */
|
|
int32_t tiles_height_count; /*!< \brief number of tiles separation in y direction */
|
|
int32_t* tiles_width_split; /*!< \brief tiles split x coordinates (dimension: tiles_width_count) */
|
|
int32_t* tiles_height_split; /*!< \brief tiles split y coordinates (dimension: tiles_height_count) */
|
|
|
|
int wpp;
|
|
int owf;
|
|
|
|
int32_t slice_count;
|
|
int32_t* slice_addresses_in_ts;
|
|
|
|
int32_t threads;
|
|
int32_t cpuid;
|
|
|
|
struct {
|
|
int32_t min[UVG_MAX_GOP_LAYERS];
|
|
int32_t max[UVG_MAX_GOP_LAYERS];
|
|
} pu_depth_inter, pu_depth_intra;
|
|
|
|
int32_t add_encoder_info;
|
|
int8_t gop_len; /*!< \brief length of GOP for the video sequence */
|
|
int8_t gop_lowdelay; /*!< \brief specifies that the GOP does not use future pictures */
|
|
uvg_gop_config gop[UVG_MAX_GOP_LENGTH]; /*!< \brief Array of GOP settings */
|
|
|
|
int32_t target_bitrate;
|
|
|
|
int8_t mv_rdo; /*!< \brief MV RDO calculation in search (0: estimation, 1: RDO). */
|
|
int8_t calc_psnr; /*!< \since 3.1.0 \brief Print PSNR in CLI. */
|
|
|
|
enum uvg_mv_constraint mv_constraint; /*!< \since 3.3.0 \brief Constrain movement vectors. */
|
|
enum uvg_hash hash; /*!< \since 3.5.0 \brief What hash algorithm to use. */
|
|
|
|
enum uvg_cu_split_termination cu_split_termination; /*!< \since 3.8.0 \brief Mode of cu split termination. */
|
|
|
|
enum uvg_me_early_termination me_early_termination; /*!< \since 3.8.0 \brief Mode of me early termination. */
|
|
int32_t intra_rdo_et; /*!< \since 4.1.0 \brief Use early termination in intra rdo. */
|
|
|
|
int32_t lossless; /*!< \brief Use lossless coding. */
|
|
|
|
int32_t tmvp_enable; /*!> \brief Use Temporal Motion Vector Predictors. */
|
|
|
|
int32_t rdoq_skip; /*!< \brief Mode of rdoq skip */
|
|
|
|
enum uvg_input_format input_format; /*!< \brief Use Temporal Motion Vector Predictors. */
|
|
int32_t input_bitdepth; /*!< \brief Use Temporal Motion Vector Predictors. */
|
|
|
|
struct {
|
|
unsigned d; // depth
|
|
unsigned t; // temporal
|
|
} gop_lp_definition;
|
|
|
|
int32_t implicit_rdpcm; /*!< \brief Enable implicit residual DPCM. */
|
|
|
|
struct {
|
|
char *file_path;
|
|
enum uvg_roi_format format;
|
|
} roi; /*!< \brief Specify delta QPs for region of interest coding. */
|
|
|
|
unsigned slices; /*!< \since 3.15.0 \brief How to map slices to frame. */
|
|
|
|
/**
|
|
* \brief Use adaptive QP for 360 video with equirectangular projection.
|
|
*/
|
|
int32_t erp_aqp;
|
|
|
|
/** \brief The HEVC level */
|
|
uint8_t level;
|
|
/** \brief Whether we ignore and just warn from all of the errors about the output not conforming to the level's requirements. */
|
|
uint8_t force_level;
|
|
/** \brief Whether we use the high tier bitrates. Requires the level to be 4 or higher. */
|
|
uint8_t high_tier;
|
|
/** \brief The maximum allowed bitrate for this level and tier. */
|
|
uint32_t max_bitrate;
|
|
|
|
/** \brief Maximum steps that hexagonal and diagonal motion estimation can use. -1 to disable */
|
|
uint32_t me_max_steps;
|
|
|
|
/** \brief Offset to add to QP for intra frames */
|
|
int8_t intra_qp_offset;
|
|
/** \brief Select intra QP Offset based on GOP length */
|
|
uint8_t intra_qp_offset_auto;
|
|
|
|
/** \brief Minimum QP that uses CABAC for residual cost instead of a fast estimate. */
|
|
int8_t fast_residual_cost_limit;
|
|
|
|
/** \brief Set QP at CU level keeping pic_init_qp_minus26 in PPS zero */
|
|
int8_t set_qp_in_cu;
|
|
|
|
/** \brief Flag to enable/disable open GOP configuration */
|
|
int8_t open_gop;
|
|
|
|
int32_t vaq; /** \brief Enable variance adaptive quantization*/
|
|
|
|
/** \brief Type of scaling lists to use */
|
|
int8_t scaling_list;
|
|
|
|
/** \brief Maximum number of merge cadidates */
|
|
uint8_t max_merge;
|
|
|
|
/** \brief Enable Early Skip Mode Decision */
|
|
uint8_t early_skip;
|
|
|
|
/** \brief Disable intra smoothing when true */
|
|
uint8_t intra_smoothing_disabled; /** \brief Enable Machine learning CU depth prediction for Intra encoding. */
|
|
uint8_t ml_pu_depth_intra;
|
|
|
|
/** \brief Used for partial frame encoding*/
|
|
struct {
|
|
uint8_t startCTU_x;
|
|
uint8_t startCTU_y;
|
|
uint16_t fullWidth;
|
|
uint16_t fullHeight;
|
|
} partial_coding;
|
|
|
|
/** \brief Always consider CU without any quantized residual */
|
|
uint8_t zero_coeff_rdo;
|
|
|
|
/** \brief Currently unused parameter for OBA rc */
|
|
int8_t frame_allocation;
|
|
|
|
/** \brief used rc scheme, 0 for QP */
|
|
int8_t rc_algorithm;
|
|
|
|
/** \brief whether to use hadamard based bit allocation for intra frames or not */
|
|
uint8_t intra_bit_allocation;
|
|
|
|
uint8_t clip_neighbour;
|
|
|
|
enum uvg_file_format file_format;
|
|
|
|
char *stats_file_prefix;
|
|
|
|
uint8_t log2_parallel_merge_level;
|
|
|
|
char *fast_coeff_table_fn; /*!< \brief Pointer to fast coeff table filename */
|
|
|
|
/** \brief whether we're sampling TBs and their costs for fast cost
|
|
* estimation training */
|
|
uint8_t rdo_cost_sampling_mode_on;
|
|
|
|
/** \brief whether we're running in normal mode, sampling TBs and their cost
|
|
* for fast estimation training, or comparing estimator accuracy to
|
|
* CABAC */
|
|
uint8_t fastrd_sampling_on;
|
|
uint8_t fastrd_accuracy_check_on;
|
|
|
|
char *fastrd_learning_outdir_fn;
|
|
|
|
int8_t num_used_table;
|
|
int8_t qp_table_start_minus26[3];
|
|
int8_t qp_table_length_minus1[3];
|
|
int8_t delta_qp_in_val_minus1[3][16];
|
|
int8_t delta_qp_out_val[3][16];
|
|
|
|
int8_t chroma_scale_in[3][17];
|
|
int8_t chroma_scale_out[3][17];
|
|
|
|
/** \brief enable use of multiple reference lines in intra prediction */
|
|
int8_t mrl;
|
|
|
|
/** \brief enable matrix weighted intra prediction */
|
|
int8_t mip;
|
|
/** \brief enable low frequency non-separable transform */
|
|
int8_t lfnst;
|
|
|
|
/** \brief enable intra sub partitions*/
|
|
int8_t isp;
|
|
|
|
int8_t jccr;
|
|
|
|
int8_t cclm;
|
|
|
|
int8_t amvr; /* \brief Adaptive motion vector resolution parameter */
|
|
|
|
/** \brief whether to try combining intra cus at the lower depth when search
|
|
* is not performed at said depth*/
|
|
uint8_t combine_intra_cus;
|
|
|
|
uint8_t force_inter;
|
|
char* cabac_debug_file_name;
|
|
|
|
uint8_t dual_tree;
|
|
} uvg_config;
|
|
|
|
/**
|
|
* \brief Struct which contains all picture data
|
|
*
|
|
* Function picture_alloc in uvg_api must be used for allocation.
|
|
*/
|
|
typedef struct uvg_picture {
|
|
uvg_pixel *fulldata_buf; //!< \brief Allocated buffer with padding (only used in the base_image)
|
|
uvg_pixel *fulldata; //!< \brief Allocated buffer portion that's actually used
|
|
|
|
uvg_pixel *y; //!< \brief Pointer to luma pixel array.
|
|
uvg_pixel *u; //!< \brief Pointer to chroma U pixel array.
|
|
uvg_pixel *v; //!< \brief Pointer to chroma V pixel array.
|
|
uvg_pixel *data[3]; //!< \brief Alternate access method to same data.
|
|
|
|
int32_t width; //!< \brief Luma pixel array width.
|
|
int32_t height; //!< \brief Luma pixel array height.
|
|
|
|
int32_t stride; //!< \brief Luma pixel array width for the full picture (should be used as stride)
|
|
|
|
struct uvg_picture *base_image; //!< \brief Pointer to the picture which owns the pixels
|
|
int32_t refcount; //!< \brief Number of references to the picture
|
|
|
|
int64_t pts; //!< \brief Presentation timestamp. Should be set for input frames.
|
|
int64_t dts; //!< \brief Decompression timestamp.
|
|
|
|
enum uvg_interlacing interlacing; //!< \since 3.2.0 \brief Field order for interlaced pictures.
|
|
enum uvg_chroma_format chroma_format;
|
|
|
|
int32_t ref_pocs[16];
|
|
|
|
struct
|
|
{
|
|
int width;
|
|
int height;
|
|
int8_t *roi_array;
|
|
} roi;
|
|
|
|
} uvg_picture;
|
|
|
|
/**
|
|
* \brief NAL unit type codes.
|
|
*
|
|
* These are the nal_unit_type codes from Table 7-1 ITU-T H.265 v1.0.
|
|
*/
|
|
enum uvg_nal_unit_type {
|
|
|
|
// Coded slices
|
|
|
|
UVG_NAL_TRAIL = 0,
|
|
UVG_NAL_STSA = 1,
|
|
UVG_NAL_RADL = 2,
|
|
UVG_NAL_RASL = 3,
|
|
|
|
// Intra random access point pictures
|
|
UVG_NAL_IDR_W_RADL = 7,
|
|
UVG_NAL_IDR_N_LP = 8,
|
|
UVG_NAL_CRA_NUT = 9,
|
|
UVG_NAL_GDR_NUT = 10,
|
|
|
|
|
|
// non-VCL
|
|
UVG_NAL_VPS_NUT = 14,
|
|
UVG_NAL_SPS_NUT = 15,
|
|
UVG_NAL_PPS_NUT = 16,
|
|
NAL_UNIT_PREFIX_APS = 17,
|
|
NAL_UNIT_SUFFIX_APS = 18,
|
|
|
|
UVG_NAL_AUD_NUT = 20,
|
|
|
|
UVG_NAL_EOS_NUT = 21,
|
|
UVG_NAL_EOB_NUT = 22,
|
|
UVG_NAL_PREFIX_SEI_NUT = 23,
|
|
UVG_NAL_SUFFIX_SEI_NUT = 24,
|
|
|
|
|
|
};
|
|
|
|
enum uvg_slice_type {
|
|
UVG_SLICE_B = 0,
|
|
UVG_SLICE_P = 1,
|
|
UVG_SLICE_I = 2,
|
|
};
|
|
|
|
enum uvg_split_mode {
|
|
UVG_NO_SPLIT = 0,
|
|
UVG_QUAD_SPLIT = 1,
|
|
UVG_HORZ_SPLIT = 2,
|
|
UVG_VERT_SPLIT = 3,
|
|
};
|
|
|
|
/**
|
|
* \brief Other information about an encoded frame
|
|
*/
|
|
typedef struct uvg_frame_info {
|
|
|
|
/**
|
|
* \brief Picture order count
|
|
*/
|
|
int32_t poc;
|
|
|
|
/**
|
|
* \brief Quantization parameter
|
|
*/
|
|
int8_t qp;
|
|
|
|
/**
|
|
* \brief Type of the NAL VCL unit
|
|
*/
|
|
enum uvg_nal_unit_type nal_unit_type;
|
|
|
|
/**
|
|
* \brief Type of the slice
|
|
*/
|
|
enum uvg_slice_type slice_type;
|
|
|
|
/**
|
|
* \brief Reference picture lists
|
|
*
|
|
* The first list contains the reference picture POCs that are less than the
|
|
* POC of this frame and the second one contains those that are greater.
|
|
*/
|
|
int ref_list[2][16];
|
|
|
|
/**
|
|
* \brief Lengths of the reference picture lists
|
|
*/
|
|
int ref_list_len[2];
|
|
|
|
} uvg_frame_info;
|
|
|
|
/**
|
|
* \brief A linked list of chunks of data.
|
|
*
|
|
* Used for returning the encoded data.
|
|
*/
|
|
typedef struct uvg_data_chunk {
|
|
/// \brief Buffer for the data.
|
|
uint8_t data[UVG_DATA_CHUNK_SIZE];
|
|
|
|
/// \brief Number of bytes filled in this chunk.
|
|
uint32_t len;
|
|
|
|
/// \brief Next chunk in the list.
|
|
struct uvg_data_chunk *next;
|
|
} uvg_data_chunk;
|
|
|
|
typedef struct uvg_api {
|
|
|
|
/**
|
|
* \brief Allocate a uvg_config structure.
|
|
*
|
|
* The returned structure should be deallocated by calling config_destroy.
|
|
*
|
|
* \return allocated config, or NULL if allocation failed.
|
|
*/
|
|
uvg_config * (*config_alloc)(void);
|
|
|
|
/**
|
|
* \brief Deallocate a uvg_config structure.
|
|
*
|
|
* If cfg is NULL, do nothing. Otherwise, the given structure must have been
|
|
* returned from config_alloc.
|
|
*
|
|
* \param cfg configuration
|
|
* \return 1 on success, 0 on failure
|
|
*/
|
|
int (*config_destroy)(uvg_config *cfg);
|
|
|
|
/**
|
|
* \brief Initialize a config structure
|
|
*
|
|
* Set all fields in the given config to default values.
|
|
*
|
|
* \param cfg configuration
|
|
* \return 1 on success, 0 on failure
|
|
*/
|
|
int (*config_init)(uvg_config *cfg);
|
|
|
|
/**
|
|
* \brief Set an option.
|
|
*
|
|
* \param cfg configuration
|
|
* \param name name of the option to set
|
|
* \param value value to set
|
|
* \return 1 on success, 0 on failure
|
|
*/
|
|
int (*config_parse)(uvg_config *cfg, const char *name, const char *value);
|
|
|
|
/**
|
|
* \brief Allocate a uvg_picture.
|
|
*
|
|
* The returned uvg_picture should be deallocated by calling picture_free.
|
|
*
|
|
* \param width width of luma pixel array to allocate
|
|
* \param height height of luma pixel array to allocate
|
|
* \return allocated picture, or NULL if allocation failed.
|
|
*/
|
|
uvg_picture * (*picture_alloc)(int32_t width, int32_t height);
|
|
|
|
/**
|
|
* \brief Deallocate a uvg_picture.
|
|
*
|
|
* If pic is NULL, do nothing. Otherwise, the picture must have been returned
|
|
* from picture_alloc.
|
|
*/
|
|
void (*picture_free)(uvg_picture *pic);
|
|
|
|
/**
|
|
* \brief Deallocate a list of data chunks.
|
|
*
|
|
* Deallocates the given chunk and all chunks that follow it in the linked
|
|
* list.
|
|
*/
|
|
void (*chunk_free)(uvg_data_chunk *chunk);
|
|
|
|
/**
|
|
* \brief Create an encoder.
|
|
*
|
|
* The returned encoder should be closed by calling encoder_close.
|
|
*
|
|
* Only one encoder may be open at a time.
|
|
*
|
|
* \param cfg encoder configuration
|
|
* \return g_created encoder, or NULL if creation failed.
|
|
*/
|
|
uvg_encoder * (*encoder_open)(const uvg_config *cfg);
|
|
|
|
/**
|
|
* \brief Deallocate an encoder.
|
|
*
|
|
* If encoder is NULL, do nothing. Otherwise, the encoder must have been
|
|
* returned from encoder_open.
|
|
*/
|
|
void (*encoder_close)(uvg_encoder *encoder);
|
|
|
|
/**
|
|
* \brief Get parameter sets.
|
|
*
|
|
* Encode the VPS, SPS and PPS.
|
|
*
|
|
* If data_out is set to non-NULL values, the caller is responsible for
|
|
* calling chunk_free on it.
|
|
*
|
|
* A null pointer may be passed in place of the parameter data_out or len_out
|
|
* to skip returning the corresponding value.
|
|
*
|
|
* \param encoder encoder
|
|
* \param data_out Returns the encoded parameter sets.
|
|
* \param len_out Returns number of bytes in the encoded data.
|
|
* \return 1 on success, 0 on error.
|
|
*/
|
|
int (*encoder_headers)(uvg_encoder *encoder,
|
|
uvg_data_chunk **data_out,
|
|
uint32_t *len_out);
|
|
|
|
/**
|
|
* \brief Encode one frame.
|
|
*
|
|
* Add pic_in to the encoding pipeline. If an encoded frame is ready, return
|
|
* the bitstream, length of the bitstream, the reconstructed frame, the
|
|
* original frame and frame info in data_out, len_out, pic_out, src_out and
|
|
* info_out, respectively. Otherwise, set the output parameters to NULL.
|
|
*
|
|
* Region of interest (ROI) / delta QP map can be specified in the input
|
|
* picture's ROI field but only when a ROI file is not used.
|
|
*
|
|
* After passing all of the input frames, the caller should keep calling this
|
|
* function with pic_in set to NULL, until no more data is returned in the
|
|
* output parameters.
|
|
*
|
|
* The caller must not modify pic_in after passing it to this function.
|
|
*
|
|
* If data_out, pic_out and src_out are set to non-NULL values, the caller is
|
|
* responsible for calling chunk_free and picture_free on them.
|
|
*
|
|
* A null pointer may be passed in place of any of the parameters data_out,
|
|
* len_out, pic_out, src_out or info_out to skip returning the corresponding
|
|
* value.
|
|
*
|
|
* \param encoder encoder
|
|
* \param pic_in input frame or NULL
|
|
* \param data_out Returns the encoded data.
|
|
* \param len_out Returns number of bytes in the encoded data.
|
|
* \param pic_out Returns the reconstructed picture.
|
|
* \param src_out Returns the original picture.
|
|
* \param info_out Returns information about the encoded picture.
|
|
* \return 1 on success, 0 on error.
|
|
*/
|
|
int (*encoder_encode)(uvg_encoder *encoder,
|
|
uvg_picture *pic_in,
|
|
uvg_data_chunk **data_out,
|
|
uint32_t *len_out,
|
|
uvg_picture **pic_out,
|
|
uvg_picture **src_out,
|
|
uvg_frame_info *info_out);
|
|
|
|
/**
|
|
* \brief Allocate a uvg_picture.
|
|
*
|
|
* The returned uvg_picture should be deallocated by calling picture_free.
|
|
*
|
|
* \since 3.12.0
|
|
* \param chroma_fomat Chroma subsampling to use.
|
|
* \param width width of luma pixel array to allocate
|
|
* \param height height of luma pixel array to allocate
|
|
* \return allocated picture, or NULL if allocation failed.
|
|
*/
|
|
uvg_picture * (*picture_alloc_csp)(enum uvg_chroma_format chroma_fomat, int32_t width, int32_t height);
|
|
} uvg_api;
|
|
|
|
|
|
UVG_PUBLIC const uvg_api * uvg_api_get(int bit_depth);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // UVG266_H_
|