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 )
  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_list0_table[X264_MBTYPE_MAX][2] =
  95 {
  96     {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
  97     {1,1},                  /* P_L0 */
  98     {0,0},                  /* P_8x8 */
  99     {1,1},                  /* P_SKIP */
 100     {0,0},                  /* B_DIRECT */
 101     {1,1}, {1,0}, {1,1},    /* B_L0_* */
 102     {0,1}, {0,0}, {0,1},    /* B_L1_* */
 103     {1,1}, {1,0}, {1,1},    /* B_BI_* */
 104     {0,0},                  /* B_8x8 */
 105     {0,0}                   /* B_SKIP */
 106 };
 107 static const uint8_t x264_mb_type_list1_table[X264_MBTYPE_MAX][2] =
 108 {
 109     {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
 110     {0,0},                  /* P_L0 */
 111     {0,0},                  /* P_8x8 */
 112     {0,0},                  /* P_SKIP */
 113     {0,0},                  /* B_DIRECT */
 114     {0,0}, {0,1}, {0,1},    /* B_L0_* */
 115     {1,0}, {1,1}, {1,1},    /* B_L1_* */
 116     {1,0}, {1,1}, {1,1},    /* B_BI_* */
 117     {0,0},                  /* B_8x8 */
 118     {0,0}                   /* B_SKIP */
 119 };
 120
 121 #define IS_SUB4x4(type) ( (type ==D_L0_4x4)||(type ==D_L1_4x4)||(type ==D_BI_4x4))
 122 #define IS_SUB4x8(type) ( (type ==D_L0_4x8)||(type ==D_L1_4x8)||(type ==D_BI_4x8))
 123 #define IS_SUB8x4(type) ( (type ==D_L0_8x4)||(type ==D_L1_8x4)||(type ==D_BI_8x4))
 124 #define IS_SUB8x8(type) ( (type ==D_L0_8x8)||(type ==D_L1_8x8)||(type ==D_BI_8x8)||(type ==D_DIRECT_8x8))
 125 enum mb_partition_e
 126 {
 127     /* sub partition type for P_8x8 and B_8x8 */
 128     D_L0_4x4        = 0,
 129     D_L0_8x4        = 1,
 130     D_L0_4x8        = 2,
 131     D_L0_8x8        = 3,
 132
 133     /* sub partition type for B_8x8 only */
 134     D_L1_4x4        = 4,
 135     D_L1_8x4        = 5,
 136     D_L1_4x8        = 6,
 137     D_L1_8x8        = 7,
 138
 139     D_BI_4x4        = 8,
 140     D_BI_8x4        = 9,
 141     D_BI_4x8        = 10,
 142     D_BI_8x8        = 11,
 143     D_DIRECT_8x8    = 12,
 144
 145     /* partition */
 146     D_8x8           = 13,
 147     D_16x8          = 14,
 148     D_8x16          = 15,
 149     D_16x16         = 16,
 150 };
 151
 152 static const uint8_t x264_mb_partition_listX_table[2][17] =
 153 {{
 154     1, 1, 1, 1, /* D_L0_* */
 155     0, 0, 0, 0, /* D_L1_* */
 156     1, 1, 1, 1, /* D_BI_* */
 157     0,          /* D_DIRECT_8x8 */
 158     0, 0, 0, 0  /* 8x8 .. 16x16 */
 159 },
 160 {
 161     0, 0, 0, 0, /* D_L0_* */
 162     1, 1, 1, 1, /* D_L1_* */
 163     1, 1, 1, 1, /* D_BI_* */
 164     0,          /* D_DIRECT_8x8 */
 165     0, 0, 0, 0  /* 8x8 .. 16x16 */
 166 }};
 167 static const uint8_t x264_mb_partition_count_table[17] =
 168 {
 169     /* sub L0 */
 170     4, 2, 2, 1,
 171     /* sub L1 */
 172     4, 2, 2, 1,
 173     /* sub BI */
 174     4, 2, 2, 1,
 175     /* Direct */
 176     1,
 177     /* Partition */
 178     4, 2, 2, 1
 179 };
 180 static const uint8_t x264_mb_partition_pixel_table[17] =
 181 {
 182     6, 4, 5, 3, 6, 4, 5, 3, 6, 4, 5, 3, 3, 3, 1, 2, 0
 183 };
 184
 185 /* zigzags are transposed with respect to the tables in the standard */
 186 static const uint8_t x264_zigzag_scan4[2][16] =
 187 {{ // frame
 188     0,  4,  1,  2,  5,  8, 12,  9,  6,  3,  7, 10, 13, 14, 11, 15
 189 },
 190 {  // field
 191     0,  1,  4,  2,  3,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15
 192 }};
 193 static const uint8_t x264_zigzag_scan8[2][64] =
 194 {{
 195     0,  8,  1,  2,  9, 16, 24, 17, 10,  3,  4, 11, 18, 25, 32, 40,
 196    33, 26, 19, 12,  5,  6, 13, 20, 27, 34, 41, 48, 56, 49, 42, 35,
 197    28, 21, 14,  7, 15, 22, 29, 36, 43, 50, 57, 58, 51, 44, 37, 30,
 198    23, 31, 38, 45, 52, 59, 60, 53, 46, 39, 47, 54, 61, 62, 55, 63
 199 },
 200 {
 201     0,  1,  2,  8,  9,  3,  4, 10, 16, 11,  5,  6,  7, 12, 17, 24,
 202    18, 13, 14, 15, 19, 25, 32, 26, 20, 21, 22, 23, 27, 33, 40, 34,
 203    28, 29, 30, 31, 35, 41, 48, 42, 36, 37, 38, 39, 43, 49, 50, 44,
 204    45, 46, 47, 51, 56, 57, 52, 53, 54, 55, 58, 59, 60, 61, 62, 63
 205 }};
 206
 207 static const uint8_t block_idx_x[16] =
 208 {
 209     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
 210 };
 211 static const uint8_t block_idx_y[16] =
 212 {
 213     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
 214 };
 215 static const uint8_t block_idx_xy[4][4] =
 216 {
 217     { 0, 2, 8,  10 },
 218     { 1, 3, 9,  11 },
 219     { 4, 6, 12, 14 },
 220     { 5, 7, 13, 15 }
 221 };
 222 static const uint8_t block_idx_xy_1d[16] =
 223 {
 224     0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15
 225 };
 226 static const uint8_t block_idx_xy_fenc[16] =
 227 {
 228     0*4 + 0*4*FENC_STRIDE, 1*4 + 0*4*FENC_STRIDE,
 229     0*4 + 1*4*FENC_STRIDE, 1*4 + 1*4*FENC_STRIDE,
 230     2*4 + 0*4*FENC_STRIDE, 3*4 + 0*4*FENC_STRIDE,
 231     2*4 + 1*4*FENC_STRIDE, 3*4 + 1*4*FENC_STRIDE,
 232     0*4 + 2*4*FENC_STRIDE, 1*4 + 2*4*FENC_STRIDE,
 233     0*4 + 3*4*FENC_STRIDE, 1*4 + 3*4*FENC_STRIDE,
 234     2*4 + 2*4*FENC_STRIDE, 3*4 + 2*4*FENC_STRIDE,
 235     2*4 + 3*4*FENC_STRIDE, 3*4 + 3*4*FENC_STRIDE
 236 };
 237 static const uint16_t block_idx_xy_fdec[16] =
 238 {
 239     0*4 + 0*4*FDEC_STRIDE, 1*4 + 0*4*FDEC_STRIDE,
 240     0*4 + 1*4*FDEC_STRIDE, 1*4 + 1*4*FDEC_STRIDE,
 241     2*4 + 0*4*FDEC_STRIDE, 3*4 + 0*4*FDEC_STRIDE,
 242     2*4 + 1*4*FDEC_STRIDE, 3*4 + 1*4*FDEC_STRIDE,
 243     0*4 + 2*4*FDEC_STRIDE, 1*4 + 2*4*FDEC_STRIDE,
 244     0*4 + 3*4*FDEC_STRIDE, 1*4 + 3*4*FDEC_STRIDE,
 245     2*4 + 2*4*FDEC_STRIDE, 3*4 + 2*4*FDEC_STRIDE,
 246     2*4 + 3*4*FDEC_STRIDE, 3*4 + 3*4*FDEC_STRIDE
 247 };
 248
 249 static const uint8_t i_chroma_qp_table[52] =
 250 {
 251      0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
 252     10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
 253     20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
 254     29, 30, 31, 32, 32, 33, 34, 34, 35, 35,
 255     36, 36, 37, 37, 37, 38, 38, 38, 39, 39,
 256     39, 39
 257 };
 258
 259 enum cabac_ctx_block_cat_e
 260 {
 261     DCT_LUMA_DC   = 0,
 262     DCT_LUMA_AC   = 1,
 263     DCT_LUMA_4x4  = 2,
 264     DCT_CHROMA_DC = 3,
 265     DCT_CHROMA_AC = 4,
 266     DCT_LUMA_8x8  = 5,
 267 };
 268
 269
 270 int  x264_macroblock_cache_init( x264_t *h );
 271 void x264_macroblock_slice_init( x264_t *h );
 272 void x264_macroblock_cache_load( x264_t *h, int i_mb_x, int i_mb_y );
 273 void x264_macroblock_cache_save( x264_t *h );
 274 void x264_macroblock_cache_end( x264_t *h );
 275
 276 void x264_macroblock_bipred_init( x264_t *h );
 277
 278 void x264_prefetch_fenc( x264_t *h, x264_frame_t *fenc, int i_mb_x, int i_mb_y );
 279
 280 /* x264_mb_predict_mv_16x16:
 281  *      set mvp with predicted mv for D_16x16 block
 282  *      h->mb. need only valid values from other blocks */
 283 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int16_t mvp[2] );
 284 /* x264_mb_predict_mv_pskip:
 285  *      set mvp with predicted mv for P_SKIP
 286  *      h->mb. need only valid values from other blocks */
 287 void x264_mb_predict_mv_pskip( x264_t *h, int16_t mv[2] );
 288 /* x264_mb_predict_mv:
 289  *      set mvp with predicted mv for all blocks except SKIP and DIRECT
 290  *      h->mb. need valid ref/partition/sub of current block to be valid
 291  *      and valid mv/ref from other blocks. */
 292 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int16_t mvp[2] );
 293 /* x264_mb_predict_mv_direct16x16:
 294  *      set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
 295  *      h->mb. need only valid values from other blocks.
 296  *      return 1 on success, 0 on failure.
 297  *      if b_changed != NULL, set it to whether refs or mvs differ from
 298  *      before this functioncall. */
 299 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed );
 300 /* x264_mb_load_mv_direct8x8:
 301  *      set h->mb.cache.mv and h->mb.cache.ref for B_DIRECT
 302  *      must be called only after x264_mb_predict_mv_direct16x16 */
 303 void x264_mb_load_mv_direct8x8( x264_t *h, int idx );
 304 /* x264_mb_predict_mv_ref16x16:
 305  *      set mvc with D_16x16 prediction.
 306  *      uses all neighbors, even those that didn't end up using this ref.
 307  *      h->mb. need only valid values from other blocks */
 308 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int16_t mvc[8][2], int *i_mvc );
 309
 310
 311 int  x264_mb_predict_intra4x4_mode( x264_t *h, int idx );
 312 int  x264_mb_predict_non_zero_code( x264_t *h, int idx );
 313
 314 /* x264_mb_transform_8x8_allowed:
 315  *      check whether any partition is smaller than 8x8 (or at least
 316  *      might be, according to just partition type.)
 317  *      doesn't check for cbp */
 318 int  x264_mb_transform_8x8_allowed( x264_t *h );
 319
 320 void x264_mb_mc( x264_t *h );
 321 void x264_mb_mc_8x8( x264_t *h, int i8 );
 322
 323 static ALWAYS_INLINE uint32_t pack16to32( int a, int b )
 324 {
 325 #ifdef WORDS_BIGENDIAN
 326    return b + (a<<16);
 327 #else
 328    return a + (b<<16);
 329 #endif
 330 }
 331 static ALWAYS_INLINE uint32_t pack8to16( int a, int b )
 332 {
 333 #ifdef WORDS_BIGENDIAN
 334    return b + (a<<8);
 335 #else
 336    return a + (b<<8);
 337 #endif
 338 }
 339 static ALWAYS_INLINE uint32_t pack8to32( int a, int b, int c, int d )
 340 {
 341 #ifdef WORDS_BIGENDIAN
 342    return d + (c<<8) + (b<<16) + (a<<24);
 343 #else
 344    return a + (b<<8) + (c<<16) + (d<<24);
 345 #endif
 346 }
 347 static ALWAYS_INLINE uint32_t pack16to32_mask( int a, int b )
 348 {
 349 #ifdef WORDS_BIGENDIAN
 350    return (b&0xFFFF) + (a<<16);
 351 #else
 352    return (a&0xFFFF) + (b<<16);
 353 #endif
 354 }
 355 static ALWAYS_INLINE void x264_macroblock_cache_rect1( void *dst, int width, int height, uint8_t val )
 356 {
 357     int dy;
 358     if( width == 4 )
 359     {
 360         uint32_t val2 = val * 0x01010101;
 361         for( dy = 0; dy < height; dy++ )
 362             ((uint32_t*)dst)[2*dy] = val2;
 363     }
 364     else // 2
 365     {
 366         uint32_t val2 = val * 0x0101;
 367         for( dy = 0; dy < height; dy++ )
 368             ((uint16_t*)dst)[4*dy] = val2;
 369     }
 370 }
 371 static ALWAYS_INLINE void x264_macroblock_cache_rect4( void *dst, int width, int height, uint32_t val )
 372 {
 373     int dy, dx;
 374     if( width == 1 || WORD_SIZE < 8 )
 375     {
 376         for( dy = 0; dy < height; dy++ )
 377             for( dx = 0; dx < width; dx++ )
 378                 ((uint32_t*)dst)[dx+8*dy] = val;
 379     }
 380     else
 381     {
 382         uint64_t val64 = val + ((uint64_t)val<<32);
 383         for( dy = 0; dy < height; dy++ )
 384             for( dx = 0; dx < width/2; dx++ )
 385                 ((uint64_t*)dst)[dx+4*dy] = val64;
 386     }
 387 }
 388 #define x264_macroblock_cache_mv_ptr(a,x,y,w,h,l,mv) x264_macroblock_cache_mv(a,x,y,w,h,l,*(uint32_t*)mv)
 389 static ALWAYS_INLINE void x264_macroblock_cache_mv( x264_t *h, int x, int y, int width, int height, int i_list, uint32_t mv )
 390 {
 391     x264_macroblock_cache_rect4( &h->mb.cache.mv[i_list][X264_SCAN8_0+x+8*y], width, height, mv );
 392 }
 393 static ALWAYS_INLINE void x264_macroblock_cache_mvd( x264_t *h, int x, int y, int width, int height, int i_list, uint32_t mv )
 394 {
 395     x264_macroblock_cache_rect4( &h->mb.cache.mvd[i_list][X264_SCAN8_0+x+8*y], width, height, mv );
 396 }
 397 static ALWAYS_INLINE void x264_macroblock_cache_ref( x264_t *h, int x, int y, int width, int height, int i_list, uint8_t ref )
 398 {
 399     x264_macroblock_cache_rect1( &h->mb.cache.ref[i_list][X264_SCAN8_0+x+8*y], width, height, ref );
 400 }
 401 static ALWAYS_INLINE void x264_macroblock_cache_skip( x264_t *h, int x, int y, int width, int height, int b_skip )
 402 {
 403     x264_macroblock_cache_rect1( &h->mb.cache.skip[X264_SCAN8_0+x+8*y], width, height, b_skip );
 404 }
 405 static ALWAYS_INLINE void x264_macroblock_cache_intra8x8_pred( x264_t *h, int x, int y, int i_mode )
 406 {
 407     int8_t *cache = &h->mb.cache.intra4x4_pred_mode[X264_SCAN8_0+x+8*y];
 408     cache[0] = cache[1] = cache[8] = cache[9] = i_mode;
 409 }
 410 #define array_non_zero(a) array_non_zero_int(a, sizeof(a))
 411 #define array_non_zero_int array_non_zero_int_c
 412 static ALWAYS_INLINE int array_non_zero_int_c( void *v, int i_count )
 413 {
 414     uint64_t *x = v;
 415     if(i_count == 8)
 416         return !!x[0];
 417     else if(i_count == 16)
 418         return !!(x[0]|x[1]);
 419     else if(i_count == 32)
 420         return !!(x[0]|x[1]|x[2]|x[3]);
 421     else
 422     {
 423         int i;
 424         i_count /= sizeof(uint64_t);
 425         for( i = 0; i < i_count; i++ )
 426             if( x[i] ) return 1;
 427         return 0;
 428     }
 429 }
 430 /* This function and its MMX version only work on arrays of size 16 */
 431 static ALWAYS_INLINE int array_non_zero_count( int16_t *v )
 432 {
 433     int i;
 434     int i_nz;
 435
 436     for( i = 0, i_nz = 0; i < 16; i++ )
 437         if( v[i] )
 438             i_nz++;
 439
 440     return i_nz;
 441 }
 442
 443 #endif
 444