📄 global.h
字号:
} 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
// !KS: RMPNI buffer should be retired. just do some sore simple stuff
RMPNIbuffer_t *rmpni_buffer; //!< stores the slice temporary buffer remapping commands
int ref_pic_list_reordering_flag_l0;
int *remapping_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 *remapping_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;
#define MAXSLICEPERPICTURE 100
typedef struct
{
int no_slices;
int idr_flag;
Slice *slices[MAXSLICEPERPICTURE];
int bits_per_picture;
float distortion_y;
float distortion_u;
float distortion_v;
} Picture;
Picture *top_pic;
Picture *bottom_pic;
Picture *frame_pic;
typedef struct
{
// Size info
int x_size, y_framesize, y_fieldsize;
char *yf, *uf, *vf; //!< frame representation
char *yt, *ut, *vt; //!< top field
char *yb, *ub, *vb; //!< bottom field
} Sourceframe;
// global picture format dependend buffers, mem allocation in image.c
byte **imgY_org; //!< Reference luma image
byte ***imgUV_org; //!< Reference croma image
//int **refFrArr; //!< Array for reference frames of each block
int **img4Y_tmp; //!< for quarter pel interpolation
unsigned int log2_max_frame_num_minus4;
unsigned int log2_max_pic_order_cnt_lsb_minus4;
int me_tot_time,me_time;
pic_parameter_set_rbsp_t *active_pps;
seq_parameter_set_rbsp_t *active_sps;
// 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)
byte **imgY_org_top;
byte **imgY_org_bot;
byte ***imgUV_org_top;
byte ***imgUV_org_bot;
byte **imgY_org_frm;
byte ***imgUV_org_frm;
byte **imgY_com; //!< Encoded luma images
byte ***imgUV_com; //!< Encoded croma images
int ***direct_ref_idx; //!< direct mode reference index buffer
int **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 Bframe_ctr, frame_no, nextP_tr_fld, nextP_tr_frm;
int tot_time;
#define ET_SIZE 300 //!< size of error text buffer
char errortext[ET_SIZE]; //!< buffer for error message for exit with error()
//! Info for the "decoders-in-the-encoder" used for rdoptimization with packet losses
typedef struct
{
int **resY; //!< Residue of Luminance
byte ***decY; //!< Decoded values at the simulated decoders
byte ****decref; //!< Reference frames of the simulated decoders
byte ***decY_best; //!< Decoded frames for the best mode for all decoders
byte **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_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
} SNRParameters;
//! all input parameters
typedef struct
{
int ProfileIDC; //!< profile idc
int LevelIDC; //!< 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 hadamard; /*!< 0: 'normal' SAD in 1/3 pixel search. 1: use 4x4 Haphazard transform and '
Sum of absolute transform difference' in 1/3 pixel search */
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_reference_frames; //!< number of reference frames to be used
int P_List0_refs;
int B_List0_refs;
int B_List1_refs;
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; //!< GH: YUV format (0=4:0:0, 1=4:2:0, 2=4:2:2, 3=4:4:4,currently only 4:2:0 is supported)
int color_depth; //!< GH: YUV color depth per component in bit/pel (currently only 8 bit/pel is supported)
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 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[100]; //!< YUV 4:2:0 input format
char outfile[100]; //!< H.264 compressed output bitstream
char ReconFile[100]; //!< Reconstructed Pictures
char TraceFile[100]; //!< Trace Outputs
int intra_period; //!< Random Access period though intra
int idr_enable; //!< Encode intra slices as IDR
int start_frame; //!< Encode sequence starting from Frame start_frame
// B pictures
int successive_Bframe; //!< number of B frames that will be used
int qpB; //!< QP of B frames
int direct_type; //!< Direct Mode type to be used (0: Temporal, 1: Spatial)
int directInferenceFlag; //!< Direct Inference Flag
// 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 WeightedPrediction; //!< Weighted prediciton for P frames (0: not used, 1: explicit)
int WeightedBiprediction; //!< Weighted prediciton for B frames (0: not used, 1: explicit, 2: implicit)
int StoredBPictures; //!< Stored (Reference) B pictures replace P pictures (0: not used, 1: used)
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;
char PictureTypeSequence[MAXPICTURETYPESEQUENCELEN];
int FrameRate;
int chroma_qp_index_offset;
#ifdef _FULL_SEARCH_RANGE_
int full_search;
#endif
#ifdef _ADAPT_LAST_GROUP_
int last_frame;
#endif
#ifdef _CHANGE_QP_
int qpN2, qpB2, qp2start;
int qp02;
#endif
int rdopt;
#ifdef _LEAKYBUCKET_
int NumberLeakyBuckets;
char LeakyBucketRateFile[100];
char LeakyBucketParamFile[100];
#endif
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[100]; //!< 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;
int *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_slice_flag; //! whether redundant slices exist, JVT-D101
int pic_order_cnt_type; // POC200301
int context_init_method;
int model_number;
//! Rate Control on JVT standard
int RCEnable;
int bit_rate;
int SeinitialQP;
int basicunit;
int channel_type;
// FastME enable
int FMEnable;
} InputParameters;
//! ImageParameters
typedef struct
{
int number; //!< current image number to be encoded
int pn; //!< picture number
int nb_references;
int current_mb_nr;
int total_number_mb;
int current_slice_nr;
int type;
int structure; //!< picture structure
int num_reference_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 framerate;
int width; //!< Number of pels
int width_cr; //!< Number of pels chroma
int height; //!< Number of lines
int height_cr; //!< Number of lines chroma
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
int **ipredmode; //!< intra prediction mode
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
int mprr[9][16][16]; //!< all 9 prediction modes? // enlarged from 4 to 16 for ABT (is that neccessary?)
int mprr_2[5][16][16]; //!< all 4 new intra prediction modes
int mprr_c[2][4][8][8]; //!< new chroma 8x8 intra prediction modes
int 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]
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
SyntaxElement MB_SyntaxElements[MAX_SYMBOLS_PER_MB]; //!< temporal storage for all chosen syntax elements of one MB
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;
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
int b_interval;
int p_interval;
int b_frame_to_code;
int fw_mb_mode;
int bw_mb_mode;
int****** pred_mv; //!< motion vector predictors for all block types and all reference frames
int****** all_mv; //!< replaces local all_mv
int LFDisableIdc;
int LFAlphaC0Offset;
int LFBetaOffset;
int direct_type; //!< 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
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -