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

   1 /*****************************************************************************
   2  * macroblock.h: h264 encoder library
   3  *****************************************************************************
   4  * Copyright (C) 2005-2008 x264 project
   5  *
   6  * Authors: Loren Merritt <lorenm@u.washington.edu>
   7  *          Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Fiona Glaser <fiona@x264.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 #ifndef X264_MACROBLOCK_H
  26 #define X264_MACROBLOCK_H
  27
  28 enum macroblock_position_e
  29 {
  30     MB_LEFT     = 0x01,
  31     MB_TOP      = 0x02,
  32     MB_TOPRIGHT = 0x04,
  33     MB_TOPLEFT  = 0x08,
  34
  35     MB_PRIVATE  = 0x10,
  36
  37     ALL_NEIGHBORS = 0xf,
  38 };
  39
  40 static const uint8_t x264_pred_i4x4_neighbors[12] =
  41 {
  42     MB_TOP,                         // I_PRED_4x4_V
  43     MB_LEFT,                        // I_PRED_4x4_H
  44     MB_LEFT | MB_TOP,               // I_PRED_4x4_DC
  45     MB_TOP  | MB_TOPRIGHT,          // I_PRED_4x4_DDL
  46     MB_LEFT | MB_TOPLEFT | MB_TOP,  // I_PRED_4x4_DDR
  47     MB_LEFT | MB_TOPLEFT | MB_TOP,  // I_PRED_4x4_VR
  48     MB_LEFT | MB_TOPLEFT | MB_TOP,  // I_PRED_4x4_HD
  49     MB_TOP  | MB_TOPRIGHT,          // I_PRED_4x4_VL
  50     MB_LEFT,                        // I_PRED_4x4_HU
  51     MB_LEFT,                        // I_PRED_4x4_DC_LEFT
  52     MB_TOP,                         // I_PRED_4x4_DC_TOP
  53     0                               // I_PRED_4x4_DC_128
  54 };
  55
  56
  57 /* XXX mb_type isn't the one written in the bitstream -> only internal usage */
  58 #define IS_INTRA(type) ( (type) == I_4x4 || (type) == I_8x8 || (type) == I_16x16 || (type) == I_PCM )
  59 #define IS_SKIP(type)  ( (type) == P_SKIP || (type) == B_SKIP )
  60 #define IS_DIRECT(type)  ( (type) == B_DIRECT )
  61 enum mb_class_e
  62 {
  63     I_4x4           = 0,
  64     I_8x8           = 1,
  65     I_16x16         = 2,
  66     I_PCM           = 3,
  67
  68     P_L0            = 4,
  69     P_8x8           = 5,
  70     P_SKIP          = 6,
  71
  72     B_DIRECT        = 7,
  73     B_L0_L0         = 8,
  74     B_L0_L1         = 9,
  75     B_L0_BI         = 10,
  76     B_L1_L0         = 11,
  77     B_L1_L1         = 12,
  78     B_L1_BI         = 13,
  79     B_BI_L0         = 14,
  80     B_BI_L1         = 15,
  81     B_BI_BI         = 16,
  82     B_8x8           = 17,
  83     B_SKIP          = 18,
  84
  85     X264_MBTYPE_MAX = 19
  86 };
  87 static const uint8_t x264_mb_type_fix[X264_MBTYPE_MAX] =
  88 {
  89     I_4x4, I_4x4, I_16x16, I_PCM,
  90     P_L0, P_8x8, P_SKIP,
  91     B_DIRECT, B_L0_L0, B_L0_L1, B_L0_BI, B_L1_L0, B_L1_L1,
  92     B_L1_BI, B_BI_L0, B_BI_L1, B_BI_BI, B_8x8, B_SKIP
  93 };
  94 static const uint8_t x264_mb_type_list_table[X264_MBTYPE_MAX][2][2] =
  95 {
  96     {{0,0},{0,0}}, {{0,0},{0,0}}, {{0,0},{0,0}}, {{0,0},{0,0}}, /* INTRA */
  97     {{1,1},{0,0}},                                              /* P_L0 */
  98     {{0,0},{0,0}},                                              /* P_8x8 */
  99     {{1,1},{0,0}},                                              /* P_SKIP */
 100     {{0,0},{0,0}},                                              /* B_DIRECT */
 101     {{1,1},{0,0}}, {{1,0},{0,1}}, {{1,1},{0,1}},                /* B_L0_* */
 102     {{0,1},{1,0}}, {{0,0},{1,1}}, {{0,1},{1,1}},                /* B_L1_* */
 103     {{1,1},{1,0}}, {{1,0},{1,1}}, {{1,1},{1,1}},                /* B_BI_* */
 104     {{0,0},{0,0}},                                              /* B_8x8 */
 105     {{0,0},{0,0}}                                               /* B_SKIP */
 106 };
 107
 108 #define IS_SUB4x4(type) ( (type ==D_L0_4x4)||(type ==D_L1_4x4)||(type ==D_BI_4x4))
 109 #define IS_SUB4x8(type) ( (type ==D_L0_4x8)||(type ==D_L1_4x8)||(type ==D_BI_4x8))
 110 #define IS_SUB8x4(type) ( (type ==D_L0_8x4)||(type ==D_L1_8x4)||(type ==D_BI_8x4))
 111 #define IS_SUB8x8(type) ( (type ==D_L0_8x8)||(type ==D_L1_8x8)||(type ==D_BI_8x8)||(type ==D_DIRECT_8x8))
 112 enum mb_partition_e
 113 {
 114     /* sub partition type for P_8x8 and B_8x8 */
 115     D_L0_4x4          = 0,
 116     D_L0_8x4          = 1,
 117     D_L0_4x8          = 2,
 118     D_L0_8x8          = 3,
 119
 120     /* sub partition type for B_8x8 only */
 121     D_L1_4x4          = 4,
 122     D_L1_8x4          = 5,
 123     D_L1_4x8          = 6,
 124     D_L1_8x8          = 7,
 125
 126     D_BI_4x4          = 8,
 127     D_BI_8x4          = 9,
 128     D_BI_4x8          = 10,
 129     D_BI_8x8          = 11,
 130     D_DIRECT_8x8      = 12,
 131
 132     /* partition */
 133     D_8x8             = 13,
 134     D_16x8            = 14,
 135     D_8x16            = 15,
 136     D_16x16           = 16,
 137     X264_PARTTYPE_MAX = 17,
 138 };
 139
 140 static const uint8_t x264_mb_partition_listX_table[2][17] =
 141 {{
 142     1, 1, 1, 1, /* D_L0_* */
 143     0, 0, 0, 0, /* D_L1_* */
 144     1, 1, 1, 1, /* D_BI_* */
 145     0,          /* D_DIRECT_8x8 */
 146     0, 0, 0, 0  /* 8x8 .. 16x16 */
 147 },
 148 {
 149     0, 0, 0, 0, /* D_L0_* */
 150     1, 1, 1, 1, /* D_L1_* */
 151     1, 1, 1, 1, /* D_BI_* */
 152     0,          /* D_DIRECT_8x8 */
 153     0, 0, 0, 0  /* 8x8 .. 16x16 */
 154 }};
 155 static const uint8_t x264_mb_partition_count_table[17] =
 156 {
 157     /* sub L0 */
 158     4, 2, 2, 1,
 159     /* sub L1 */
 160     4, 2, 2, 1,
 161     /* sub BI */
 162     4, 2, 2, 1,
 163     /* Direct */
 164     1,
 165     /* Partition */
 166     4, 2, 2, 1
 167 };
 168 static const uint8_t x264_mb_partition_pixel_table[17] =
 169 {
 170     6, 4, 5, 3, 6, 4, 5, 3, 6, 4, 5, 3, 3, 3, 1, 2, 0
 171 };
 172
 173 /* zigzags are transposed with respect to the tables in the standard */
 174 static const uint8_t x264_zigzag_scan4[2][16] =
 175 {{ // frame
 176     0,  4,  1,  2,  5,  8, 12,  9,  6,  3,  7, 10, 13, 14, 11, 15
 177 },
 178 {  // field
 179     0,  1,  4,  2,  3,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15
 180 }};
 181 static const uint8_t x264_zigzag_scan8[2][64] =
 182 {{
 183     0,  8,  1,  2,  9, 16, 24, 17, 10,  3,  4, 11, 18, 25, 32, 40,
 184    33, 26, 19, 12,  5,  6, 13, 20, 27, 34, 41, 48, 56, 49, 42, 35,
 185    28, 21, 14,  7, 15, 22, 29, 36, 43, 50, 57, 58, 51, 44, 37, 30,
 186    23, 31, 38, 45, 52, 59, 60, 53, 46, 39, 47, 54, 61, 62, 55, 63
 187 },
 188 {
 189     0,  1,  2,  8,  9,  3,  4, 10, 16, 11,  5,  6,  7, 12, 17, 24,
 190    18, 13, 14, 15, 19, 25, 32, 26, 20, 21, 22, 23, 27, 33, 40, 34,
 191    28, 29, 30, 31, 35, 41, 48, 42, 36, 37, 38, 39, 43, 49, 50, 44,
 192    45, 46, 47, 51, 56, 57, 52, 53, 54, 55, 58, 59, 60, 61, 62, 63
 193 }};
 194
 195 static const uint8_t block_idx_x[16] =
 196 {
 197     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
 198 };
 199 static const uint8_t block_idx_y[16] =
 200 {
 201     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
 202 };
 203 static const uint8_t block_idx_xy[4][4] =
 204 {
 205     { 0, 2, 8,  10 },
 206     { 1, 3, 9,  11 },
 207     { 4, 6, 12, 14 },
 208     { 5, 7, 13, 15 }
 209 };
 210 static const uint8_t block_idx_xy_1d[16] =
 211 {
 212     0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15
 213 };
 214 static const uint8_t block_idx_yx_1d[16] =
 215 {
 216     0, 4, 1, 5, 8, 12, 9, 13, 2, 6, 3, 7, 10, 14, 11, 15
 217 };
 218 static const uint8_t block_idx_xy_fenc[16] =
 219 {
 220     0*4 + 0*4*FENC_STRIDE, 1*4 + 0*4*FENC_STRIDE,
 221     0*4 + 1*4*FENC_STRIDE, 1*4 + 1*4*FENC_STRIDE,
 222     2*4 + 0*4*FENC_STRIDE, 3*4 + 0*4*FENC_STRIDE,
 223     2*4 + 1*4*FENC_STRIDE, 3*4 + 1*4*FENC_STRIDE,
 224     0*4 + 2*4*FENC_STRIDE, 1*4 + 2*4*FENC_STRIDE,
 225     0*4 + 3*4*FENC_STRIDE, 1*4 + 3*4*FENC_STRIDE,
 226     2*4 + 2*4*FENC_STRIDE, 3*4 + 2*4*FENC_STRIDE,
 227     2*4 + 3*4*FENC_STRIDE, 3*4 + 3*4*FENC_STRIDE
 228 };
 229 static const uint16_t block_idx_xy_fdec[16] =
 230 {
 231     0*4 + 0*4*FDEC_STRIDE, 1*4 + 0*4*FDEC_STRIDE,
 232     0*4 + 1*4*FDEC_STRIDE, 1*4 + 1*4*FDEC_STRIDE,
 233     2*4 + 0*4*FDEC_STRIDE, 3*4 + 0*4*FDEC_STRIDE,
 234     2*4 + 1*4*FDEC_STRIDE, 3*4 + 1*4*FDEC_STRIDE,
 235     0*4 + 2*4*FDEC_STRIDE, 1*4 + 2*4*FDEC_STRIDE,
 236     0*4 + 3*4*FDEC_STRIDE, 1*4 + 3*4*FDEC_STRIDE,
 237     2*4 + 2*4*FDEC_STRIDE, 3*4 + 2*4*FDEC_STRIDE,
 238     2*4 + 3*4*FDEC_STRIDE, 3*4 + 3*4*FDEC_STRIDE
 239 };
 240
 241 #define QP(qP) ( (qP)+QP_BD_OFFSET )
 242 static const uint8_t i_chroma_qp_table[QP_MAX+1+12*2] =
 243 {
 244          0,      0,      0,      0,      0,      0,
 245          0,      0,      0,      0,      0,      0,
 246 #if BIT_DEPTH > 9
 247    QP(-12),QP(-11),QP(-10), QP(-9), QP(-8), QP(-7),
 248 #endif
 249 #if BIT_DEPTH > 8
 250     QP(-6), QP(-5), QP(-4), QP(-3), QP(-2), QP(-1),
 251 #endif
 252      QP(0),  QP(1),  QP(2),  QP(3),  QP(4),  QP(5),
 253      QP(6),  QP(7),  QP(8),  QP(9), QP(10), QP(11),
 254     QP(12), QP(13), QP(14), QP(15), QP(16), QP(17),
 255     QP(18), QP(19), QP(20), QP(21), QP(22), QP(23),
 256     QP(24), QP(25), QP(26), QP(27), QP(28), QP(29),
 257     QP(29), QP(30), QP(31), QP(32), QP(32), QP(33),
 258     QP(34), QP(34), QP(35), QP(35), QP(36), QP(36),
 259     QP(37), QP(37), QP(37), QP(38), QP(38), QP(38),
 260     QP(39), QP(39), QP(39), QP(39),
 261     QP(39), QP(39), QP(39), QP(39), QP(39), QP(39),
 262     QP(39), QP(39), QP(39), QP(39), QP(39), QP(39),
 263 };
 264 #undef QP
 265
 266 enum cabac_ctx_block_cat_e
 267 {
 268     DCT_LUMA_DC   = 0,
 269     DCT_LUMA_AC   = 1,
 270     DCT_LUMA_4x4  = 2,
 271     DCT_CHROMA_DC = 3,
 272     DCT_CHROMA_AC = 4,
 273     DCT_LUMA_8x8  = 5,
 274 };
 275
 276 /* Per-frame allocation: is allocated per-thread only in frame-threads mode. */
 277 int  x264_macroblock_cache_allocate( x264_t *h );
 278 void x264_macroblock_cache_free( x264_t *h );
 279
 280 /* Per-thread allocation: is allocated per-thread even in sliced-threads mode. */
 281 int  x264_macroblock_thread_allocate( x264_t *h, int b_lookahead );
 282 void x264_macroblock_thread_free( x264_t *h, int b_lookahead );
 283
 284 void x264_macroblock_slice_init( x264_t *h );
 285 void x264_macroblock_thread_init( x264_t *h );
 286 void x264_macroblock_cache_load( x264_t *h, int mb_x, int mb_y );
 287 void x264_macroblock_cache_load_deblock( x264_t *h );
 288 void x264_macroblock_cache_load_neighbours_deblock( x264_t *h, int mb_x, int mb_y );
 289 void x264_macroblock_cache_save( x264_t *h );
 290
 291 void x264_macroblock_bipred_init( x264_t *h );
 292
 293 void x264_prefetch_fenc( x264_t *h, x264_frame_t *fenc, int i_mb_x, int i_mb_y );
 294
 295 void x264_copy_column8( pixel *dst, pixel *src );
 296
 297 /* x264_mb_predict_mv_16x16:
 298  *      set mvp with predicted mv for D_16x16 block
 299  *      h->mb. need only valid values from other blocks */
 300 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int16_t mvp[2] );
 301 /* x264_mb_predict_mv_pskip:
 302  *      set mvp with predicted mv for P_SKIP
 303  *      h->mb. need only valid values from other blocks */
 304 void x264_mb_predict_mv_pskip( x264_t *h, int16_t mv[2] );
 305 /* x264_mb_predict_mv:
 306  *      set mvp with predicted mv for all blocks except SKIP and DIRECT
 307  *      h->mb. need valid ref/partition/sub of current block to be valid
 308  *      and valid mv/ref from other blocks. */
 309 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int16_t mvp[2] );
 310 /* x264_mb_predict_mv_direct16x16:
 311  *      set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
 312  *      h->mb. need only valid values from other blocks.
 313  *      return 1 on success, 0 on failure.
 314  *      if b_changed != NULL, set it to whether refs or mvs differ from
 315  *      before this functioncall. */
 316 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed );
 317 /* x264_mb_predict_mv_ref16x16:
 318  *      set mvc with D_16x16 prediction.
 319  *      uses all neighbors, even those that didn't end up using this ref.
 320  *      h->mb. need only valid values from other blocks */
 321 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int16_t mvc[8][2], int *i_mvc );
 322
 323 void x264_mb_mc( x264_t *h );
 324 void x264_mb_mc_8x8( x264_t *h, int i8 );
 325
 326 static ALWAYS_INLINE uint32_t pack16to32( int a, int b )
 327 {
 328 #if WORDS_BIGENDIAN
 329    return b + (a<<16);
 330 #else
 331    return a + (b<<16);
 332 #endif
 333 }
 334 static ALWAYS_INLINE uint32_t pack8to16( int a, int b )
 335 {
 336 #if WORDS_BIGENDIAN
 337    return b + (a<<8);
 338 #else
 339    return a + (b<<8);
 340 #endif
 341 }
 342 static ALWAYS_INLINE uint32_t pack8to32( int a, int b, int c, int d )
 343 {
 344 #if WORDS_BIGENDIAN
 345    return d + (c<<8) + (b<<16) + (a<<24);
 346 #else
 347    return a + (b<<8) + (c<<16) + (d<<24);
 348 #endif
 349 }
 350 static ALWAYS_INLINE uint32_t pack16to32_mask( int a, int b )
 351 {
 352 #if WORDS_BIGENDIAN
 353    return (b&0xFFFF) + (a<<16);
 354 #else
 355    return (a&0xFFFF) + (b<<16);
 356 #endif
 357 }
 358 static ALWAYS_INLINE uint64_t pack32to64( uint32_t a, uint32_t b )
 359 {
 360 #ifdef WORDS_BIGENDIAN
 361    return b + ((uint64_t)a<<32);
 362 #else
 363    return a + ((uint64_t)b<<32);
 364 #endif
 365 }
 366
 367 #if X264_HIGH_BIT_DEPTH
 368 #   define pack_pixel_1to2 pack16to32
 369 #   define pack_pixel_2to4 pack32to64
 370 #else
 371 #   define pack_pixel_1to2 pack8to16
 372 #   define pack_pixel_2to4 pack16to32
 373 #endif
 374
 375 #define array_non_zero(a) array_non_zero_int(a, sizeof(a)/sizeof(dctcoef))
 376 #define array_non_zero_int array_non_zero_int
 377 static ALWAYS_INLINE int array_non_zero_int( dctcoef *v, int i_count )
 378 {
 379     for( int i = 0; i < i_count; i++ )
 380         if( v[i] )
 381             return 1;
 382     return 0;
 383 }
 384 static ALWAYS_INLINE int x264_mb_predict_intra4x4_mode( x264_t *h, int idx )
 385 {
 386     const int ma = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 1];
 387     const int mb = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 8];
 388     const int m  = X264_MIN( x264_mb_pred_mode4x4_fix(ma),
 389                              x264_mb_pred_mode4x4_fix(mb) );
 390
 391     if( m < 0 )
 392         return I_PRED_4x4_DC;
 393
 394     return m;
 395 }
 396 static ALWAYS_INLINE int x264_mb_predict_non_zero_code( x264_t *h, int idx )
 397 {
 398     const int za = h->mb.cache.non_zero_count[x264_scan8[idx] - 1];
 399     const int zb = h->mb.cache.non_zero_count[x264_scan8[idx] - 8];
 400
 401     int i_ret = za + zb;
 402
 403     if( i_ret < 0x80 )
 404         i_ret = ( i_ret + 1 ) >> 1;
 405     return i_ret & 0x7f;
 406 }
 407 /* x264_mb_transform_8x8_allowed:
 408  *      check whether any partition is smaller than 8x8 (or at least
 409  *      might be, according to just partition type.)
 410  *      doesn't check for cbp */
 411 static ALWAYS_INLINE int x264_mb_transform_8x8_allowed( x264_t *h )
 412 {
 413     // intra and skip are disallowed
 414     // large partitions are allowed
 415     // direct and 8x8 are conditional
 416     static const uint8_t partition_tab[X264_MBTYPE_MAX] = {
 417         0,0,0,0,1,2,0,1,1,1,1,1,1,1,1,1,1,1,0,
 418     };
 419
 420     if( !h->pps->b_transform_8x8_mode )
 421         return 0;
 422     if( h->mb.i_type != P_8x8 )
 423         return partition_tab[h->mb.i_type];
 424     return M32( h->mb.i_sub_partition ) == D_L0_8x8*0x01010101;
 425 }
 426
 427 #endif
 428