📄 global.h
字号:
struct macroblock *mb_available[3][3]; /*!< pointer to neighboring MBs in a 3x3 window of current MB, which is located at [1][1] \n
NULL pointer identifies neighboring MBs which are unavailable */
struct macroblock *field_available[2];
// some storage of macroblock syntax elements for global access
int mb_type;
int mvd[2][BLOCK_MULTIPLE][BLOCK_MULTIPLE][2]; //!< indices correspond to [forw,backw][block_y][block_x][x,y]
int intra_pred_modes[BLOCK_MULTIPLE*BLOCK_MULTIPLE];
int cbp ;
int cbp_blk ; //!< 1 bit set for every 4x4 block with coefs (not implemented for INTRA)
int b8mode[4];
int b8pdir[4];
unsigned long cbp_bits;
int lf_disable;
int lf_alpha_c0_offset;
int lf_beta_offset;
int c_ipred_mode; //!< chroma intra prediction mode
int IntraChromaPredModeFlag;
int mb_field;
int nbmv[4][2];
} 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
// int tmp_byte_pos; //!< temp storage for position in bitstream
// int last_startcode; //!< location of last valid startcode
} Bitstream;
//! DataPartition
typedef struct datapartition
{
Bitstream *bitstream;
// Bitstream *bitstream_frm; //!< frame stream buffer
// Bitstream *bitstream_topfld; //!< field stream buffer
// Bitstream *bitstream_botfld; //!< field stream buffer
EncodingEnvironment ee_cabac;
int (*writeSyntaxElement)(SyntaxElement *, struct datapartition *);
/*!< virtual function;
actual method depends on chosen data partition and
entropy coding method */
} 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 write_is_real;//GB
int field_ctx[3][2]; //GB
} Slice;
#define MAXSLICEPERPICTURE 100
typedef struct
{
int no_slices;
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;
unsigned int toprefpoc[MAX_NO_POC_FRAMES];
unsigned int bottomrefpoc[MAX_NO_POC_FRAMES];
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_frm; //!< Encoded luma images
byte ***imgUV_frm; //!< Encoded croma images
byte **imgY_org_frm; //!< Reference luma image
byte ***imgUV_org_frm; //!< Reference croma image
int ***tmp_mv_frm; //!< motion vector buffer
int **refFrArr_frm; //!< Array for reference frames of each block
byte **imgY; //!< Encoded luma images
byte ***imgUV; //!< Encoded croma images
byte **imgY_org; //!< Reference luma image
byte ***imgUV_org; //!< Reference croma image
//int **refFrArr; //!< Array for reference frames of each block
byte **imgY_pf; //!< Post filter luma image
byte ***imgUV_pf; //!< Post filter croma image
byte ***mref; //!< 1/4 pix luma
byte ***mref_w; //!< 1/4 pix luma for weighted prediction ME
byte ****mcef; //!< pix chroma
_int16 **img4Y_tmp; //!< for quarter pel interpolation
int ***tmp_mv; //!< motion vector buffer
int **moving_block; //!< stationary block buffer
int **moving_block_frm; //!< stationary block buffer - frame
int **moving_block_top; //!< stationary block buffer - field
int **moving_block_bot; //!< stationary block buffer - field
int **refFrArr; //!< Array for reference frames of each block
// B pictures
// motion vector : forward, backward, direct
int ***tmp_fwMV;
int ***tmp_bwMV;
int ***tmp_fwMV_top; //!< For MB level field/frame coding tools
int ***tmp_fwMV_bot; //!< For MB level field/frame coding tools
int ***tmp_bwMV_top; //!< For MB level field/frame coding tools
int ***tmp_bwMV_bot; //!< For MB level field/frame coding tools
int **field_mb; //!< For MB level field/frame coding tools
int mb_adaptive; //!< For MB level field/frame coding tools
int MBPairIsField; //!< For MB level field/frame coding tools
int WriteFrameFieldMBInHeader; //! For MB level field/frame coding tools
int ***dfMV;
int ***dbMV;
int **fw_refFrArr;
int **bw_refFrArr;
byte **nextP_imgY;
byte ***nextP_imgUV;
pel_t ***Refbuf11; //!< 1/1th pel (full pel) reference frame buffer
pel_t **Refbuf11_w; // for weighted reference frame buffer
//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 **weight; // weight in [refbuf][component] order, because JM currently uses one list for fwd and bwd ref pics
int **offset; // offset in [refbuf][component] order, because JM currently uses one list for fwd and bwd ref pics
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 ***imgUV_org_top;
byte **imgY_org_bot;
byte ***imgUV_org_bot;
byte **imgY_top; //!< Encoded luma images
byte ***imgUV_top; //!< Encoded croma images
byte **imgY_bot; //!< Encoded luma images
byte ***imgUV_bot; //!< Encoded croma images
byte **imgY_com; //!< Encoded luma images
byte ***imgUV_com; //!< Encoded croma images
pel_t ***Refbuf11_fld; //!< 1/1th pel (full pel) reference frame buffer
pel_t **Refbuf11_fld_w; //!< 1/1th pel (full pel) reference frame buffer
int **refFrArr_top; //!< Array for reference frames of each block
int **refFrArr_bot; //!< Array for reference frames of each block
// int **refFrArr_top_save; //!< For MB level field/frame coding tools
// int **refFrArr_bot_save; //!< For MB level field/frame coding tools
int *parity_fld;
// global picture format dependend buffers, mem allocation in image.c (field picture)
byte ***mref_fld; //!< 1/4 pix luma
byte ***mref_fld_w; //!< 1/4 pix luma for wp
byte ****mcef_fld; //!< pix chroma
byte ***mref_mbfld; //!< For MB level field/frame coding tools
byte ***mref_mbfld_w; //!< For MB level field/frame coding tools for wp
// global picture format dependend buffers, mem allocation in image.c (frame buffer)
byte ***mref_frm; //!< 1/4 pix luma
byte ***mref_frm_w; //!< 1/4 pix luma
byte ****mcef_frm; //!< pix chroma
// B pictures
// motion vector : forward, backward, direct
int **fw_refFrArr_top;
int **bw_refFrArr_top;
int **fw_refFrArr_bot;
int **bw_refFrArr_bot;
int ***tmp_mv_top; //!< motion vector buffer
int ***tmp_mv_bot; //!< motion vector buffer
// int ***tmp_mv_top_save; //!< motion vector buffer for MB level field/frame coding tools
// int ***tmp_mv_bot_save; //!< motion vector buffer for MB level field/frame coding tools
int **fwdir_refFrArr; //!< direct mode forward reference buffer
int **bwdir_refFrArr; //!< direct mode backward reference buffer
// global picture format dependend buffers, mem allocation in image.c (frame buffer)
byte **imgY_org_frm;
byte ***imgUV_org_frm;
byte **imgY_frm; //!< Encoded luma images
byte ***imgUV_frm; //!< Encoded croma images
pel_t ***Refbuf11_frm; //!< 1/1th pel (full pel) reference frame buffer
pel_t **Refbuf11_frm_w; //!< 1/1th pel (full pel) reference frame buffer
int **refFrArr_frm; //!< Array for reference frames of each block
int direct_mode;
int TopFieldIsSkipped, TopFrameIsSkipped; //!< Flag to prevent bottom MB in a field MB pair to be skipped
//!< if the top MB is skipped
// B pictures
// motion vector : forward, backward, direct
int **fw_refFrArr_frm;
int **bw_refFrArr_frm;
// 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()
int **abp_type_FrArr; //!< Array for abp_type of each block
int **abp_type_FrArr_top;
int **abp_type_FrArr_bot;
//! 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 no_frames; //!< number of frames to be encoded
int no_fields; //!< number of fields 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 no_multpred; /*!< 1: prediction from the last frame only. 2: prediction from the last or
second last frame etc. Maximum 5 frames */
int img_width; //!< GH: if CUSTOM image format is chosen, use this size
int img_height; //!< GH: width and 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
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -