Compiler Explorer

Source code

#include <stdint.h>
#include <stdbool.h>

#define imgpel unsigned short
#define pel_t imgpel
#define int64 int64_t
#define byte unsigned char

typedef enum 
{
  BITS_HEADER,
  BITS_TOTAL_MB,
  BITS_MB_MODE,
  BITS_INTER_MB,
  BITS_CBP_MB,
  BITS_COEFF_Y_MB,
  BITS_COEFF_UV_MB,
  BITS_DELTA_QUANT_MB,
  MAX_BITCOUNTER_MB
} BitCountType;

#define BLOCK_SIZE      4
#define MB_BLOCK_SIZE   16
#define BLOCK_MULTIPLE      (MB_BLOCK_SIZE/BLOCK_SIZE)

typedef struct macroblock
{
  int                 currSEnr;                   //!< number of current syntax element
  int                 slice_nr;
  int                 delta_qp;
  int                 qp ;
  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 [forw,backw][block_y][block_x][x,y]
  int                 intra_pred_modes[BLOCK_MULTIPLE*BLOCK_MULTIPLE];
  int                 intra_pred_modes8x8[BLOCK_MULTIPLE*BLOCK_MULTIPLE];                             //!< 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];
  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 mbAddrA, mbAddrB, mbAddrC, mbAddrD;
  int mbAvailA, mbAvailB, mbAvailC, mbAvailD;

int                 all_blk_8x8;
  int                 luma_transform_size_8x8_flag;
  int                 NoMbPartLessThan8x8Flag;

#if BI_PREDICTION
  int    bi_pred_me;
#endif
  
  // 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;

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_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
  float 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 height_cr_frame;         //!< Number of lines  chroma frame
  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 **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]

// 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;                                
  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
#if BI_PREDICTION
  short****** bipred_mv1;              //!< Biprediction MVs
  short****** bipred_mv2;              //!< Biprediction MVs
  short bi_pred_me[MAXMODE];
#endif

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
#define MAX_REFERENCE_PICTURES 15
  int mvscale[6][MAX_REFERENCE_PICTURES];
  int buf_cycle;
  int i16offset;

int layer;             //!< which layer this picture belonged to
  int old_layer;         //!< old layer number
  int NoResidueDirect;

int redundant_pic_cnt; // JVT-D101

int MbaffFrameFlag;    //!< indicates frame with mb aff coding

//the following should probably go in sequence parameters
  // unsigned int log2_max_frame_num_minus4;
  unsigned int pic_order_cnt_type;
  // for poc mode 0, POC200301
  // unsigned int log2_max_pic_order_cnt_lsb_minus4;  
  // for poc mode 1, POC200301
  unsigned int 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];  // MAX_LENGTH_POC_CYCLE in decoder

// POC200301
  //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];

// POC200301
  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 PicWidthInMbs;
  unsigned PicHeightInMapUnits;
  unsigned FrameHeightInMbs;
  unsigned PicHeightInMbs;
  unsigned PicSizeInMbs;
  unsigned FrameSizeInMbs;

//the following should probably go in picture parameters
  unsigned int 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*/
  int NumberofHeaderBits; 
  int NumberofTextureBits;
  int NumberofBasicUnitHeaderBits;
  int NumberofBasicUnitTextureBits;
  double TotalMADBasicUnit;
  int NumberofMBTextureBits;
  int NumberofMBHeaderBits;
  int NumberofCodedBFrame; 
  int NumberofCodedPFrame;
  int NumberofGOP;
  int TotalQpforPPicture;
  int NumberofPPicture;
  double *MADofMB;
  int BasicUnitQP;
  int TopFieldFlag;
  int FieldControl;
  int FieldFrame;
  int Frame_Total_Number_MB;
  int IFLAG;
  int NumberofCodedMacroBlocks;
  int BasicUnit;
  int write_macroblock;
  int bot_MB;
  int write_macroblock_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;
  unsigned int dc_pred_value;   //!< value for DC prediction (depends on 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 chroma_qp_offset[2];      //!< offset for qp for chroma [0-Cb, 1-Cr]

// Residue Color Transform
  int residue_transform_flag;

int auto_crop_right;
  int auto_crop_bottom;

} ImageParameters;
extern ImageParameters *img;

#define Boolean bool
#define imgpel unsigned short
#define pel_t imgpel

typedef enum 
{
  P_SLICE = 0,
  B_SLICE,
  I_SLICE,
  SP_SLICE,
  SI_SLICE
} SliceType;

extern  int*   byte_abs;
int* spiral_search_x;
int* spiral_search_y;

/*static */int** max_search_range;
/*static */int  *****BlockSAD; 
/*static */int  **search_center_x;    //!< absolute search center for fast full motion search
/*static */int  **search_center_y;    //!< absolute search center for fast full motion search

#define MAX_LIST_SIZE 33
typedef enum 
{
  FRAME,
  TOP_FIELD,
  BOTTOM_FIELD
} PictureStructure;

typedef struct storable_picture
{
  PictureStructure structure;

int         poc;
  int         top_poc;
  int         bottom_poc;
  int         frame_poc;
  int         order_num;
  int64       ref_pic_num[6][MAX_LIST_SIZE];
  int64       frm_ref_pic_num[6][MAX_LIST_SIZE];
  int64       top_ref_pic_num[6][MAX_LIST_SIZE];
  int64       bottom_ref_pic_num[6][MAX_LIST_SIZE];
  unsigned    frame_num;
  int         pic_num;
  int         long_term_pic_num;
  int         long_term_frame_idx;

int         is_long_term;
  int         used_for_reference;
  int         is_output;
  int         non_existing;

int         size_x, size_y, size_x_cr, size_y_cr;
  int         chroma_vector_adjustment;
  int         coded_frame;
  int         MbaffFrameFlag;

imgpel **   imgY;          //!< Y picture component
  imgpel *    imgY_11;       //!< Y picture component with padded borders
  imgpel *    imgY_11_w;     //!< Y picture component with padded borders for weighted prediction
  imgpel **   imgY_ups;      //!< Y picture component upsampled (Quarter pel)
  imgpel **   imgY_ups_w;    //!< Y picture component upsampled (Quarter pel) for weighted prediction
  imgpel ***  imgUV;         //!< U and V picture components

byte *      mb_field;      //!< field macroblock indicator

short ***   ref_idx;       //!< reference picture   [list][subblock_x][subblock_y]

int64 ***   ref_pic_id;    //!< reference picture identifier [list][subblock_x][subblock_y]
                             //   (not  simply index)

int64 ***   ref_id;    //!< reference picture identifier [list][subblock_x][subblock_y]
                             //   (not  simply index)

short ****  mv;            //!< motion vector       [list][subblock_x][subblock_y][component]
  
  byte **     moving_block;
  byte **     field_frame;         //!< indicates if co_located is field or frame.
  
  struct storable_picture *top_field;     // for mb aff, if frame for referencing the top field
  struct storable_picture *bottom_field;  // for mb aff, if frame for referencing the bottom field
  struct storable_picture *frame;         // for mb aff, if field for referencing the combined frame

int         chroma_format_idc;
  int         frame_mbs_only_flag;
  int         frame_cropping_flag;
  int         frame_cropping_rect_left_offset;
  int         frame_cropping_rect_right_offset;
  int         frame_cropping_rect_top_offset;
  int         frame_cropping_rect_bottom_offset;
} StorablePicture;

StorablePicture **listX[6];
static pel_t *(*PelYline_11) (pel_t *, int, int, int, int);
pel_t *FastLine16Y_11 (pel_t *Pic, int y, int x, int height, int width);
pel_t *UMVLine16Y_11 (pel_t *Pic, int y, int x, int height, int width);

#define MAXnum_slice_groups_minus1  8
typedef struct
{
  Boolean   Valid;                  // indicates the parameter set is valid
  unsigned  pic_parameter_set_id;                             // ue(v)
  unsigned  seq_parameter_set_id;                             // ue(v)
  Boolean   entropy_coding_mode_flag;                         // u(1)

Boolean   transform_8x8_mode_flag;                          // u(1)
  Boolean   pic_scaling_matrix_present_flag;                  // u(1)
  int       pic_scaling_list_present_flag[8];                 // u(1)

// if( pic_order_cnt_type < 2 )  in the sequence parameter set
  Boolean      pic_order_present_flag;                           // u(1)
  unsigned  num_slice_groups_minus1;                          // ue(v)
    unsigned  slice_group_map_type;                        // ue(v)
    // if( slice_group_map_type = = 0 )
      unsigned  run_length_minus1[MAXnum_slice_groups_minus1]; // ue(v)
    // else if( slice_group_map_type = = 2 )
      unsigned  top_left[MAXnum_slice_groups_minus1];         // ue(v)
      unsigned  bottom_right[MAXnum_slice_groups_minus1];     // ue(v)
    // else if( slice_group_map_type = = 3 || 4 || 5
      Boolean   slice_group_change_direction_flag;            // u(1)
      unsigned  slice_group_change_rate_minus1;               // ue(v)
    // else if( slice_group_map_type = = 6 )
      unsigned  pic_size_in_map_units_minus1;	                // ue(v)
      byte      *slice_group_id;                              // complete MBAmap u(v)
			
  int       num_ref_idx_l0_active_minus1;                     // ue(v)
  int       num_ref_idx_l1_active_minus1;                     // ue(v)
  Boolean   weighted_pred_flag;                               // u(1)
  unsigned  weighted_bipred_idc;                              // u(2)
  int       pic_init_qp_minus26;                              // se(v)
  int       pic_init_qs_minus26;                              // se(v)
  int       chroma_qp_index_offset;                           // se(v)

int       cb_qp_index_offset;                               // se(v)
  int       cr_qp_index_offset;                               // se(v)

Boolean   deblocking_filter_control_present_flag;           // u(1)
  Boolean   constrained_intra_pred_flag;                      // u(1)
  Boolean   redundant_pic_cnt_present_flag;                   // u(1)
  Boolean   vui_pic_parameters_flag;                          // u(1)
} pic_parameter_set_rbsp_t;

extern pic_parameter_set_rbsp_t *active_pps;

void SetupFastFullPelSearch(
    short ref, int list)  // <--  reference frame parameter, list0 or 1
{
  int offset_x, offset_y, y, range_partly_outside, pos, abs_x,
      abs_y, bindex, blky;
pel_t   orig_blocks[256], *orgptr=orig_blocks, *refptr;
int     LineSadBlk0, LineSadBlk1, LineSadBlk2, LineSadBlk3;

StorablePicture *ref_picture;
  pel_t   *ref_pic;

int**   block_sad = BlockSAD[list][ref][7];
  int     search_range  = max_search_range[list][ref];
  int     max_pos       = (2*search_range+1) * (2*search_range+1);

int     list_offset   = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))? img->current_mb_nr%2 ? 4 : 2 : 0;

int     apply_weights = ( (active_pps->weighted_pred_flag && (img->type == P_SLICE || img->type == SP_SLICE)) ||
                            (active_pps->weighted_bipred_idc && (img->type == B_SLICE)));

ref_picture     = listX[list+list_offset][ref];

//===== Use weighted Reference for ME ====
  if (apply_weights) //  && input->UseWeightedReferenceME )
    ref_pic       = ref_picture->imgY_11_w;
  else
    ref_pic       = ref_picture->imgY_11;

int     max_width, max_height;
  int     img_width, img_height;
  max_width     = ref_picture->size_x - 17;
  max_height    = ref_picture->size_y - 17;
  
  img_width     = ref_picture->size_x;
  img_height    = ref_picture->size_y;

offset_x = search_center_x[list][ref];
  offset_y = search_center_y[list][ref];

//===== check if whole search range is inside image =====
  if (offset_x >= search_range && offset_x <= max_width  - search_range &&
      offset_y >= search_range && offset_y <= max_height - search_range   )
  {
    range_partly_outside = 0; PelYline_11 = FastLine16Y_11;
  }
  else
  {
    range_partly_outside = 1;
  }

//===== loop over search range (spiral search): get blockwise SAD =====
 for (pos = 0; pos < max_pos; pos++) {
    //if (pos > 1) abort();
    abs_y = offset_y + spiral_search_y[pos];
    abs_x = offset_x + spiral_search_x[pos];

if (range_partly_outside) {
      if (abs_y >= 0 && abs_y <= max_height && abs_x >= 0 &&
          abs_x <= max_width) {
        PelYline_11 = FastLine16Y_11;
      } else {
        PelYline_11 = UMVLine16Y_11;
      }
    }

orgptr = orig_blocks;
    bindex = 0;
    for (blky = 0; blky < 4; blky++) {
      LineSadBlk0 = LineSadBlk1 = LineSadBlk2 = LineSadBlk3 = 0;
      for (y = 0; y < 4; y++) {
        refptr = PelYline_11(ref_pic, abs_y++, abs_x, img_height, img_width);

LineSadBlk0 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk0 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk0 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk0 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk1 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk1 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk1 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk1 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk2 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk2 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk2 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk2 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk3 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk3 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk3 += byte_abs[*refptr++ - *orgptr++];
        LineSadBlk3 += byte_abs[*refptr++ - *orgptr++];
      }
      block_sad[bindex++][pos] = LineSadBlk0;
      block_sad[bindex++][pos] = LineSadBlk1;
      block_sad[bindex++][pos] = LineSadBlk2;
      block_sad[bindex++][pos] = LineSadBlk3;
    }
  }
}