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

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