common.h

/*****************************************************************************
 * common.h: misc common functions
 *****************************************************************************/
 
#ifndef X264_COMMON_H
#define X264_COMMON_H
 
#include "config.h"
 
/****************************************************************************
 * Macros
 ****************************************************************************/
#define X264_MIN(a, b) ((a) < (b) ? (a) : (b))
#define X264_MAX(a, b) ((a) > (b) ? (a) : (b))
#define X264_MIN3(a, b, c) X264_MIN((a), X264_MIN((b), (c)))
#define X264_MAX3(a, b, c) X264_MAX((a), X264_MAX((b), (c)))
#define X264_MIN4(a, b, c, d) X264_MIN((a), X264_MIN3((b), (c), (d)))
#define X264_MAX4(a, b, c, d) X264_MAX((a), X264_MAX3((b), (c), (d)))
#define XCHG(type, a, b)    \
    do {                \
        type t = a; \
        a = b;      \
        b = t;      \
    } while (0)
#define IS_DISPOSABLE(type) (type == X264_TYPE_B)
#define FIX8(f) ((int)(f * (1 << 8) + .5))
#define ALIGN(x, a) (((x) + ((a)-1)) & ~((a)-1))
 
#define CHECKED_MALLOC(var, size)        \
    do {                             \
        var = x264_malloc(size); \
        if (!var)                \
            goto fail;       \
    } while (0)
#define CHECKED_MALLOCZERO(var, size)      \
    do {                               \
        CHECKED_MALLOC(var, size); \
        memset(var, 0, size);      \
    } while (0)
 
#define X264_BFRAME_MAX 4       /**** default: 16 => 4   ****/
#define X264_REF_MAX 4          /**** default: 16 => 4   ****/
#define X264_THREAD_MAX 4       /**** default: 128 => 4  ****/
#define X264_LOOKAHEAD_THREAD_MAX 2 /**** default: 16 => 2   ****/
#define X264_LOOKAHEAD_MAX 5        /**** default: 250 => 5  ****/
#define QP_BD_OFFSET (6 * (BIT_DEPTH - 8))
#define QP_MAX_SPEC (51 + QP_BD_OFFSET)
#define QP_MAX (QP_MAX_SPEC + 18)
#define QP_MAX_MAX (51 + 2 * 6 + 18)
#define PIXEL_MAX ((1 << BIT_DEPTH) - 1)
// arbitrary, but low because SATD scores are 1/4 normal
#define X264_LOOKAHEAD_QP (12 + QP_BD_OFFSET)
#define SPEC_QP(x) X264_MIN((x), QP_MAX_SPEC)
 
// number of pixels (per thread) in progress at any given time.
// 16 for the macroblock in progress + 3 for deblocking + 3 for motion compensation filter + 2 for extra safety
#define X264_THREAD_HEIGHT 24
 
/* WEIGHTP_FAKE is set when mb_tree & psy are enabled, but normal weightp is disabled
 * (such as in baseline). It checks for fades in lookahead and adjusts qp accordingly
 * to increase quality. Defined as (-1) so that if(i_weighted_pred > 0) is true only when
 * real weights are being used. */
 
#define X264_WEIGHTP_FAKE (-1)
 
#define NALU_OVERHEAD 5 // startcode + NAL type costs 5 bytes per frame
#define FILLER_OVERHEAD (NALU_OVERHEAD + 1)
 
/****************************************************************************
 * Includes
 ****************************************************************************/
#include "osdep.h"
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
/*#include <assert.h>*/
#include <limits.h>
 
#if HAVE_INTERLACED
#define MB_INTERLACED h->mb.b_interlaced
#define SLICE_MBAFF h->sh.b_mbaff
#define PARAM_INTERLACED h->param.b_interlaced
#else
#define MB_INTERLACED 0
#define SLICE_MBAFF 0
#define PARAM_INTERLACED 0
#endif
 
#ifdef CHROMA_FORMAT
#define CHROMA_H_SHIFT (CHROMA_FORMAT == CHROMA_420 || CHROMA_FORMAT == CHROMA_422)
#define CHROMA_V_SHIFT (CHROMA_FORMAT == CHROMA_420)
#else
#define CHROMA_FORMAT h->sps->i_chroma_format_idc
#define CHROMA_H_SHIFT h->mb.chroma_h_shift
#define CHROMA_V_SHIFT h->mb.chroma_v_shift
#endif
 
#define CHROMA_SIZE(s) ((s) >> (CHROMA_H_SHIFT + CHROMA_V_SHIFT))
#define FRAME_SIZE(s) ((s) + 2 * CHROMA_SIZE(s))
 
/* Unions for type-punning.
 * Mn: load or store n bits, aligned, native-endian
 * CPn: copy n bits, aligned, native-endian
 * we don't use memcpy for CPn because memcpy's args aren't assumed to be aligned */
typedef union {
    uint16_t i;
    uint8_t c[2];
} MAY_ALIAS x264_union16_t;
typedef union {
    uint32_t i;
    uint16_t b[2];
    uint8_t c[4];
} MAY_ALIAS x264_union32_t;
typedef union {
    uint64_t i;
    uint32_t a[2];
    uint16_t b[4];
    uint8_t c[8];
} MAY_ALIAS x264_union64_t;
typedef struct {
    uint64_t i[2];
} x264_uint128_t;
typedef union {
    x264_uint128_t i;
    uint64_t a[2];
    uint32_t b[4];
    uint16_t c[8];
    uint8_t d[16];
} MAY_ALIAS x264_union128_t;
#define M16(src) (((x264_union16_t *)(src))->i)
#define M32(src) (((x264_union32_t *)(src))->i)
#define M64(src) (((x264_union64_t *)(src))->i)
#define M128(src) (((x264_union128_t *)(src))->i)
#define M128_ZERO ((x264_uint128_t){{0, 0}})
#define CP16(dst, src) M16(dst) = M16(src)
#define CP32(dst, src) M32(dst) = M32(src)
#define CP64(dst, src) M64(dst) = M64(src)
#define CP128(dst, src) M128(dst) = M128(src)
 
#if HIGH_BIT_DEPTH
typedef uint16_t pixel;
typedef uint64_t pixel4;
typedef int32_t dctcoef;
typedef uint32_t udctcoef;
 
#define PIXEL_SPLAT_X4(x) ((x)*0x0001000100010001ULL)
#define MPIXEL_X4(src) M64(src)
#else
typedef uint8_t pixel;
typedef uint32_t pixel4;
typedef int16_t dctcoef;
typedef uint16_t udctcoef;
 
#define PIXEL_SPLAT_X4(x) ((x)*0x01010101U)
#define MPIXEL_X4(src) M32(src)
#endif
 
#define BIT_DEPTH X264_BIT_DEPTH
 
#define CPPIXEL_X4(dst, src) MPIXEL_X4(dst) = MPIXEL_X4(src)
 
#define X264_SCAN8_LUMA_SIZE (5 * 8)
#define X264_SCAN8_SIZE (X264_SCAN8_LUMA_SIZE * 3)
#define X264_SCAN8_0 (4 + 1 * 8)
 
/* Scan8 organization:
 *    0 1 2 3 4 5 6 7
 * 0  DY    y y y y y
 * 1        y Y Y Y Y
 * 2        y Y Y Y Y
 * 3        y Y Y Y Y
 * 4        y Y Y Y Y
 * 5  DU    u u u u u
 * 6        u U U U U
 * 7        u U U U U
 * 8        u U U U U
 * 9        u U U U U
 * 10 DV    v v v v v
 * 11       v V V V V
 * 12       v V V V V
 * 13       v V V V V
 * 14       v V V V V
 *
 * Scan8 stores pixels of 4x4 sub-block.
 * X264_SCAN8_SIZE = 3 * 5 * 8 = 120
 * y/u/v stores left or top pixels
 * Y/U/V stores current pixels
 * DY/DU/DV are for luma/chroma DC.
 */
 
#define LUMA_DC 48
#define CHROMA_DC 49
 
static const uint8_t x264_scan8[16 * 3 + 3] =
    {
    /* Y */
    4 + 1 * 8, 5 + 1 * 8, 4 + 2 * 8, 5 + 2 * 8,
    6 + 1 * 8, 7 + 1 * 8, 6 + 2 * 8, 7 + 2 * 8,
    4 + 3 * 8, 5 + 3 * 8, 4 + 4 * 8, 5 + 4 * 8,
    6 + 3 * 8, 7 + 3 * 8, 6 + 4 * 8, 7 + 4 * 8,
    /* U */
    4 + 6 * 8, 5 + 6 * 8, 4 + 7 * 8, 5 + 7 * 8,
    6 + 6 * 8, 7 + 6 * 8, 6 + 7 * 8, 7 + 7 * 8,
    4 + 8 * 8, 5 + 8 * 8, 4 + 9 * 8, 5 + 9 * 8,
    6 + 8 * 8, 7 + 8 * 8, 6 + 9 * 8, 7 + 9 * 8,
    /* V */
    4 + 11 * 8, 5 + 11 * 8, 4 + 12 * 8, 5 + 12 * 8,
    6 + 11 * 8, 7 + 11 * 8, 6 + 12 * 8, 7 + 12 * 8,
    4 + 13 * 8, 5 + 13 * 8, 4 + 14 * 8, 5 + 14 * 8,
    6 + 13 * 8, 7 + 13 * 8, 6 + 14 * 8, 7 + 14 * 8,
    0 + 0 * 8, 0 + 5 * 8, 0 + 10 * 8};
 
#include "x264.h"
#include "bitstream.h"
#include "set.h"
#include "predict.h"
#include "pixel.h"
#include "mc.h"
#include "frame.h"
#include "dct.h"
#include "cabac.h"
#include "quant.h"
 
/****************************************************************************
 * General functions
 ****************************************************************************/
/* x264_malloc : will do or emulate a memalign
 * you have to use x264_free for buffers allocated with x264_malloc */
void *x264_malloc(int);
void x264_free(void *);
 
/* x264_param2string: return a (malloced) string containing most of
 * the encoding options */
char *x264_param2string(x264_param_t *p, int b_res);
 
/* log */
void x264_log(x264_t *h, int i_level, const char *psz_fmt, ...);
 
void x264_cavlc_init(x264_t *h);
void x264_cabac_init(x264_t *h);
 
static ALWAYS_INLINE pixel x264_clip_pixel(int x) {
    return ((x & ~PIXEL_MAX) ? (-x) >> 31 & PIXEL_MAX : x);
}
 
static ALWAYS_INLINE int x264_clip3(int v, int i_min, int i_max) {
    return ((v < i_min) ? i_min : (v > i_max) ? i_max
                          : v);
}
 
static ALWAYS_INLINE double x264_clip3f(double v, double f_min, double f_max) {
    return ((v < f_min) ? f_min : (v > f_max) ? f_max
                          : v);
}
 
#if defined(__TI_COMPILER_VERSION__) && HAVE_TIC6X
static ALWAYS_INLINE void x264_median_mv(int16_t *dst, int16_t *a, int16_t *b, int16_t *c) {
    int mva = _mem4(a);
    int mvb = _mem4(b);
    int mvc = _mem4(c);
    int mvd;
 
    mvd = _min2(mva, mvb);
    mva = _max2(mva, mvb);
    mvd = _max2(mvd, mvc);
    mvd = _min2(mvd, mva);
    _mem4(dst) = mvd;
}
#else
static ALWAYS_INLINE int x264_median(int a, int b, int c) {
    int t = (a - b) & ((a - b) >> 31);
    a -= t;
    b += t;
    b -= (b - c) & ((b - c) >> 31);
    b += (a - b) & ((a - b) >> 31);
    return b;
}
 
static ALWAYS_INLINE void x264_median_mv(int16_t *dst, int16_t *a, int16_t *b, int16_t *c) {
    dst[0] = x264_median(a[0], b[0], c[0]);
    dst[1] = x264_median(a[1], b[1], c[1]);
}
#endif
 
#if defined(__TI_COMPILER_VERSION__) && HAVE_TIC6X
static void ALWAYS_INLINE x264_predictor_roundclip(int16_t (*dst)[2], int16_t (*mvc)[2], int i_mvc, int mv_x_min, int mv_x_max, int mv_y_min, int mv_y_max) {
    int mv_min = _spack2(mv_y_min, mv_x_min);
    int mv_max = _spack2(mv_y_max, mv_x_max);
    int k_2 = 0x00020002;
    int mv, i;
 
    for (i = 0; i < i_mvc; i++) {
        mv = _mem4(mvc++);
        mv = _add2(mv, k_2);
        mv = _shr2(mv, 2);
        mv = _max2(mv, mv_min);
        mv = _min2(mv, mv_max);
        _mem4(dst++) = mv;
    }
}
#else
static void ALWAYS_INLINE x264_predictor_roundclip(int16_t (*dst)[2], int16_t (*mvc)[2], int i_mvc, int mv_x_min, int mv_x_max, int mv_y_min, int mv_y_max) {
    int i;
    for (i = 0; i < i_mvc; i++) {
        int mx = (mvc[i][0] + 2) >> 2;
        int my = (mvc[i][1] + 2) >> 2;
        dst[i][0] = x264_clip3(mx, mv_x_min, mv_x_max);
        dst[i][1] = x264_clip3(my, mv_y_min, mv_y_max);
    }
}
#endif
 
extern const float x264_log2_lut[128];
extern const float x264_log2_lz_lut[32];
 
static ALWAYS_INLINE float x264_log2(uint32_t x) {
    int lz = x264_clz(x);
    return x264_log2_lut[(x << lz >> 24) & 0x7f] + x264_log2_lz_lut[lz];
}
 
enum slice_type_e {
    SLICE_TYPE_P = 0,
    SLICE_TYPE_B = 1,
    SLICE_TYPE_I = 2,
};
 
static const char slice_type_to_char[] = {'P', 'B', 'I'};
 
/* Supplemental Enhancement Information (SEI) */
enum sei_payload_type_e {
    SEI_BUFFERING_PERIOD = 0,
    SEI_PIC_TIMING = 1,
    SEI_PAN_SCAN_RECT = 2,
    SEI_FILLER = 3,
    SEI_USER_DATA_REGISTERED = 4,
    SEI_USER_DATA_UNREGISTERED = 5,
    SEI_RECOVERY_POINT = 6,
    SEI_DEC_REF_PIC_MARKING = 7,
    SEI_FRAME_PACKING = 45,
};
 
typedef struct
{
    /* sequence parameter set syntax */
    x264_sps_t *sps;
    /* picture parameter set syntax */
    x264_pps_t *pps;
 
    /* slice type, 0: P, 1: B, 2: I */
    int i_type;
    /* first macro-block in slice. set 0 if only one slice per picture */
    int i_first_mb;
    /* last macro-block in slice.  */
    int i_last_mb;
 
    /* PPS id, range: [0-255] */
    int i_pps_id;
 
    /* frame number indicating decode order */
    int i_frame_num;
 
    /* macro-block adaptive field frame. 1: enable, 0: disable. default = h->param.b_interlaced */
    int b_mbaff;
    /* field coding flag. 1: field coding, 0: non-field coding */
    int b_field_pic;
    /* bottom field flag. valid only in field coding. */
    int b_bottom_field;
 
    /* IDR picture flag */
    int i_idr_pic_id; /* -1 if nal_type != 5 */
 
    /* picture-order-count */
    int i_poc;
    int i_delta_poc_bottom;
 
    int i_delta_poc[2];
    int i_redundant_pic_cnt;
 
    /* direct predict mode for B-slice. 1: spatial, 0: temporal */
    int b_direct_spatial_mv_pred;
 
    /* override flag of number of reference frames */
    int b_num_ref_idx_override;
    /* active reference frames of list 0 */
    int i_num_ref_idx_l0_active;
    /* active reference frames of list 1 */
    int i_num_ref_idx_l1_active;
 
    /* list reordering flag. array[0] for list 0, array[1] for list 1. */
    int b_ref_pic_list_reordering[2];
    struct
    {
        int idc;
        int arg;
    } ref_pic_list_order[2][X264_REF_MAX];
 
    /* P-frame weighting */
    int b_weighted_pred;
    x264_weight_t weight[X264_REF_MAX * 2][3];
 
    /* memory management control operation */
    int i_mmco_remove_from_end;
    int i_mmco_command_count;
    struct /* struct for future expansion */
    {
        int i_difference_of_pic_nums;
        int i_poc;
    } mmco[X264_REF_MAX];
 
    /* the index for determining the initialization table used in */
    /* the initialization process for context variables. range: [0-2] */
    int i_cabac_init_idc;
 
    int i_qp;
    /************************************************************************
     * specifies the initial value of QPY to be used for all the            *
     * macro-blocks in the slice until modified by the value of mb_qp_delta *
     * in the macro-block layer. The initial QPY quantization parameter for *
     * the slice is computed as:                                            *
     * QPY = 26 + pic_init_qp_minus26 + slice_qp_delta                      *
     ************************************************************************/
    int i_qp_delta;
    /* SP flag, 1: SP-frame, 0: SI-frame or other */
    int b_sp_for_swidth;
    /************************************************************************
     * specifies the value of QSY for all the macro-blocks in SP/SI slices. *
     * The QSY quantization parameter for the slice is computed as:         *
     * QSY = 26 + pic_init_qs_minus26 + slice_qs_delta                      *
     ************************************************************************/
    int i_qs_delta;
 
    /* deblocking filter */
    /*************************************************************************
     * specifies whether the operation of the deblocking filter shall be     *
     * disabled across some block edges of the slice and specifies for which *
     * edges the filtering is disabled. range: [0-2], default: 0.            *
     *                                                                       *
     * 0: all luma and chroma block edges of the slice are filtered.         *
     * 1: deblocking is disabled for all block edges of the slice.           *
     * 2: all luma and chroma block edges of the slice are filtered with     *
     *    exception of the block edges that coincide with slice boundaries.  *
     *************************************************************************/
    int i_disable_deblocking_filter_idc;
    int i_alpha_c0_offset; /* alpha c0 offset for deblocking filter. default: 0 */
    int i_beta_offset;     /* beta offset for deblocking filter. default: 0 */
} x264_slice_header_t;
 
typedef struct x264_lookahead_t {
    volatile uint8_t b_exit_thread; /* notifying lookahead thread to exit */
    uint8_t b_thread_active;    /* lookahead thread active flag */
    uint8_t b_analyse_keyframe; /* whether perform propagation analysis on I-frames. default: off */
    int i_last_keyframe;        /* last key frame number */
    int i_slicetype_length;     /* number of delay frames. 0 if b-frames disabled */
    x264_frame_t *last_nonb;    /* last Non-B frame pointer */
    x264_pthread_t thread_handle;   /* lookahead thread handle */
    x264_sync_frame_list_t next;    /* frames waiting for slice type decision */
    x264_sync_frame_list_t ofbuf;   /* frames which slice type decision is done */
} x264_lookahead_t;
 
typedef struct x264_ratecontrol_t x264_ratecontrol_t;
 
typedef struct x264_left_table_t {
    uint8_t intra[4];
    uint8_t nnz[4];
    uint8_t nnz_chroma[4];
    uint8_t mv[4];
    uint8_t ref[4];
} x264_left_table_t;
 
/* Current frame stats */
typedef struct
{
    /* MV bits (MV+Ref+Block Type) */
    int i_mv_bits;
    /* Texture bits (DCT coefs) */
    int i_tex_bits;
    /* ? */
    int i_misc_bits;
    /* MB type counts */
    int i_mb_count[19]; /* Accumulated mb count for 19 specific types of current frame */
    int i_mb_count_i;
    int i_mb_count_p;
    int i_mb_count_skip;
    int i_mb_count_8x8dct[2];
    int i_mb_count_ref[2][X264_REF_MAX * 2];
    int i_mb_partition[17]; /* Accumulated mb count for 17 partition types of current frame */
    int i_mb_cbp[6];
    int i_mb_pred_mode[4][13];
    int i_mb_field[3];
    /* Adaptive direct mv pred */
    int i_direct_score[2];
    /* Metrics */
    int64_t i_ssd[3]; /* SSD of Luma(y) and Chroma(u,v) for PSNR */
    double f_ssim;    /* SSIM of Luma */
    int i_ssim_cnt;   /* SSIM count */
} x264_frame_stat_t;
 
struct x264_t {
    /* encoder parameters */
    x264_param_t param;
 
    x264_t *thread[X264_THREAD_MAX + 1];
    x264_t *lookahead_thread[X264_LOOKAHEAD_THREAD_MAX];
    int b_thread_active;     /* thread active flag */
    int i_thread_phase;  /* which thread to use for the next frame */
    int i_thread_idx;    /* which thread this is */
    int i_threadslice_start; /* first row in this thread slice. set 0 if only one slice per frame. */
    int i_threadslice_end;   /* row after the end of this thread slice. set h->mb.i_mb_height if only one slice per frame. */
    int i_threadslice_pass;  /* which pass of encoding we are on */
 
    /* bitstream output */
    struct
    {
        int i_nal;        /* current used nals */
        int i_nals_allocated; /* allocated nals */
        x264_nal_t *nal;      /* nal unit list. output nals are guaranteed to be sequential in memory */
        int i_bitstream;      /* size of p_bitstream. at least 1MB */
        uint8_t *p_bitstream; /* will hold raw data for all nal */
        bs_t bs;
    } out;
 
    uint8_t *nal_buffer; /* buffer for encapsulated nal unit. */
    int nal_buffer_size; /* buffer size for encapsulated nal unit. at least 1.5 MB */
 
    /**** thread synchronization starts here ****/
 
    /* frame number/poc */
    int i_frame;     /* current frames */
    int i_frame_num; /* total frames */
 
    /* Number of different frames being encoded by threads;
     * 1 when sliced-threads is on, otherwise == x264_param_t.i_threads.
     */
    int i_thread_frames;
    int i_nal_type;    /* current nal unit type */
    int i_nal_ref_idc; /* current nal unit reference indication */
 
    int64_t i_disp_fields; /* Number of displayed fields (both coded and implied via pic_struct) */
    int i_disp_fields_last_frame;
    int64_t i_prev_duration;      /* Duration of previous frame */
    int64_t i_coded_fields;       /* Number of coded fields (both coded and implied via pic_struct) */
    int64_t i_cpb_delay;          /* Equal to number of fields preceding this field
                       * since last buffering_period SEI */
    int64_t i_coded_fields_lookahead; /* Use separate counters for lookahead */
    int64_t i_cpb_delay_lookahead;
 
    int64_t i_cpb_delay_pir_offset;
    int64_t i_cpb_delay_pir_offset_next;
 
    int b_queued_intra_refresh;
    int64_t i_last_idr_pts;
 
    /* IDR picture flag */
    int i_idr_pic_id;
 
    /* quantization matrix for decoding, [cqm][qp%6][coef] */
    int (*dequant4_mf[4])[16]; /* [4][6][16] */
    /* quantization matrix for deadzone */
    udctcoef (*quant4_mf[4])[16];   /* [4][52][16] */
    udctcoef (*quant4_bias[4])[16]; /* [4][52][16] */
 
    /* mv/ref cost arrays. */
    /* NOTE: x264_analyse_init_costs() mallocs 64KB for each integer between qp_min and qp_max.
     * this may occupy space about: 64KB * 70 = 4.4MB
     * cost_mv_fpel is used only when motion estimation is ESA or TESA.
     */
    uint16_t *cost_mv[QP_MAX + 1];
 
    /* includes both the nonlinear luma->chroma mapping and chroma_qp_offset.
     * see definition of i_chroma_qp_table in common/macroblock.h
     * h->chroma_qp_table = i_chroma_qp_table + 12 + h->pps->i_chroma_qp_index_offset;
     */
    const uint8_t *chroma_qp_table;
 
    /* Slice header */
    x264_slice_header_t sh;
 
    /* SPS / PPS */
    x264_sps_t sps[1];
    x264_pps_t pps[1];
 
    /* Slice header backup, for SEI_DEC_REF_PIC_MARKING */
    int b_sh_backup;
    x264_slice_header_t sh_backup;
 
    /* cabac context */
    x264_cabac_t cabac;
 
    struct
    {
        /* Frames to be encoded (whose types have been decided) */
        x264_frame_t **current;
        /* Unused frames: 0 = fenc, 1 = fdec */
        x264_frame_t **unused[2];
 
        /* Unused blank frames (for duplicates) */
        x264_frame_t **blank_unused;
 
        /* frames used for reference + sentinels */
        x264_frame_t *reference[X264_REF_MAX + 2];
 
        int i_last_keyframe;     /* Frame number of the last keyframe */
        int i_last_idr;      /* Frame number of the last IDR (not RP)*/
        int i_poc_last_open_gop; /* Poc of the I frame of the last open-gop. The value
                      * is only assigned during the period between that
                      * I frame and the next P or I frame, else -1 */
 
        int i_input; /* Number of input frames already accepted */
 
        int i_max_dpb;  /* Number of frames allocated in the decoded picture buffer */
        int i_max_ref0; /* Maximum frames of list 0 */
        int i_max_ref1; /* Maximum frames of list 1 */
        int i_delay;    /* Number of frames buffered for B reordering */
        int i_bframe_delay;
        int64_t i_bframe_delay_time;
        int64_t i_first_pts;
        int64_t i_prev_reordered_pts[2];
        int64_t i_largest_pts;
        int64_t i_second_largest_pts;
        /******************************************************
         * Whether 1/2 resolution luma planes are being used. *
         * It is activated when the encoder needs to generate *
         * low resolution frames for the lookahead.           *
         ******************************************************/
        int b_have_lowres;
        int b_have_sub8x8_esa; /* Whether sub8x8 ESA is being used. default: off */
    } frames;
 
    /* current frame being encoded */
    x264_frame_t *fenc;
 
    /* frame being reconstructed */
    x264_frame_t *fdec;
 
    /* references lists */
    int i_ref[2];                /* frame number of l0/l1 */
    x264_frame_t *fref[2][X264_REF_MAX + 3]; /* frames of l0/l1, ordered by distance */
    x264_frame_t *fref_nearest[2];       /* nearest frame of l0/l1 */
    int b_ref_reorder[2];
 
    /* hrd */
    int initial_cpb_removal_delay;
    int initial_cpb_removal_delay_offset;
    int64_t i_reordered_pts_delay;
 
    /* Current MB DCT coeffs */
    struct
    {
        /* Intra_16x16 LUMA DC for Hadamard transform */
        ALIGNED_16(dctcoef luma16x16_dc[3][16]);
        /* CHROMA DC for Hadamard transform */
        ALIGNED_16(dctcoef chroma_dc[2][8]);
        /* 4x4 DCT transform, including luma and chroma */
        ALIGNED_16(dctcoef luma4x4[16 * 3][16]);
    } dct;
 
    /* MB table and cache for current frame/mb */
    struct
    {
        int i_mb_width;  /* number of mbs in width */
        int i_mb_height; /* number of mbs in height */
        int i_mb_count;  /* number of mbs in a frame */
 
        /* Chroma subsampling */
        int chroma_h_shift; /* horizontal shift bits for Chroma, 1 for 4:2:0 format. */
        int chroma_v_shift; /* vertical shift bits for Chroma, 1 for 4:2:0 format. */
 
        /* Strides */
        int i_mb_stride; /* how many macro-blocks (16x16) in one line. */
        int i_b8_stride; /* how many blocks (8x8) in one line. */
        int i_b4_stride; /* how many blocks (4x4) in one line. */
        int left_b8[2];  /* indices of two left blocks by 8x8 */
        int left_b4[2];  /* indices of two left blocks by 4x4 */
 
        /* Current index */
        int i_mb_x;  /* x of current mb */
        int i_mb_y;  /* y of current mb */
        int i_mb_xy; /* index of current mb */
        int i_b8_xy; /* index of current mb counted by block 8x8 */
        int i_b4_xy; /* index of current mb counted by block 4x4 */
 
        /* Search parameters */
        int i_me_method;     /* motion estimation method. see x264_param_t.i_me_method */
        int i_subpel_refine; /* sub-pixel refine. see x264_param_t.i_subpel_refine */
        /**********************************************************
         * whether uses chroma in motion estimation. default: off *
         * enabled only if x264_param_t.b_chroma_me == 1 and      *
         * (subme >= 5 if P or subme >= 9 if B)                   *
         **********************************************************/
        int b_chroma_me;
        /*****************************************************************
         * whether uses Trellis quantization.                            *
         * This value depends on x264_param_t.analyse.i_trellis          *
         *                                                               *
         * 1. for the analyse phase of a mb.                             *
         * enabled only when i_trellis > 1 and i_mbrd > 0                *
         * h->mb.b_trellis = h->param.analyse.i_trellis > 1 && a->i_mbrd *
         *                                                               *
         * 2. for the final encode of a mb.                              *
         * enabled when i_trellis > 0                                    *
         * h->mb.b_trellis = h->param.analyse.i_trellis                  *
         *****************************************************************/
        int b_trellis;
        int b_noise_reduction; /* whether uses noise reduction. default: off, depends on h->param.analyse.i_noise_reduction */
        int b_dct_decimate;    /* whether uses dct decimate for P/B mb. default: on, depends on h->param.analyse.b_dct_decimate */
        int i_psy_rd;          /* Psy RD strength--fixed point value */
        int i_psy_trellis;     /* Psy trellis strength--fixed point value */
 
        int b_interlaced;     /* interlaced mode. default: off */
        int b_adaptive_mbaff; /* MBAFF+subme 0 requires non-adaptive MBAFF i.e. all field mbs. default: off */
 
        /* Allowed qpel MV range to stay within the picture + emulated edge pixels */
        int mv_min[2];      /* minimum motion vector in x/y */
        int mv_max[2];      /* maximum motion vector in x/y */
        int mv_miny_row[3]; /* 0 == top progressive, 1 == bot progressive, 2 == interlaced */
        int mv_maxy_row[3];
        /* Subpel MV range for motion search.
         * same mv_min/max but includes levels' i_mv_range. */
        int mv_min_spel[2];  /* min mv x/y of sub-pixel */
        int mv_max_spel[2];  /* max mv x/y of sub-pixel */
        int mv_miny_spel_row[3]; /* */
        int mv_maxy_spel_row[3]; /* */
        /* Fullpel MV range for motion search */
        int mv_min_fpel[2];  /* min mv x/y of full-pixel */
        int mv_max_fpel[2];  /* max mv x/y of full-pixel */
        int mv_miny_fpel_row[3]; /* */
        int mv_maxy_fpel_row[3]; /* */
 
        /* neighboring MBs */
        unsigned int i_neighbour; /* position combination of neighbors that are available. eg: MB_LEFT|MB_TOP */
        /*********************************************************
         * neighbours of each 8x8 block that are available       *
         * at the time the block is coded.                       *
         *                                                       *
         * code order of 8x8 block in one macro-block:           *
         * 0  1                                                  *
         * 2  3                                                  *
         *                                                       *
         * At the beginning of 8x8 block coding:                 *
         * 1. available neighbours of block 3:                   *
         * MB_LEFT | MB_TOP | MB_TOPLEFT                         *
         * 2. available neighbours of other blocks is uncertain. *
         *********************************************************/
        unsigned int i_neighbour8[4];
        /*********************************************************
         * neighbours of each 4x4 block that are available       *
         * at the time the block is coded.                       *
         *                                                       *
         * code order of 4x4 block in one macro-block:           *
         * 0  1  4  5                                            *
         * 2  3  6  7                                            *
         * 8  9  12 13                                           *
         * 10 11 14 15                                           *
         *                                                       *
         * At the beginning of 4x4 block coding:                 *
         * 1. available neighbours of block 6, 9, 12, 14:        *
         * MB_LEFT | MB_TOP | MB_TOPLEFT | MB_TOPRIGHT           *
         * 2. available neighbours of block 3, 7, 11, 13, 15:    *
         * MB_LEFT | MB_TOP | MB_TOPLEFT                         *
         * 3. available neighbours of other blocks is uncertain. *
         *********************************************************/
        unsigned int i_neighbour4[16];
        unsigned int i_neighbour_intra; /* for constrained intra pred */
        unsigned int i_neighbour_frame; /* ignoring slice boundaries */
        int i_mb_type_top;      /* type of top mb */
        int i_mb_type_left[2];      /* type of two left mbs */
        int i_mb_type_topleft;      /* type of top-left mb */
        int i_mb_type_topright;     /* type of top-right mb */
        int i_mb_prev_xy;
        int i_mb_left_xy[2];  /* indices of two left mbs relative to h->mb.i_mb_xy */
        int i_mb_top_xy;      /* index of top mb relative to h->mb.i_mb_xy */
        int i_mb_topleft_xy;  /* index of top-left mb relative to h->mb.i_mb_xy */
        int i_mb_topright_xy; /* index of top-right mb relative to h->mb.i_mb_xy */
        int i_mb_top_y;       /* coordinate-y of top mb relative to h->mb.i_mb_xy */
        int i_mb_topleft_y;   /* coordinate-y of top-left/top-right mb relative to h->mb.i_mb_xy */
        int i_mb_topright_y;  /* i_mb_top_y == i_mb_topleft_y == i_mb_topright_y if in progressive mode. */
        const x264_left_table_t *left_index_table;
        int i_mb_top_mbpair_xy;
        int topleft_partition;
        int b_allow_skip; /* whether allow P/B_SKIP mb. default: on */
        int field_decoding_flag;
 
        /**** thread synchronization ends here ****/
        /* subsequent variables are either thread-local or constant,
         * and won't be copied from one thread to another */
 
        /* mb table of current frame */
        int8_t *type;               /* mb type. point to fdec: (h->mb.type = h->fdec->mb_type) */
        uint8_t *partition;         /* mb partition. point to fdec: (h->mb.partition = h->fdec->mb_partition) */
        int8_t *qp;             /* mb qp */
        int16_t *cbp;               /* mb cbp: 0x0?: luma, 0x?0: chroma, 0x100: luma dc, 0x0200 and 0x0400: chroma dc  (all set for PCM)*/
        int8_t (*intra4x4_pred_mode)[8];    /* intra4x4 pred mode. for non I4x4 set to I_PRED_4x4_DC(2) */
                            /* actually has only 7 entries; set to 8 for write-combining optimizations */
        uint8_t (*non_zero_count)[16 * 3];  /* nzc. for I_PCM set to 16 */
        int8_t *chroma_pred_mode;       /* chroma_pred_mode. cabac only. for non intra I_PRED_CHROMA_DC(0) */
        int16_t (*mv[2])[2];            /* mb mv. set to 0 for intra mb. point to fdec: (h->mb.mv[0] = h->fdec->mv[0];h->mb.mv[1] = h->fdec->mv[1]) */
        uint8_t (*mvd[2])[8][2];        /* absolute value of mb mv difference with predict, clipped to [0,33]. set to 0 if intra. cabac only */
        int8_t *ref[2];             /* mb ref. set to -1 if non used (intra or Lx only). point to fdec: (h->mb.ref[0] = h->fdec->ref[0];h->mb.ref[1] = h->fdec->ref[1]) */
        int16_t (*mvr[2][X264_REF_MAX * 2])[2]; /* 16x16 mv for each possible ref */
        int8_t *skipbp;             /* block pattern for SKIP or DIRECT (sub)mbs. B-frames + cabac only */
        int8_t *mb_transform_size;      /* transform_size_8x8_flag of each mb */
        uint16_t *slice_table;          /* sh->first_mb of the slice that the indexed mb is part of
                             * NOTE: this will fail on resolutions above 2^16 MBs... */
        uint8_t *field;             /* point to fdec: (h->mb.field = h->fdec->field) */
 
        /* buffer for weighted versions of the reference frames */
        pixel *p_weight_buf[X264_REF_MAX];
 
        /* current value */
        /* current macro-block type.
         * I_4x4,I_8x8,I_16x16,I_PCM,P_L0,P_8x8,P_SKIP,
         * B_DIRECT,B_L0_L0,B_L0_L1,B_L0_BI,B_L1_L0,B_L1_L1,
         * B_L1_BI,B_BI_L0,B_BI_L1,B_BI_BI,B_8x8,B_SKIP
         */
        int i_type;
        /* current macro-block partition.
         * D_16x16,D_8x16,D_16x8,D_8x8
         */
        int i_partition;
        /* current macro-block sub-partition type. used only if (i_partition == D_8x8)
         * for P_8x8:
         * D_L0_4x4,D_L0_8x4,D_L0_4x8,D_L0_8x8
         * for B_8x8:
         * D_L0_4x4,D_L0_8x4,D_L0_4x8,D_L0_8x8,
         * D_L1_4x4,D_L1_8x4,D_L1_4x8,D_L1_8x8,
         * D_BI_4x4,D_BI_8x4,D_BI_4x8,D_BI_8x8,
         * D_DIRECT_8x8
         */
        ALIGNED_4(uint8_t i_sub_partition[4]);
        int b_transform_8x8; /* 8x8 transform flag for current mb */
 
        /**********************************************************************************
         * Coded block pattern for luma. rage: [0-15]                                     *
         * If mb predict mode is Intra_16x16:                                             *
         * 0:  all AC transform coefficient levels of the luma component of the           *
         *     mb are equal to 0 for all 16 of the 4x4 blocks in the luma block           *
         * 15: at least one of the AC transform coefficient levels of the luma            *
         *     component of the mb shall be non-zero, and the AC transform coefficient    *
         *     levels are scanned for all 16 of the 4x4 blocks in the luma block          *
         * Otherwise (Not Intra_16x16), the following applies:                            *
         * - If the corresponding bit of CodedBlockPatternLuma is equal to 0,             *
         *   all transform coefficient levels of the luma transform blocks in the 8x8     *
         *   luma block are equal to zero.                                                *
         * - Otherwise (equal to 1), one or more transform coefficient levels of one      *
         *   or more of the luma transform blocks in the 8x8 luma block shall be non-zero *
         *   valued and the transform coefficient levels of the corresponding transform   *
         *   blocks are scanned.                                                          *
         **********************************************************************************/
        int i_cbp_luma;
        /*********************************************************************************************
         * Coded block pattern for chroma. range: [0-2]                                              *
         * 0 (none):    All chroma transform coefficient levels are equal to 0.                      *
         * 1 (dc only): One or more chroma DC transform coefficient levels shall be non-zero valued. *
         *              All chroma AC transform coefficient levels are equal to 0.                   *
         * 2 (dc + ac): Zero or more chroma DC transform coefficient levels are non-zero valued.     *
         *              One or more chroma AC transform coefficient levels shall be non-zero valued. *
         *********************************************************************************************/
        int i_cbp_chroma;
 
        int i_intra16x16_pred_mode; /* Intra_16x16 predict mode */
        int i_chroma_pred_mode;     /* Chroma predict mode */
 
        /***************************************************************************************
         * skip flags for i4x4 and i8x8. default: 1                                            *
         * 0 = encode as normal.                                                               *
         * 1 (non-RD only) = the DCT is still in h->dct, restore fdec and skip reconstruction. *
         * 2 (RD only) = the DCT has since been overwritten by RD; restore that too.           *
         ***************************************************************************************/
        int i_skip_intra;
        /* skip flag for motion compensation */
        /* if we've already done MC, we don't need to do it again */
        int b_skip_mc;
        /* set to true if we are re-encoding a macroblock. */
        int b_reencode_mb;
        int ip_offset;     /* Used by PIR to offset the quantizer of intra-refresh blocks. */
        int b_deblock_rdo; /* Whether call x264_macroblock_deblock for each mb rd cost. default: off */
        int b_overflow;    /* If CAVLC had a level code overflow during bitstream writing. */
 
        struct
        {
            /* space for p_fenc and p_fdec */
#define FENC_STRIDE 16
#define FDEC_STRIDE 32
            ALIGNED_16(pixel fenc_buf[48 * FENC_STRIDE]);
            ALIGNED_16(pixel fdec_buf[52 * FDEC_STRIDE]);
 
            /* i4x4 backup data, for skipping the encode stage when possible */
            ALIGNED_16(pixel i4x4_fdec_buf[16 * 16]);
            ALIGNED_16(dctcoef i4x4_dct_buf[15][16]);
            uint32_t i4x4_nnz_buf[4];
            int i4x4_cbp;
 
            /* pointer of y/u/v over mb of the frame to be compressed */
            pixel *p_fenc[3];
            /* pointer to the actual source frame, not a block copy */
            pixel *p_fenc_plane[3];
 
            /* pointer of y/u/v over mb of the frame to be reconstructed  */
            pixel *p_fdec[3];
 
            /* pointer over mb of the references of l0/l1 */
            int i_fref[2];
            /****************************************************************************
             * p_fref stores pixel values based on 1/2 sub-pixel precision.             *
             * Index: yN, yH, yV, yHV, (NV12 ? uv : I444 ? (uN, uH, uV, uHV, vN, ...))  *
             * [0] yN: full-pixel value of luma                                         *
             * [1] yH: horizontal half-pixel value of luma (right of full-pixel)        *
             * [2] yV: vertical half-pixel value of luma (down of full-pixel)           *
             * [3] yHV: hv half-pixel value of luma (diagonal down right of full-pixel) *
             *                                                                          *
             * for NV12/I420:                                                           *
             * [4] uv: full-pixel value of chroma                                       *
             * for I444:                                                                *
             * [4] uN, [5] uH, [6] uV, [7] uHV, [8] vN, [9] vH, [10] vV, [11] vHV       *
             ****************************************************************************/
            pixel *p_fref[2][X264_REF_MAX * 2][12];
            pixel *p_fref_w[X264_REF_MAX * 2]; /* weighted fullpel luma */
 
            /* fref stride */
            int i_stride[3];
        } pic;
 
        /* cache */
        struct
        {
            /* real intra4x4_pred_mode if I_4X4 or I_8X8, I_PRED_4x4_DC if mb available, -1 if not */
            ALIGNED_8(int8_t intra4x4_pred_mode[X264_SCAN8_LUMA_SIZE]);
 
            /* i_non_zero_count if available else 0x80 */
            ALIGNED_16(uint8_t non_zero_count[X264_SCAN8_SIZE]);
 
            /* -1 if unused, -2 if unavailable */
            ALIGNED_4(int8_t ref[2][X264_SCAN8_LUMA_SIZE]); /* reference frame number of last mb */
 
            /* 0 if not available */
            ALIGNED_16(int16_t mv[2][X264_SCAN8_LUMA_SIZE][2]); /* motion vectors of last mb in x/y */
            ALIGNED_8(uint8_t mvd[2][X264_SCAN8_LUMA_SIZE][2]); /* motion vectors delta of last mb in x/y */
 
            /* 1 if SKIP or DIRECT. set only for B-frames + CABAC */
            ALIGNED_4(int8_t skip[X264_SCAN8_LUMA_SIZE]);
 
            ALIGNED_4(int16_t direct_mv[2][4][2]);
            ALIGNED_4(int8_t direct_ref[2][4]);
            int direct_partition;
            ALIGNED_4(int16_t pskip_mv[2]);
 
            /* number of neighbors (top and left) that used 8x8 dct */
            int i_neighbour_transform_size;
            int i_neighbour_skip;
 
            /* neighbor CBPs */
            int i_cbp_top;  /* cbp of top mb  */
            int i_cbp_left; /* cbp of left mb */
 
            /* extra data required for mbaff in mv prediction */
            int16_t topright_mv[2][3][2];
            int8_t topright_ref[2][3];
 
            /* current mb deblock strength */
            uint8_t (*deblock_strength)[8][4];
        } cache;
 
        /* qp */
        int i_qp;        /* luma qp of current mb */
        int i_chroma_qp;     /* chroma qp of current mb */
        int i_last_qp;       /* luma qp of last mb */
        int i_last_dqp;      /* last delta qp. always 0 if qp is constant in slice. */
        int b_variable_qp;   /* whether qp is allowed to vary per macroblock. depends on whether VBV enabled or AQ enabled. */
        int b_lossless;      /* lossless flag. (rc.i_qp_constant == 0). default: off */
        int b_direct_auto_read;  /* take stats for --direct auto from the 2pass log */
        int b_direct_auto_write; /* analyse direct modes, to use and/or save */
 
        /* B_direct and weighted prediction */
        int16_t dist_scale_factor_buf[2][2][X264_REF_MAX * 2][4];
        int16_t (*dist_scale_factor)[4];
        int8_t bipred_weight_buf[2][2][X264_REF_MAX * 2][4];
        int8_t (*bipred_weight)[4];
        /* maps fref1[0]'s ref indices into the current list0 */
#define map_col_to_list0(col) h->mb.map_col_to_list0[(col) + 2]
        int8_t map_col_to_list0[X264_REF_MAX + 2];
        int ref_blind_dupe; /* The index of the blind reference frame duplicate. */
        int8_t deblock_ref_table[X264_REF_MAX * 2 + 2];
#define deblock_ref_table(x) h->mb.deblock_ref_table[(x) + 2]
    } mb;
 
    /* rate control encoding only */
    x264_ratecontrol_t *rc;
 
    /* stats */
    struct
    {
        /* Current frame stats */
        x264_frame_stat_t frame;
 
        /* Cumulated stats */
 
        /* per slice info */
        int i_frame_count[3];    /* Accumulated frame count for P/B/I frames */
        int64_t i_frame_size[3]; /* Accumulated frame bytes for P/B/I frames */
        double f_frame_qp[3];    /* Accumulated frame QP for P/B/I frames */
        int i_consecutive_bframes[X264_BFRAME_MAX + 1];
 
        /* psnr and ssim */
#ifdef _DEBUG
        double f_ssd_global[3];     /* Accumulated SSD for P/B/I frames */
        double f_psnr_average[3];   /* Average PSNR for P/B/I frames */
        double f_psnr_mean_y[3];    /* Mean LUMA PSNR for P/B/I frames */
        double f_psnr_mean_u[3];    /* Mean CHROMA (u) PSNR for P/B/I frames */
        double f_psnr_mean_v[3];    /* Mean CHROMA (v) PSNR for P/B/I frames */
        double f_ssim_mean_y[3];    /* Mean LUMA SSIM for P/B/I frames */
        double f_frame_duration[3]; /* Accumulated frame duration for P/B/I frames */
#endif
 
        /* macro-block stat */
#ifdef _DEBUG
        /**************************************************************
         * Accumulated mb count for 19 specific types of P/B/I frames *
         *                                                            *
         * I_4x4, I_8x8, I_16x16, I_PCM, P_L0, P_8x8, P_SKIP,         *
         * B_DIRECT, B_L0_L0, B_L0_L1, B_L0_BI, B_L1_L0, B_L1_L1,     *
         * B_L1_BI, B_BI_L0, B_BI_L1, B_BI_BI, B_8x8, B_SKIP          *
         **************************************************************/
        int64_t i_mb_count[3][19];
        /**************************************************************
         * Accumulated mb count for 17 partition types of P/B frames  *
         *                                                            *
         * sub partition type for P_8x8 and B_8x8                     *
         * D_L0_4x4, D_L0_8x4, D_L0_4x8, D_L0_8x8,                    *
         *                                                            *
         * sub partition type for B_8x8 only                          *
         * D_L1_4x4, D_L1_8x4, D_L1_4x8, D_L1_8x8,                    *
         * D_BI_4x4, D_BI_8x4, D_BI_4x8, D_BI_8x8,                    *
         * D_DIRECT_8x8,                                              *
         *                                                            *
         * partition                                                  *
         * D_8x8, D_16x8, D_8x16, D_16x16                             *
         **************************************************************/
        int64_t i_mb_partition[2][17];
        int64_t i_mb_count_8x8dct[2];
        /**************************************************************
         * Accumulated mb count for referenced index of P/B frames    *
         * [0][0]: L0 count of P-slices.                              *
         * [0][1]: Not used.                                          *
         * [1][0]: L0 count of B-slices.                              *
         * [1][1]: L1 count of B-slices.                              *
         **************************************************************/
        int64_t i_mb_count_ref[2][2][X264_REF_MAX * 2];
        /**************************************************************
         * Accumulated CodeBlockPattern count for all frames          *
         * [0]: Intra_y                                               *
         * [1]: Inter_y                                               *
         * [2]: Intra_uvDC/Intra_u                                    *
         * [3]: Inter_uvDC/Inter_u                                    *
         * [4]: Intra_uvAC/Intra_v                                    *
         * [5]: Inter_uvAC/Inter_v                                    *
         **************************************************************/
        int64_t i_mb_cbp[6];
        /**************************************************************
         * Accumulated mb count for 4 predict modes of all frames     *
         *                                                            *
         * [0]: I16x16 by (V,H,DC,P,DC_LEFT,DC_TOP,DC_128)            *
         * [1]: I8x8   by (V,H,DC,DDL,DDR,VR,HD,VL,HU,                *
         * [2]: I4x4       DC_LEFT,DC_TOP,DC_128)                     *
         * [3]: I8x8c  by (DC,H,V,P,DC_LEFT,DC_TOP,DC_128)            *
         **************************************************************/
        int64_t i_mb_pred_mode[4][13];
        int64_t i_mb_field[3];
#endif
 
        /* score of B-frames direct predict mode by temporal and spatial */
        int i_direct_score[2];
        /* num B-frames of direct predict mode by temporal and spatial */
        int i_direct_frames[2];
        /* num P-frames weighted for LUMA and CHROMA */
        int i_wpred[2];
    } stat;
 
    /* noise reduction */
    /* 0 = luma 4x4, 1 = luma 8x8, 2 = chroma 4x4, 3 = chroma 8x8 */
    udctcoef (*nr_offset)[64];
    uint32_t (*nr_residual_sum)[64];
    uint32_t *nr_count;
 
    ALIGNED_16(udctcoef nr_offset_denoise[4][64]);
    ALIGNED_16(uint32_t nr_residual_sum_buf[2][4][64]);
    uint32_t nr_count_buf[2][4];
 
    uint8_t luma2chroma_pixel[7]; /* Sub-sampled pixel size. for 4:2:0: 16x16 -> 8x8, 8x8 -> 4x4, 4x4 -> 2x2 */
 
    /* Buffers that are allocated per-thread even in sliced threads. */
    void *scratch_buffer;         /* for any temporary storage that doesn't want repeated malloc */
    void *scratch_buffer2;        /* used for output of frame cost, see x264_slicetype_frame_cost */
    pixel *intra_border_backup[5][3]; /* bottom pixels of the previous mb row, used for intra prediction after the framebuffer has been deblocked */
    /* Deblock strength values are stored for each 4x4 partition. In MBAFF
     * there are four extra values that need to be stored, located in [4][i]. */
    uint8_t (*deblock_strength[2])[2][8][4];
 
    /* CPU functions dependents */
    x264_predict_t predict_16x16[4 + 3];
    x264_predict_t predict_4x4[9 + 3];
    x264_predict_t predict_chroma[4 + 3]; /* CHROMA predict, 8x8c or 8x16c */
    x264_predict_t predict_8x8c[4 + 3];   /* for CHROMA_420 */
    x264_pixel_function_t pixf;
    x264_mc_functions_t mc;
    x264_dct_function_t dctf;
    x264_zigzag_function_t zigzagf;
    x264_quant_function_t quantf;
    x264_deblock_function_t loopf;
    x264_bitstream_function_t bsf;
 
    x264_lookahead_t *lookahead; /* lookahead struct for each thread */
};
 
// included at the end because it needs x264_t
#include "macroblock.h"
 
#include "rectangle.h"
 
#endif