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

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