git.sesse.net Git - x264/blob - common/common.h

   1 /*****************************************************************************
   2  * common.h: h264 encoder
   3  *****************************************************************************
   4  * Copyright (C) 2003 Laurent Aimar
   5  * $Id: common.h,v 1.1 2004/06/03 19:27:06 fenrir Exp $
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 #ifndef _COMMON_H
  25 #define _COMMON_H 1
  26
  27 #ifdef HAVE_STDINT_H
  28 #include <stdint.h>
  29 #else
  30 #include <inttypes.h>
  31 #endif
  32 #include <stdarg.h>
  33
  34 #include "x264.h"
  35 #include "bs.h"
  36 #include "set.h"
  37 #include "predict.h"
  38 #include "pixel.h"
  39 #include "mc.h"
  40 #include "frame.h"
  41 #include "dct.h"
  42 #include "cabac.h"
  43 #include "csp.h"
  44
  45 /****************************************************************************
  46  * Macros
  47  ****************************************************************************/
  48 #define X264_MIN(a,b) ( (a)<(b) ? (a) : (b) )
  49 #define X264_MAX(a,b) ( (a)>(b) ? (a) : (b) )
  50 #define X264_ABS(a)   ( (a)< 0 ? -(a) : (a) )
  51
  52 /****************************************************************************
  53  * Generals functions
  54  ****************************************************************************/
  55 /* x264_malloc : will do or emulate a memalign
  56  * XXX you HAVE TO use x264_free for buffer allocated
  57  * with x264_malloc
  58  */
  59 void *x264_malloc( int );
  60 void *x264_realloc( void *p, int i_size );
  61 void  x264_free( void * );
  62
  63 /* mdate: return the current date in microsecond */
  64 int64_t x264_mdate( void );
  65
  66 /* log */
  67 void x264_log( x264_t *h, int i_level, const char *psz_fmt, ... );
  68
  69 static inline int x264_clip3( int v, int i_min, int i_max )
  70 {
  71     return ( (v < i_min) ? i_min : (v > i_max) ? i_max : v );
  72 }
  73
  74 static inline float x264_clip3f( float v, float f_min, float f_max )
  75 {
  76     return ( (v < f_min) ? f_min : (v > f_max) ? f_max : v );
  77 }
  78
  79 /****************************************************************************
  80  *
  81  ****************************************************************************/
  82 enum slice_type_e
  83 {
  84     SLICE_TYPE_P  = 0,
  85     SLICE_TYPE_B  = 1,
  86     SLICE_TYPE_I  = 2,
  87     SLICE_TYPE_SP = 3,
  88     SLICE_TYPE_SI = 4
  89 };
  90
  91 typedef struct
  92 {
  93     x264_sps_t *sps;
  94     x264_pps_t *pps;
  95
  96     int i_type;
  97     int i_first_mb;
  98
  99     int i_pps_id;
 100
 101     int i_frame_num;
 102
 103     int b_field_pic;
 104     int b_bottom_field;
 105
 106     int i_idr_pic_id;   /* -1 if nal_type != 5 */
 107
 108     int i_poc_lsb;
 109     int i_delta_poc_bottom;
 110
 111     int i_delta_poc[2];
 112     int i_redundant_pic_cnt;
 113
 114     int b_direct_spatial_mv_pred;
 115
 116     int b_num_ref_idx_override;
 117     int i_num_ref_idx_l0_active;
 118     int i_num_ref_idx_l1_active;
 119
 120     int i_cabac_init_idc;
 121
 122     int i_qp_delta;
 123     int b_sp_for_swidth;
 124     int i_qs_delta;
 125
 126     /* deblocking filter */
 127     int i_disable_deblocking_filter_idc;
 128     int i_alpha_c0_offset;
 129     int i_beta_offset;
 130
 131 } x264_slice_header_t;
 132
 133 /* From ffmpeg
 134  */
 135 #define X264_SCAN8_SIZE (6*8)
 136 #define X264_SCAN8_0 (4+1*8)
 137
 138 static const int x264_scan8[16+2*4] =
 139 {
 140     /* Luma */
 141     4+1*8, 5+1*8, 4+2*8, 5+2*8,
 142     6+1*8, 7+1*8, 6+2*8, 7+2*8,
 143     4+3*8, 5+3*8, 4+4*8, 5+4*8,
 144     6+3*8, 7+3*8, 6+4*8, 7+4*8,
 145
 146     /* Cb */
 147     1+1*8, 2+1*8,
 148     1+2*8, 2+2*8,
 149
 150     /* Cr */
 151     1+4*8, 2+4*8,
 152     1+5*8, 2+5*8,
 153 };
 154 /*
 155    0 1 2 3 4 5 6 7
 156  0
 157  1   B B   L L L L
 158  2   B B   L L L L
 159  3         L L L L
 160  4   R R   L L L L
 161  5   R R
 162 */
 163
 164 #define X264_BFRAME_MAX 16
 165
 166 typedef struct x264_ratecontrol_t   x264_ratecontrol_t;
 167 typedef struct x264_vlc_table_t     x264_vlc_table_t;
 168
 169 struct x264_t
 170 {
 171     /* encoder parameters */
 172     x264_param_t    param;
 173
 174     /* bitstream output */
 175     struct
 176     {
 177         int         i_nal;
 178         x264_nal_t  nal[3];         /* for now 3 is enought */
 179         int         i_bitstream;    /* size of p_bitstream */
 180         uint8_t     *p_bitstream;   /* will hold data for all nal */
 181         bs_t        bs;
 182     } out;
 183
 184     /* frame number/poc */
 185     int             i_frame;
 186     int             i_poc;
 187
 188     int             i_frame_offset; /* decoding only */
 189     int             i_frame_num;    /* decoding only */
 190     int             i_poc_msb;      /* decoding only */
 191     int             i_poc_lsb;      /* decoding only */
 192
 193     /* We use only one SPS and one PPS */
 194     x264_sps_t      sps_array[32];
 195     x264_sps_t      *sps;
 196     x264_pps_t      pps_array[256];
 197     x264_pps_t      *pps;
 198     int             i_idr_pic_id;
 199
 200     /* Slice header */
 201     x264_slice_header_t sh;
 202
 203     /* cabac context */
 204     x264_cabac_t    cabac;
 205
 206     struct
 207     {
 208         /* Frames to be encoded */
 209         x264_frame_t *current[X264_BFRAME_MAX+1];
 210         /* Temporary buffer (eg B frames pending until we reach the I/P) */
 211         x264_frame_t *next[X264_BFRAME_MAX+1];
 212         /* Unused frames */
 213         x264_frame_t *unused[X264_BFRAME_MAX+1];
 214
 215         /* frames used for reference +1 for decoding */
 216         x264_frame_t *reference[16+1];
 217
 218         int i_last_idr; /* Frame number of the last IDR */
 219
 220         int i_input;    /* Number of input frames already accepted */
 221     } frames;
 222
 223     /* current frame being encoded */
 224     x264_frame_t    *fenc;
 225
 226     /* frame being reconstructed */
 227     x264_frame_t    *fdec;
 228
 229     /* references lists */
 230     int             i_ref0;
 231     x264_frame_t    *fref0[16];       /* ref list 0 */
 232     int             i_ref1;
 233     x264_frame_t    *fref1[16];       /* ref list 1 */
 234
 235
 236
 237     /* Current MB DCT coeffs */
 238     struct
 239     {
 240         DECLARE_ALIGNED( int, luma16x16_dc[16], 16 );
 241         DECLARE_ALIGNED( int, chroma_dc[2][4], 16 );
 242         union
 243         {
 244             DECLARE_ALIGNED( int, residual_ac[15], 16 );
 245             DECLARE_ALIGNED( int, luma4x4[16], 16 );
 246         } block[16+8];
 247     } dct;
 248
 249     /* MB table and cache for current frame/mb */
 250     struct
 251     {
 252         int     i_mb_count;                 /* number of mbs in a frame */
 253
 254         /* Strides */
 255         int     i_mb_stride;
 256         int     i_b8_stride;
 257         int     i_b4_stride;
 258
 259         /* Current index */
 260         int     i_mb_x;
 261         int     i_mb_y;
 262         int     i_mb_xy;
 263         int     i_b8_xy;
 264         int     i_b4_xy;
 265
 266         unsigned int i_neighbour;
 267
 268         /* mb table */
 269         int8_t  *type;                      /* mb type */
 270         int8_t  *qp;                        /* mb qp */
 271         int16_t *cbp;                       /* mb cbp: 0x0?: luma, 0x?0: chroma, 0x100: luma dc, 0x0200 and 0x0400: chroma dc  (all set for PCM)*/
 272         int8_t  (*intra4x4_pred_mode)[7];   /* intra4x4 pred mode. for non I4x4 set to I_PRED_4x4_DC(2) */
 273         uint8_t (*non_zero_count)[16+4+4];  /* nzc. for I_PCM set to 16 */
 274         int8_t  *chroma_pred_mode;          /* chroma_pred_mode. cabac only. for non intra I_PRED_CHROMA_DC(0) */
 275         int16_t (*mv[2])[2];                /* mb mv. set to 0 for intra mb */
 276         int16_t (*mvd[2])[2];               /* mb mv difference with predict. set to 0 if intra. cabac only */
 277         int8_t   *ref[2];                   /* mb ref. set to -1 if non used (intra or Lx only) */
 278         int16_t (*mvr[2][16])[2];           /* 16x16 mv for each possible ref */
 279         int8_t  *skipbp;                    /* block pattern for SKIP or DIRECT (sub)mbs. B-frames + cabac only */
 280
 281         /* current value */
 282         int     i_type;
 283         int     i_partition;
 284         int     i_sub_partition[4];
 285
 286         int     i_cbp_luma;
 287         int     i_cbp_chroma;
 288
 289         int     i_intra16x16_pred_mode;
 290         int     i_chroma_pred_mode;
 291
 292         struct
 293         {
 294             /* pointer over mb of the frame to be compressed */
 295             uint8_t *p_fenc[3];
 296
 297             /* pointer over mb of the frame to be reconstrucated  */
 298             uint8_t *p_fdec[3];
 299
 300             /* pointer over mb of the references */
 301             uint8_t *p_fref[2][16][3];
 302
 303             /* common stride */
 304             int     i_stride[3];
 305         } pic;
 306
 307         /* cache */
 308         struct
 309         {
 310             /* real intra4x4_pred_mode if I_4X4, I_PRED_4x4_DC if mb available, -1 if not */
 311             int     intra4x4_pred_mode[X264_SCAN8_SIZE];
 312
 313             /* i_non_zero_count if availble else 0x80 */
 314             int     non_zero_count[X264_SCAN8_SIZE];
 315
 316             /* -1 if unused, -2 if unavaible */
 317             int8_t  ref[2][X264_SCAN8_SIZE];
 318
 319             /* 0 if non avaible */
 320             int16_t mv[2][X264_SCAN8_SIZE][2];
 321             int16_t mvd[2][X264_SCAN8_SIZE][2];
 322
 323             /* 1 if SKIP or DIRECT. set only for B-frames + CABAC */
 324             int8_t  skip[X264_SCAN8_SIZE];
 325
 326             int16_t direct_mv[2][X264_SCAN8_SIZE][2];
 327             int8_t  direct_ref[2][X264_SCAN8_SIZE];
 328         } cache;
 329
 330         /* */
 331         int     i_last_qp;  /* last qp */
 332         int     i_last_dqp; /* last delta qp */
 333
 334     } mb;
 335
 336     /* rate control encoding only */
 337     x264_ratecontrol_t *rc;
 338
 339     int i_last_inter_size;
 340     int i_last_intra_size;
 341     int i_last_intra_qp;
 342
 343     /* stats */
 344     struct
 345     {
 346         /* Current frame stats */
 347         struct
 348         {
 349             /* Headers bits (MV+Ref+MB Block Type */
 350             int i_hdr_bits;
 351             /* Texture bits (Intra/Predicted) */
 352             int i_itex_bits;
 353             int i_ptex_bits;
 354             /* ? */
 355             int i_misc_bits;
 356             /* MB type counts */
 357             int i_mb_count[18];
 358             int i_mb_count_p;
 359             int i_mb_count_skip;
 360             /* Estimated (SATD) cost as Intra/Predicted frame */
 361             /* XXX: both omit the cost of MBs coded as P_SKIP */
 362             int i_intra_cost;
 363             int i_inter_cost;
 364         } frame;
 365
 366         /* Cummulated stats */
 367
 368         /* per slice info */
 369         int   i_slice_count[5];
 370         int64_t i_slice_size[5];
 371         int     i_slice_qp[5];
 372         /* */
 373         int64_t i_sqe_global[5];
 374         float   f_psnr_average[5];
 375         float   f_psnr_mean_y[5];
 376         float   f_psnr_mean_u[5];
 377         float   f_psnr_mean_v[5];
 378         /* */
 379         int64_t i_mb_count[5][18];
 380
 381     } stat;
 382
 383     /* CPU functions dependants */
 384     x264_predict_t      predict_16x16[4+3];
 385     x264_predict_t      predict_8x8[4+3];
 386     x264_predict_t      predict_4x4[9+3];
 387
 388     x264_pixel_function_t pixf;
 389     x264_mc_function_t    mc[2];
 390     x264_dct_function_t   dctf;
 391     x264_csp_function_t   csp;
 392
 393     /* vlc table for decoding purpose only */
 394     x264_vlc_table_t *x264_coeff_token_lookup[5];
 395     x264_vlc_table_t *x264_level_prefix_lookup;
 396     x264_vlc_table_t *x264_total_zeros_lookup[15];
 397     x264_vlc_table_t *x264_total_zeros_dc_lookup[3];
 398     x264_vlc_table_t *x264_run_before_lookup[7];
 399 };
 400
 401 #endif
 402