blob: 449afb8c013d7bfdb9f2556462da2f594f5b1c97 [file] [log] [blame]
* \file
* global.h
* \brief
* global definitions for H.264 encoder.
* \author
* Copyright (C) 1999 Telenor Satellite Services,Norway
* Ericsson Radio Systems, Sweden
* Inge Lille-Langoy <>
* Telenor Satellite Services
* Keysers gt.13 tel.: +47 23 13 86 98
* N-0130 Oslo,Norway fax.: +47 22 77 79 80
* Rickard Sjoberg <>
* Ericsson Radio Systems
* 164 80 Stockholm, Sweden
#ifndef _GLOBAL_H_
#define _GLOBAL_H_
#include <stdio.h>
#include <time.h>
#include "win32.h"
#include "defines.h"
#include "parsetcommon.h"
#include "q_matrix.h"
#include "q_offsets.h"
#include "minmax.h"
#include "ifunctions.h"
* T y p e d e f i n i t i o n s f o r T M L
//typedef byte imgpel;
//typedef unsigned short distpel;
typedef unsigned short imgpel;
typedef int distpel;
enum {
YUV400 = 0,
YUV420 = 1,
YUV422 = 2,
YUV444 = 3
} color_formats;
enum {
LIST_0 = 0,
LIST_1 = 1,
BI_PRED = 2,
BI_PRED_L0 = 3,
BI_PRED_L1 = 4
enum {
enum {
ME_Y_ONLY = 0,
ME_YUV_FP = 1,
enum {
//! Data Partitioning Modes
typedef enum
PAR_DP_1, //!< no data partitioning is supported
PAR_DP_3 //!< data partitioning with 3 partitions
//! Output File Types
typedef enum
PAR_OF_ANNEXB, //!< Annex B byte stream format
PAR_OF_RTP //!< RTP packets in outfile
//! Field Coding Types
typedef enum
} CodingType;
//! definition of H.264 syntax elements
typedef enum
SE_MAX_ELEMENTS //!< number of maximum syntax elements
} SE_type; // substituting the definitions in elements.h
typedef enum
} IntraInterDecision;
typedef enum
} BitCountType;
typedef enum
} SliceMode;
typedef enum
} SymbolMode;
typedef enum
UM_HEX = 1,
EPZS = 3
} SearchType;
typedef enum
} PictureStructure; //!< New enum for field processing
typedef enum
P_SLICE = 0,
B_SLICE = 1,
I_SLICE = 2,
} SliceType;
//Motion Estimation levels
typedef enum
F_PEL, //!< Full Pel refinement
H_PEL, //!< Half Pel refinement
Q_PEL //!< Quarter Pel refinement
} MELevel;
typedef enum
FAST_ACCESS = 0, //!< Fast/safe reference access
UMV_ACCESS = 1 //!< unconstrained reference access
typedef enum
IS_LUMA = 0,
} Component_Type;
typedef enum
RC_MODE_0 = 0,
RC_MODE_1 = 1,
RC_MODE_2 = 2,
RC_MODE_3 = 3
} RCModeType;
* D a t a t y p e s f o r C A B A C
//! struct to characterize the state of the arithmetic coding engine
typedef struct
unsigned int Elow, Erange;
unsigned int Ebuffer;
unsigned int Ebits_to_go;
unsigned int Ebits_to_follow;
byte *Ecodestrm;
int *Ecodestrm_len;
int C;
int E;
} EncodingEnvironment;
typedef EncodingEnvironment *EncodingEnvironmentPtr;
//! struct for context management
typedef struct
unsigned short state; // index into state-table CP
unsigned char MPS; // Least Probable Symbol 0/1 CP
unsigned long count;
} BiContextType;
typedef BiContextType *BiContextTypePtr;
* C O N T E X T S F O R T M L S Y N T A X E L E M E N T S
#define NUM_MB_TYPE_CTX 11
#define NUM_B8_TYPE_CTX 9
#define NUM_MV_RES_CTX 10
#define NUM_REF_NO_CTX 6
#define NUM_DELTA_QP_CTX 4
#define NUM_MB_AFF_CTX 4
typedef struct
BiContextType mb_type_contexts [3][NUM_MB_TYPE_CTX];
BiContextType b8_type_contexts [2][NUM_B8_TYPE_CTX];
BiContextType mv_res_contexts [2][NUM_MV_RES_CTX];
BiContextType ref_no_contexts [2][NUM_REF_NO_CTX];
BiContextType delta_qp_contexts [NUM_DELTA_QP_CTX];
BiContextType mb_aff_contexts [NUM_MB_AFF_CTX];
BiContextType transform_size_contexts [NUM_TRANSFORM_SIZE_CTX];
} MotionInfoContexts;
#define NUM_IPR_CTX 2
#define NUM_CIPR_CTX 4
#define NUM_CBP_CTX 4
#define NUM_BCBP_CTX 4
#define NUM_MAP_CTX 15
#define NUM_LAST_CTX 15
#define NUM_ONE_CTX 5
#define NUM_ABS_CTX 5
typedef struct
BiContextType ipr_contexts [NUM_IPR_CTX];
BiContextType cipr_contexts[NUM_CIPR_CTX];
BiContextType cbp_contexts [3][NUM_CBP_CTX];
BiContextType bcbp_contexts[NUM_BLOCK_TYPES][NUM_BCBP_CTX];
BiContextType map_contexts [NUM_BLOCK_TYPES][NUM_MAP_CTX];
BiContextType last_contexts[NUM_BLOCK_TYPES][NUM_LAST_CTX];
BiContextType one_contexts [NUM_BLOCK_TYPES][NUM_ONE_CTX];
BiContextType abs_contexts [NUM_BLOCK_TYPES][NUM_ABS_CTX];
BiContextType fld_map_contexts [NUM_BLOCK_TYPES][NUM_MAP_CTX];
BiContextType fld_last_contexts[NUM_BLOCK_TYPES][NUM_LAST_CTX];
} TextureInfoContexts;
//*********************** end of data type definition for CABAC *******************
//! Pixel position for checking neighbors
typedef struct pix_pos
int available;
int mb_addr;
int x;
int y;
int pos_x;
int pos_y;
} PixelPos;
//! Buffer structure for decoded reference picture marking commands
typedef struct DecRefPicMarking_s
int memory_management_control_operation;
int difference_of_pic_nums_minus1;
int long_term_pic_num;
int long_term_frame_idx;
int max_long_term_frame_idx_plus1;
struct DecRefPicMarking_s *Next;
} DecRefPicMarking_t;
//! Syntax Element
typedef struct syntaxelement
int type; //!< type of syntax element for data part.
int value1; //!< numerical value of syntax element
int value2; //!< for blocked symbols, e.g. run/level
int len; //!< length of code
int inf; //!< info part of UVLC code
unsigned int bitpattern; //!< UVLC bitpattern
int context; //!< CABAC context
#define TRACESTRING_SIZE 100 //!< size of trace string
char tracestring[TRACESTRING_SIZE]; //!< trace string
//!< for mapping of syntaxElement to UVLC
void (*mapping)(int value1, int value2, int* len_ptr, int* info_ptr);
} SyntaxElement;
//! Macroblock
typedef struct macroblock
int slice_nr;
int delta_qp;
int qp; //!< QP luma
int qpc[2]; //!< QP chroma
int qpsp ;
int bitcounter[MAX_BITCOUNTER_MB];
struct macroblock *mb_available_up; //!< pointer to neighboring MB (CABAC)
struct macroblock *mb_available_left; //!< pointer to neighboring MB (CABAC)
int mb_type;
int mvd[2][BLOCK_MULTIPLE][BLOCK_MULTIPLE][2]; //!< indices correspond to [list][block_y][block_x][x,y]
signed char intra_pred_modes[MB_BLOCK_PARTITIONS];
signed char intra_pred_modes8x8[MB_BLOCK_PARTITIONS]; //!< four 8x8 blocks in a macroblock
int cbp ;
int64 cbp_blk ; //!< 1 bit set for every 4x4 block with coefs (not implemented for INTRA)
int b8mode[4];
int b8pdir[4];
int64 cbp_bits;
int c_ipred_mode; //!< chroma intra prediction mode
int IntraChromaPredModeFlag;
int mb_field;
int is_field_mode;
int list_offset;
int mbAddrA, mbAddrB, mbAddrC, mbAddrD;
int mbAvailA, mbAvailB, mbAvailC, mbAvailD;
int all_blk_8x8;
int luma_transform_size_8x8_flag;
int NoMbPartLessThan8x8Flag;
short bi_pred_me;
// rate control
double actj; // macroblock activity measure for macroblock j
int prev_qp;
int prev_delta_qp;
int prev_cbp;
int predict_qp;
int predict_error;
int LFDisableIdc;
int LFAlphaC0Offset;
int LFBetaOffset;
int skip_flag;
} Macroblock;
//! Bitstream
typedef struct
int byte_pos; //!< current position in bitstream;
int bits_to_go; //!< current bitcounter
byte byte_buf; //!< current buffer for last written byte
int stored_byte_pos; //!< storage for position in bitstream;
int stored_bits_to_go; //!< storage for bitcounter
byte stored_byte_buf; //!< storage for buffer of last written byte
byte byte_buf_skip; //!< current buffer for last written byte
int byte_pos_skip; //!< storage for position in bitstream;
int bits_to_go_skip; //!< storage for bitcounter
byte *streamBuffer; //!< actual buffer for written bytes
int write_flag; //!< Bitstream contains data and needs to be written
Boolean trace_enabled;
} Bitstream;
//! DataPartition
typedef struct datapartition
Bitstream *bitstream;
EncodingEnvironment ee_cabac;
EncodingEnvironment ee_recode;
} DataPartition;
//! Slice
typedef struct
int picture_id;
int qp;
int picture_type; //!< picture type
int start_mb_nr;
int max_part_nr; //!< number of different partitions
int num_mb; //!< number of MBs in the slice
DataPartition *partArr; //!< array of partitions
MotionInfoContexts *mot_ctx; //!< pointer to struct of context models for use in CABAC
TextureInfoContexts *tex_ctx; //!< pointer to struct of context models for use in CABAC
int ref_pic_list_reordering_flag_l0;
int *reordering_of_pic_nums_idc_l0;
int *abs_diff_pic_num_minus1_l0;
int *long_term_pic_idx_l0;
int ref_pic_list_reordering_flag_l1;
int *reordering_of_pic_nums_idc_l1;
int *abs_diff_pic_num_minus1_l1;
int *long_term_pic_idx_l1;
Boolean (*slice_too_big)(int bits_slice); //!< for use of callback functions
int field_ctx[3][2]; //GB
} Slice;
typedef struct
int no_slices;
int idr_flag;
int bits_per_picture;
float distortion_y;
float distortion_u;
float distortion_v;
} Picture;
Picture *top_pic;
Picture *bottom_pic;
Picture *frame_pic;
Picture *frame_pic_1;
Picture *frame_pic_2;
Picture *frame_pic_3;
Picture *frame_pic_si;
long *Bit_Buffer;
// global picture format dependend buffers, mem allocation in image.c
imgpel **imgY_org; //!< Reference luma image
imgpel ***imgUV_org; //!< Reference chroma image
int **imgY_sub_tmp; //!< Y picture temporary component (Quarter pel)
int **PicPos;
unsigned int log2_max_frame_num_minus4;
unsigned int log2_max_pic_order_cnt_lsb_minus4;
time_t me_tot_time,me_time;
pic_parameter_set_rbsp_t *active_pps;
seq_parameter_set_rbsp_t *active_sps;
int dsr_new_search_range; //!<Dynamic Search Range.
// B pictures
// motion vector : forward, backward, direct
int mb_adaptive; //!< For MB level field/frame coding tools
int MBPairIsField; //!< For MB level field/frame coding tools
//Weighted prediction
int ***wp_weight; // weight in [list][index][component] order
int ***wp_offset; // offset in [list][index][component] order
int ****wbp_weight; // weight in [list][fwd_index][bwd_idx][component] order
int luma_log_weight_denom;
int chroma_log_weight_denom;
int wp_luma_round;
int wp_chroma_round;
// global picture format dependend buffers, mem allocation in image.c (field picture)
imgpel **imgY_org_top;
imgpel **imgY_org_bot;
imgpel ***imgUV_org_top;
imgpel ***imgUV_org_bot;
imgpel **imgY_org_frm;
imgpel ***imgUV_org_frm;
imgpel **imgY_com; //!< Encoded luma images
imgpel ***imgUV_com; //!< Encoded croma images
signed char ***direct_ref_idx; //!< direct mode reference index buffer
signed char **direct_pdir; //!< direct mode reference index buffer
// Buffers for rd optimization with packet losses, Dim. Kontopodis
byte **pixel_map; //!< Shows the latest reference frame that is reliable for each pixel
byte **refresh_map; //!< Stores the new values for pixel_map
int intras; //!< Counts the intra updates in each frame.
int frame_ctr[5];
int frame_no, nextP_tr_fld, nextP_tr_frm;
time_t tot_time;
#define ET_SIZE 300 //!< size of error text buffer
char errortext[ET_SIZE]; //!< buffer for error message for exit with error()
// Residue Color Transform
signed char b8_ipredmode8x8[4][4], b8_intra_pred_modes8x8[16];
//! Info for the "decoders-in-the-encoder" used for rdoptimization with packet losses
typedef struct
int **resY; //!< Residue of Luminance
imgpel ***decY; //!< Decoded values at the simulated decoders
imgpel ****decref; //!< Reference frames of the simulated decoders
imgpel ***decY_best; //!< Decoded frames for the best mode for all decoders
imgpel **RefBlock;
byte **status_map;
byte **dec_mb_mode;
} Decoders;
extern Decoders *decs;
//! SNRParameters
typedef struct
float snr_y; //!< current Y SNR
float snr_u; //!< current U SNR
float snr_v; //!< current V SNR
float snr_y1; //!< SNR Y(dB) first frame
float snr_u1; //!< SNR U(dB) first frame
float snr_v1; //!< SNR V(dB) first frame
float snr_yt[5]; //!< SNR Y(dB) based on frame type
float snr_ut[5]; //!< SNR U(dB) based on frame type
float snr_vt[5]; //!< SNR V(dB) based on frame type
float snr_ya; //!< Average SNR Y(dB) remaining frames
float snr_ua; //!< Average SNR U(dB) remaining frames
float snr_va; //!< Average SNR V(dB) remaining frames
float sse_y; //!< SSE Y
float sse_u; //!< SSE U
float sse_v; //!< SSE V
float msse_y; //!< Average SSE Y
float msse_u; //!< Average SSE U
float msse_v; //!< Average SSE V
int frame_ctr; //!< number of coded frames
} SNRParameters;
#define FILE_NAME_SIZE 256
//! all input parameters
typedef struct
int ProfileIDC; //!< value of syntax element profile_idc
int LevelIDC; //!< value of syntax element level_idc
int no_frames; //!< number of frames to be encoded
int qp0; //!< QP of first frame
int qpN; //!< QP of remaining frames
int jumpd; //!< number of frames to skip in input sequence (e.g 2 takes frame 0,3,6,9...)
int DisableSubpelME; //!< Disable sub-pixel motion estimation
int search_range; /*!< search range - integer pel search and 16x16 blocks. The search window is
generally around the predicted vector. Max vector is 2xmcrange. For 8x8
and 4x4 block sizes the search range is 1/2 of that for 16x16 blocks. */
int num_ref_frames; //!< number of reference frames to be used
int P_List0_refs; //!< number of reference picture in list 0 in P pictures
int B_List0_refs; //!< number of reference picture in list 0 in B pictures
int B_List1_refs; //!< number of reference picture in list 1 in B pictures
int Log2MaxFNumMinus4; //!< value of syntax element log2_max_frame_num
int Log2MaxPOCLsbMinus4; //!< value of syntax element log2_max_pic_order_cnt_lsb_minus4
int img_width; //!< image width (must be a multiple of 16 pels)
int img_height; //!< image height (must be a multiple of 16 pels)
int yuv_format; //!< YUV format (0=4:0:0, 1=4:2:0, 2=4:2:2, 3=4:4:4)
int intra_upd; /*!< For error robustness. 0: no special action. 1: One GOB/frame is intra coded
as regular 'update'. 2: One GOB every 2 frames is intra coded etc.
In connection with this intra update, restrictions is put on motion vectors
to prevent errors to propagate from the past */
int blc_size[8][2]; //!< array for different block sizes
int part_size[8][2]; //!< array for different partition sizes
int blocktype_lut[4][4]; //!< array for different partition sizes
int slice_mode; //!< Indicate what algorithm to use for setting slices
int slice_argument; //!< Argument to the specified slice algorithm
int UseConstrainedIntraPred; //!< 0: Inter MB pixels are allowed for intra prediction 1: Not allowed
int infile_header; //!< If input file has a header set this to the length of the header
char infile[FILE_NAME_SIZE]; //!< YUV 4:2:0 input format
char outfile[FILE_NAME_SIZE]; //!< H.264 compressed output bitstream
char ReconFile[FILE_NAME_SIZE]; //!< Reconstructed Pictures
char TraceFile[FILE_NAME_SIZE]; //!< Trace Outputs
char QmatrixFile[FILE_NAME_SIZE]; //!< Q matrix cfg file
int intra_period; //!< Random Access period though intra
int EnableOpenGOP; //!< support for open gops.
int idr_enable; //!< Encode intra slices as IDR
int start_frame; //!< Encode sequence starting from Frame start_frame
int GenerateMultiplePPS;
int Generate_SEIVUI;
char SEIMessageText[500];
int VUISupport;
int ResendSPS;
int ResendPPS;
// B pictures
int successive_Bframe; //!< number of B frames that will be used
int PReplaceBSlice;
int qpB; //!< QP for non-reference B slice coded pictures
int qpBRSOffset; //!< QP for reference B slice coded pictures
int direct_spatial_mv_pred_flag; //!< Direct Mode type to be used (0: Temporal, 1: Spatial)
int directInferenceFlag; //!< Direct Mode Inference Flag
int BiPredMotionEstimation;
int BiPredMERefinements;
int BiPredMESearchRange;
int BiPredMESubPel;
// SP Pictures
int sp_periodicity; //!< The periodicity of SP-pictures
int qpsp; //!< SP Picture QP for prediction error
int qpsp_pred; //!< SP Picture QP for predicted block
int si_frame_indicator; //!< Flag indicating whether SI frames should be encoded rather than SP frames (0: not used, 1: used)
int sp2_frame_indicator; //!< Flag indicating whether switching SP frames should be encoded rather than SP frames (0: not used, 1: used)
int sp_output_indicator; //!< Flag indicating whether coefficients are output to allow future encoding of switchin SP frames (0: not used, 1: used)
char sp_output_filename[FILE_NAME_SIZE]; //!<Filename where SP coefficients are output
char sp2_input_filename1[FILE_NAME_SIZE]; //!<Filename of coefficients of the first bitstream when encoding SP frames to switch bitstreams
char sp2_input_filename2[FILE_NAME_SIZE]; //!<Filenames of coefficients of the second bitstream when encoding SP frames to switch bitstreams
int WeightedPrediction; //!< Weighted prediction for P frames (0: not used, 1: explicit)
int WeightedBiprediction; //!< Weighted prediction for B frames (0: not used, 1: explicit, 2: implicit)
int UseWeightedReferenceME; //!< Use Weighted Reference for ME.
int RDPictureDecision; //!< Perform RD optimal decision between various coded versions of same picture
int RDPictureIntra; //!< Enabled RD pic decision for intra as well.
int RDPSliceWeightOnly; //!< If enabled, does not check QP variations for P slices.
int RDPSliceBTest; //!< Tests B slice replacement for P.
int RDBSliceWeightOnly; //!< If enabled, does not check QP variations for B slices.
int SkipIntraInInterSlices; //!< Skip intra type checking in inter slices if best_mode is skip/direct
int BRefPictures; //!< B coded reference pictures replace P pictures (0: not used, 1: used)
int HierarchicalCoding;
int HierarchyLevelQPEnable;
char ExplicitHierarchyFormat[1024];//!< Explicit GOP format (HierarchicalCoding==3).
int ReferenceReorder; //!< Reordering based on Poc distances
int PocMemoryManagement; //!< Memory management based on Poc distances for hierarchical coding
int symbol_mode; //!< Specifies the mode the symbols are mapped on bits
int of_mode; //!< Specifies the mode of the output file
int partition_mode; //!< Specifies the mode of data partitioning
int InterSearch16x16;
int InterSearch16x8;
int InterSearch8x16;
int InterSearch8x8;
int InterSearch8x4;
int InterSearch4x8;
int InterSearch4x4;
int IntraDisableInterOnly;
int Intra4x4ParDisable;
int Intra4x4DiagDisable;
int Intra4x4DirDisable;
int Intra16x16ParDisable;
int Intra16x16PlaneDisable;
int ChromaIntraDisable;
int EnableIPCM;
double FrameRate;
int EPZSPattern;
int EPZSDual;
int EPZSFixed;
int EPZSTemporal;
int EPZSSpatialMem;
int EPZSMinThresScale;
int EPZSMaxThresScale;
int EPZSMedThresScale;
int EPZSSubPelGrid;
int EPZSSubPelME;
int EPZSSubPelMEBiPred;
int EPZSSubPelThresScale;
int chroma_qp_index_offset;
int full_search;
int last_frame;
#ifdef _CHANGE_QP_
int qpN2, qpB2, qp2start;
int qp02, qpBRS2Offset;
int rdopt;
int CtxAdptLagrangeMult; //!< context adaptive lagrangian multiplier
int FastCrIntraDecision;
int disthres;
int nobskip;
int NumberLeakyBuckets;
char LeakyBucketRateFile[FILE_NAME_SIZE];
char LeakyBucketParamFile[FILE_NAME_SIZE];
int PicInterlace; //!< picture adaptive frame/field
int MbInterlace; //!< macroblock adaptive frame/field
int IntraBottom; //!< Force Intra Bottom at GOP periods.
int LossRateA; //!< assumed loss probablility of partition A (or full slice), in per cent, used for loss-aware R/D optimization
int LossRateB; //!< assumed loss probablility of partition B, in per cent, used for loss-aware R/D
int LossRateC; //!< assumed loss probablility of partition C, in per cent, used for loss-aware R/D
int NoOfDecoders;
int RestrictRef;
int NumFramesInELSubSeq;
int NumFrameIn2ndIGOP;
int RandomIntraMBRefresh; //!< Number of pseudo-random intra-MBs per picture
int LFSendParameters;
int LFDisableIdc;
int LFAlphaC0Offset;
int LFBetaOffset;
int SparePictureOption;
int SPDetectionThreshold;
int SPPercentageThreshold;
// FMO
char SliceGroupConfigFileName[FILE_NAME_SIZE]; //!< Filename for config info fot type 0, 2, 6
int num_slice_groups_minus1; //!< "FmoNumSliceGroups" in encoder.cfg, same as FmoNumSliceGroups, which should be erased later
int slice_group_map_type;
int *top_left; //!< top_left and bottom_right store values indicating foregrounds
int *bottom_right;
byte *slice_group_id; //!< slice_group_id is for slice group type being 6
int *run_length_minus1; //!< run_length_minus1 is for slice group type being 0
int slice_group_change_direction_flag;
int slice_group_change_rate_minus1;
int slice_group_change_cycle;
int redundant_pic_flag; //! encoding of redundant pictures
int pic_order_cnt_type; //! POC type
int context_init_method;
int model_number;
int Transform8x8Mode;
int ReportFrameStats;
int DisplayEncParams;
int Verbose;
//! Rate Control on JVT standard
int RCEnable;
int bit_rate;
int SeinitialQP;
unsigned int basicunit;
int channel_type;
int RCUpdateMode;
double RCIoverPRatio;
double RCBoverPRatio;
double RCISliceBitRatio;
int ScalingMatrixPresentFlag;
int ScalingListPresentFlag[8];
// Search Algorithm
SearchType SearchMode;
int UMHexDSR;//!< Dynamic Search Range
int UMHexScale;
// Fidelity Range Extensions
int BitDepthLuma;
int BitDepthChroma;
int img_height_cr;
int img_width_cr;
int rgb_input_flag;
int cb_qp_index_offset;
int cr_qp_index_offset;
// Lossless Coding
int lossless_qpprime_y_zero_flag;
// Lambda Params
int UseExplicitLambdaParams;
double LambdaWeight[6];
double FixedLambda[6];
char QOffsetMatrixFile[FILE_NAME_SIZE]; //!< Quantization Offset matrix cfg file
int OffsetMatrixPresentFlag; //!< Enable Explicit Quantization Offset Matrices
int AdaptiveRounding; //!< Adaptive Rounding parameter based on JVT-N011
int AdaptRndPeriod; //!< Set period for adaptive rounding of JVT-N011 in MBs
int AdaptRndChroma;
int AdaptRndWFactor[2][5]; //!< Weighting factors for luma component based on reference indicator and slice type
int AdaptRndCrWFactor[2][5]; //!< Weighting factors for chroma components based on reference indicator and slice type
// Fast Mode Decision
int EarlySkipEnable;
int SelectiveIntraEnable;
int DisposableP;
int DispPQPOffset;
//Redundant picture
int NumRedundantHierarchy; //!< number of entries to allocate redundant pictures in a GOP
int PrimaryGOPLength; //!< GOP length of primary pictures
int NumRefPrimary; //!< number of reference frames for primary picture
// Chroma interpolation and buffering
int ChromaMCBuffer;
int ChromaMEEnable;
int MEErrorMetric[3];
int ModeDecisionMetric;
} InputParameters;
//! ImageParameters
typedef struct
int number; //!< current image number to be encoded
int pn; //!< picture number
int LevelIndex; //!< mapped level idc
int current_mb_nr;
int current_slice_nr;
int type;
int structure; //!< picture structure
int num_ref_frames; //!< number of reference frames to be used
int max_num_references; //!< maximum number of reference pictures that may occur
int qp; //!< quant for the current frame
int qpsp; //!< quant for the prediction frame of SP-frame
int qp_scaled;
float framerate;
int width; //!< Number of pels
int width_padded; //!< Width in pels of padded picture
int width_blk; //!< Number of columns in blocks
int width_cr; //!< Number of pels chroma
int height; //!< Number of lines
int height_padded; //!< Number in lines of padded picture
int height_blk; //!< Number of lines in blocks
int height_cr; //!< Number of lines chroma
int height_cr_frame; //!< Number of lines chroma frame
int size; //!< Luma Picture size in pels
int size_cr; //!< Chroma Picture size in pels
int subblock_x; //!< current subblock horizontal
int subblock_y; //!< current subblock vertical
int is_intra_block;
int is_v_block;
int mb_y_upd;
int mb_y_intra; //!< which GOB to intra code
int block_c_x; //!< current block chroma vertical
signed char **ipredmode; //!< intra prediction mode
signed char **ipredmode8x8; //!< help storage for 8x8 modes, inserted by YV
int cod_counter; //!< Current count of number of skipped macroblocks in a row
int ***nz_coeff; //!< number of coefficients per block (CAVLC)
int mb_x; //!< current MB horizontal
int mb_y; //!< current MB vertical
int block_x; //!< current block horizontal
int block_y; //!< current block vertical
int pix_x; //!< current pixel horizontal
int pix_y; //!< current pixel vertical
int pix_c_x; //!< current pixel chroma horizontal
int pix_c_y; //!< current pixel chroma vertical
int opix_x; //!< current original picture pixel horizontal
int opix_y; //!< current original picture pixel vertical
int opix_c_x; //!< current original picture pixel chroma horizontal
int opix_c_y; //!< current original picture pixel chroma vertical
// some temporal buffers
imgpel mprr[9][16][16]; //!< all 9 prediction modes? // enlarged from 4 to 16 for ABT (is that neccessary?)
imgpel mprr_2[5][16][16]; //!< all 4 new intra prediction modes
imgpel mprr_3[9][8][8]; //!< all 9 prediction modes for 8x8 transformation
imgpel mprr_c[2][4][16][16]; //!< chroma intra prediction modes
imgpel mpr[16][16]; //!< current best prediction mode
int m7[16][16]; //!< the diff pixel values between orginal image and prediction
int ****cofAC; //!< AC coefficients [8x8block][4x4block][level/run][scan_pos]
int ***cofDC; //!< DC coefficients [yuv][level/run][scan_pos]
int ***fadjust4x4; //!< Transform coefficients for 4x4 luma. Excludes DC for I16x16
int ***fadjust8x8; //!< Transform coefficients for 8x8 luma
int ****fadjust4x4Cr; //!< Transform coefficients for 4x4 chroma. Excludes DC chroma.
int ****fadjust8x8Cr; //!< Transform coefficients for 4x4 chroma within 8x8 inter blocks.
Picture *currentPicture; //!< The coded picture currently in the works (typically frame_pic, top_pic, or bottom_pic)
Slice *currentSlice; //!< pointer to current Slice data struct
Macroblock *mb_data; //!< array containing all MBs of a whole frame
int *quad; //!< Array containing square values,used for snr computation */ /* Values are limited to 5000 for pixel differences over 70 (sqr(5000)).
int *intra_block;
int tr;
int fld_type; //!< top or bottom field
unsigned int fld_flag;
unsigned int rd_pass;
int direct_intraP_ref[4][4];
int pstruct_next_P;
int imgtr_next_P_frm;
int imgtr_last_P_frm;
int imgtr_next_P_fld;
int imgtr_last_P_fld;
// B pictures
double b_interval;
int p_interval;
int b_frame_to_code;
int fw_mb_mode;
int bw_mb_mode;
short****** pred_mv; //!< motion vector predictors for all block types and all reference frames
short****** all_mv; //!< replaces local all_mv
short****** bipred_mv1; //!< Biprediction MVs
short****** bipred_mv2; //!< Biprediction MVs
short bi_pred_me[MAXMODE];
int LFDisableIdc;
int LFAlphaC0Offset;
int LFBetaOffset;
int direct_spatial_mv_pred_flag; //!< Direct Mode type to be used (0: Temporal, 1: Spatial)
int num_ref_idx_l0_active;
int num_ref_idx_l1_active;
int field_mode; //!< For MB level field/frame -- field mode on flag
int top_field; //!< For MB level field/frame -- top field flag
int buf_cycle;
int i16offset;
int layer; //!< which layer this picture belonged to
int old_layer; //!< old layer number
int NoResidueDirect;
int AdaptiveRounding; //!< Adaptive Rounding parameter based on JVT-N011
int redundant_pic_cnt; // JVT-D101
int MbaffFrameFlag; //!< indicates frame with mb aff coding
//the following should probably go in sequence parameters
unsigned int pic_order_cnt_type;
// for poc mode 1
Boolean delta_pic_order_always_zero_flag;
int offset_for_non_ref_pic;
int offset_for_top_to_bottom_field;
unsigned int num_ref_frames_in_pic_order_cnt_cycle;
int offset_for_ref_frame[1];
//the following is for slice header syntax elements of poc
// for poc mode 0.
unsigned int pic_order_cnt_lsb;
int delta_pic_order_cnt_bottom;
// for poc mode 1.
int delta_pic_order_cnt[2];
unsigned int field_picture;
signed int toppoc; //!< poc for this frame or field
signed int bottompoc; //!< for completeness - poc of bottom field of a frame (always = poc+1)
signed int framepoc; //!< min (toppoc, bottompoc)
signed int ThisPOC; //!< current picture POC
unsigned int frame_num; //!< frame_num for this frame
unsigned int PicWidthInMbs;
unsigned int PicHeightInMapUnits;
unsigned int FrameHeightInMbs;
unsigned int PicSizeInMbs;
unsigned int FrameSizeInMbs;
//the following should probably go in picture parameters
Boolean pic_order_present_flag; // ????????
//the following are sent in the slice header
// int delta_pic_order_cnt[2];
int nal_reference_idc;
int adaptive_ref_pic_buffering_flag;
int no_output_of_prior_pics_flag;
int long_term_reference_flag;
DecRefPicMarking_t *dec_ref_pic_marking_buffer;
int model_number;
// rate control variables
int NumberofCodedMacroBlocks;
int BasicUnitQP;
int NumberofMBTextureBits;
int NumberofMBHeaderBits;
unsigned int BasicUnit;
int write_macroblock;
int bot_MB;
int write_mbaff_frame;
int DeblockCall;
int last_pic_bottom_field;
int last_has_mmco_5;
int pre_frame_num;
int slice_group_change_cycle;
int pic_unit_size_on_disk;
int bitdepth_luma;
int bitdepth_chroma;
int bitdepth_luma_qp_scale;
int bitdepth_chroma_qp_scale;
int bitdepth_lambda_scale;
int max_bitCount;
int max_qp_delta;
int min_qp_delta;
// Lagrangian Parameters
double **lambda_md; //!< Mode decision Lambda
double ***lambda_me; //!< Motion Estimation Lambda
int ***lambda_mf; //!< Integer formatted Motion Estimation Lambda
double **lambda_mf_factor; //!< Motion Estimation Lamda Scale Factor
unsigned int dc_pred_value_luma; //!< luma value for DC prediction (depends on luma pel bit depth)
unsigned int dc_pred_value_chroma; //!< chroma value for DC prediction (depends on chroma pel bit depth)
int max_imgpel_value; //!< max value that one picture element (pixel) can take (depends on pic_unit_bitdepth)
int max_imgpel_value_uv;
int num_blk8x8_uv;
int num_cdc_coeff;
int yuv_format;
int lossless_qpprime_flag;
int mb_cr_size_x;
int mb_cr_size_y;
int mb_size[3][2];
int chroma_qp_offset[2]; //!< offset for qp for chroma [0-Cb, 1-Cr]
int auto_crop_right;
int auto_crop_bottom;
short checkref;
int last_valid_reference;
int bytes_in_picture;
int AverageFrameQP;
int SumFrameQP;
int GopLevels;
} ImageParameters;
#define NUM_PIC_TYPE 5
//!< statistics
typedef struct
int quant0; //!< quant for the first frame
int quant1; //!< average quant for the remaining frames
float bitr; //!< bit rate for current frame, used only for output til terminal
float bitrate; //!< average bit rate for the sequence except first frame
int64 bit_ctr; //!< counter for bit usage
int64 bit_ctr_n; //!< bit usage for the current frame
int bit_slice; //!< number of bits in current slice
int stored_bit_slice; //!< keep number of bits in current slice (to restore status in case of MB re-encoding)
int bit_ctr_emulationprevention; //!< stored bits needed to prevent start code emulation
int b8_mode_0_use[NUM_PIC_TYPE][2];
int mode_use_transform_8x8[NUM_PIC_TYPE][MAXMODE];
int mode_use_transform_4x4[NUM_PIC_TYPE][MAXMODE];
int intra_chroma_mode[4];
// B pictures
int successive_Bframe;
int *mode_use_Bframe;
int *bit_use_mode_Bframe;
int64 bit_ctr_I;
int64 bit_ctr_P;
int64 bit_ctr_B;
float bitrate_I;
float bitrate_P;
float bitrate_B;
int64 mode_use [NUM_PIC_TYPE][MAXMODE]; //!< Macroblock mode usage for Intra frames
int64 bit_use_mode [NUM_PIC_TYPE][MAXMODE]; //!< statistics of bit usage
int64 bit_use_stuffingBits[NUM_PIC_TYPE];
int64 bit_use_mb_type [NUM_PIC_TYPE];
int64 bit_use_header [NUM_PIC_TYPE];
int64 tmp_bit_use_cbp [NUM_PIC_TYPE];
int64 bit_use_coeffY [NUM_PIC_TYPE];
int64 bit_use_coeffC [NUM_PIC_TYPE];
int64 bit_use_delta_quant [NUM_PIC_TYPE];
int em_prev_bits_frm;
int em_prev_bits_fld;
int *em_prev_bits;
int bit_ctr_parametersets;
int bit_ctr_parametersets_n;
} StatParameters;
//! For MB level field/frame coding tools
//! temporary structure to store MB data for field/frame coding
typedef struct
double min_rdcost;
imgpel rec_mbY[16][16]; // hold the Y component of reconstructed MB
imgpel rec_mbU[16][16], rec_mbV[16][16];
int ****cofAC;
int ***cofDC;
int mb_type;
short bi_pred_me;
int b8mode[4], b8pdir[4];
signed char **ipredmode;
signed char intra_pred_modes[16];
signed char intra_pred_modes8x8[16];
int cbp;
int64 cbp_blk;
int mode;
short ******pred_mv; //!< predicted motion vectors
short ******all_mv; //!< all modes motion vectors
signed char refar[2][4][4];//!< reference frame array [list][y][x]
int i16offset;
int c_ipred_mode;
int luma_transform_size_8x8_flag;
int NoMbPartLessThan8x8Flag;
int qp;
int prev_qp;
int prev_delta_qp;
int delta_qp;
int prev_cbp;
//! Set Explicit GOP Parameters.
//! Currently only supports Enhancement GOP but could be easily extended
typedef struct
int slice_type; //! Slice type
int display_no; //! GOP Display order
int reference_idc; //! Is reference?
int slice_qp; //! Assigned QP
int hierarchy_layer; //! Hierarchy layer (used with GOP Hierarchy option 2)
int hierarchyPocDelta; //! Currently unused
typedef struct
int cost8x8;
int rec_resG_8x8[16][16];
int resTrans_R_8x8[16][16];
int resTrans_B_8x8[16][16];
int mprRGB_8x8[3][16][16];
short part8x8mode[4];
signed char part8x8pdir[4];
signed char part8x8fwref[4];
signed char part8x8bwref[4];
imgpel rec_mbY8x8[16][16];
imgpel mpr8x8[16][16];
int lrec[16][16]; // transform and quantized coefficients will be stored here for SP frames
} RD_8x8DATA;
typedef struct
double lambda_md; //!< Mode decision Lambda
double lambda_me[3]; //!< Motion Estimation Lambda
int lambda_mf[3]; //!< Integer formatted Motion Estimation Lambda
short valid[MAXMODE];
short list_offset[2];
short curr_mb_field;
short best_ref[2];
int best_mcost[2];
GOP_DATA *gop_structure;
RD_DATA *rdopt;
RD_DATA rddata_top_frame_mb, rddata_bot_frame_mb; //!< For MB level field/frame coding tools
RD_DATA rddata_top_field_mb, rddata_bot_field_mb; //!< For MB level field/frame coding tools
extern InputParameters *input;
extern ImageParameters *img;
extern StatParameters *stats;
extern SNRParameters *snr;
// files
FILE *p_stat; //!< status file for the last encoding session
FILE *p_log; //!< SNR file
FILE *p_trace; //!< Trace file
int p_in; //!< original YUV file handle
int p_dec; //!< decoded image file handle
* P r o t o t y p e s f o r T M L
void intrapred_luma(int CurrPixX,int CurrPixY, int *left_available, int *up_available, int *all_available);
int dct_luma(int pos_mb1,int pos_mb2,int *cnt_nonz, int intra);
int dct_luma_sp(int pos_mb1,int pos_mb2,int *cnt_nonz);
void copyblock_sp(int pos_mb1,int pos_mb2);
int dct_chroma(int uv,int i11);
int dct_chroma_sp(int uv,int i11);
void intrapred_luma_16x16(void);
int dct_luma_16x16(int);
void init_poc(void);
void init_img(void);
void report(void);
int get_picture_type(void);
void DeblockFrame(ImageParameters *img, imgpel **, imgpel ***) ;
int distortion4x4(int*);
int distortion8x8(int*);
extern int* refbits;
extern int**** motion_cost;
double *mb16x16_cost_frame;
void Get_Direct_Motion_Vectors (void);
void PartitionMotionSearch (int, int, int*);
int BIDPartitionCost (int, int, short, short, int);
int writeAbpCoeffIndex (int, int, int, int);
void estimate_weighting_factor_B_slice(void);
void estimate_weighting_factor_P_slice(int offset);
int test_wp_P_slice(int offset);
int test_wp_B_slice(int method);
void poc_based_ref_management(int current_pic_num);
int picture_coding_decision (Picture *picture1, Picture *picture2, int qp);
unsigned CeilLog2( unsigned uiVal);
int GetDirectCost8x8 (int, int*);
int BPredPartitionCost (int, int, short, short, int, int);
int GetDirectCostMB (void);
int GetSkipCostMB (void);
void FindSkipModeMotionVector (void);
// dynamic mem allocation
int init_global_buffers(void);
void free_global_buffers(void);
void no_mem_exit (char *where);
int get_mem_mv (short*******);
void free_mem_mv (short******);
void free_img (void);
int get_mem_ACcoeff (int*****);
int get_mem_DCcoeff (int****);
void free_mem_ACcoeff (int****);
void free_mem_DCcoeff (int***);
int decide_fld_frame(float snr_frame_Y, float snr_field_Y, int bit_field, int bit_frame, double lambda_picture);
void combine_field(void);
Picture *malloc_picture(void);
void free_picture (Picture *pic);
int encode_one_slice(int SLiceGroupId, Picture *pic, int TotalCodedMBs); //! returns the number of MBs in the slice
void free_slice_list(Picture *currPic);
void report_stats_on_error(void);
void trace2out(SyntaxElement *se);
void trace2out_cabac(SyntaxElement *se);
void error(char *text, int code);
int start_sequence(void);
int rewrite_paramsets(void);
int terminate_sequence(void);
int start_slice(void);
int terminate_slice(int);
int write_PPS(int, int);
// B pictures
int get_fwMV(int *min_fw_sad, int tot_intra_sad);
void get_bwMV(int *min_bw_sad);
void get_bid(int *bid_sad, int fw_predframe_no);
void get_dir(int *dir_sad);
void compare_sad(int tot_intra_sad, int fw_sad, int bw_sad, int bid_sad, int dir_sad, int);
int BlkSize2CodeNumber(int blc_size_h, int blc_size_v);
void InitMotionVectorSearchModule(void);
int field_flag_inference(void);
void set_mbaff_parameters(void); // For MB AFF
void writeVlcByteAlign(Bitstream* currStream);
int writeMB_bits_for_4x4_luma (int, int, int);
int writeMB_bits_for_16x16_luma (void);
int writeMB_bits_for_luma (int);
int writeMB_bits_for_DC_chroma (int);
int writeMB_bits_for_AC_chroma (int);
int writeMB_bits_for_CBP (void);
int SingleUnifiedMotionSearch (int, int, int**, int***, int*****, int, int*****, double);
//============= rate-distortion optimization ===================
void clear_rdopt (void);
void init_rdopt (void);
void RD_Mode_Decision (void);
//============= rate-distortion opt with packet losses ===========
void decode_one_macroblock(void);
void decode_one_mb (int, Macroblock*);
void decode_one_b8block (int, int, int, int, int);
void Get_Reference_Block(imgpel **imY, int block_y, int block_x, int mvhor, int mvver, imgpel **out);
byte Get_Reference_Pixel(imgpel **imY, int y, int x);
int Half_Upsample(imgpel **imY, int j, int i);
void DecOneForthPix(imgpel **dY, imgpel ***dref);
void compute_residue(int mode);
void compute_residue_b8block (int, int);
void compute_residue_mb (int);
void UpdateDecoders(void);
void Build_Status_Map(byte **s_map);
void Error_Concealment(imgpel **inY, byte **s_map, imgpel ***refY);
void Conceal_Error(imgpel **inY, int mb_y, int mb_x, imgpel ***refY, byte **s_map);
//============= restriction of reference frames based on the latest intra-refreshes==========
void UpdatePixelMap(void);
//============= fast full integer search =======================
void ClearFastFullIntegerSearch (void);
void ResetFastFullIntegerSearch (void);
void process_2nd_IGOP(void);
void SetImgType(void);
// Tian Dong: for IGOPs
extern Boolean In2ndIGOP;
extern int start_frame_no_in_this_IGOP;
extern int start_tr_in_this_IGOP;
extern int FirstFrameIn2ndIGOP;
#define IMG_NUMBER (img->number - start_frame_no_in_this_IGOP)
void AllocNalPayloadBuffer(void);
void FreeNalPayloadBuffer(void);
void SODBtoRBSP(Bitstream *currStream);
int RBSPtoEBSP(byte *streamBuffer, int begin_bytepos, int end_bytepos, int min_num_bytes);
int Bytes_After_Header;
// Fast ME enable
int BlockMotionSearch (short,int,int,int,int,int, int*);
void low_complexity_encode_md (void);
void encode_one_macroblock_low (void);
void encode_one_macroblock_high (void);
void encode_one_macroblock_highfast (void);
void encode_one_macroblock_highloss (void);
void (*encode_one_macroblock) (void);
void set_chroma_qp(Macroblock *currMB);
#include "context_ini.h"
void store_coding_state_cs_cm(void);
void reset_coding_state_cs_cm(void);
int writeIPCMBytes(Bitstream *currStream);
int writePCMByteAlign(Bitstream *currStream);
int dct_luma_sp2(int pos_mb1,int pos_mb2,int *cnt_nonz);
int dct_chroma_sp2(int ,int);
int check_for_SI16(void);
int **lrec ;
int ***lrec_uv;
int si_frame_indicator;
int sp2_frame_indicator;
int number_sp2_frames;
//#define sp_output_indicator 0 //will be in the config file
//#define sp_output_filename "sp_stored.txt" // will be in the config file
void output_SP_coefficients(void);
void read_SP_coefficients(void);
int giRDOpt_B8OnlyFlag;
int gaaiMBAFF_NZCoeff[4][12];
// Redundant picture
imgpel **imgY_tmp;
imgpel **imgUV_tmp[2];
int frameNuminGOP;
int redundant_coding;
int key_frame;
int redundant_ref_idx;
void Init_redundant_frame(void);
void Set_redundant_frame(void);
void encode_one_redundant_frame(void);
int img_pad_size_uv_x;
int img_pad_size_uv_y;
unsigned char chroma_mask_mv_y;
unsigned char chroma_mask_mv_x;
int chroma_shift_y, chroma_shift_x;
int shift_cr_x, shift_cr_y;
int img_padded_size_x;
int img_cr_padded_size_x;
// struct with pointers to the sub-images
typedef struct {
imgpel ****luma; // component 0 (usually Y, X, or R)
imgpel ****crcb[2]; // component 2 (usually U/V, Y/Z, or G/B)
} SubImageContainer;
int start_me_refinement_hp; // if set then recheck the center position when doing half-pel motion refinement
int start_me_refinement_qp; // if set then recheck the center position when doing quarter-pel motion refinement