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 _MACROBLOCK_H
  25 #define _MACROBLOCK_H 1
  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 int 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 static const int x264_mb_type_fix[19] =
  85 {
  86     I_4x4, I_4x4, I_16x16, I_PCM,
  87     P_L0, P_8x8, P_SKIP,
  88     B_DIRECT, B_L0_L0, B_L0_L1, B_L0_BI, B_L1_L0, B_L1_L1,
  89     B_L1_BI, B_BI_L0, B_BI_L1, B_BI_BI, B_8x8, B_SKIP
  90 };
  91 static const int x264_mb_type_list0_table[19][2] =
  92 {
  93     {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
  94     {1,1},                  /* P_L0 */
  95     {0,0},                  /* P_8x8 */
  96     {1,1},                  /* P_SKIP */
  97     {0,0},                  /* B_DIRECT */
  98     {1,1}, {1,0}, {1,1},    /* B_L0_* */
  99     {0,1}, {0,0}, {0,1},    /* B_L1_* */
 100     {1,1}, {1,0}, {1,1},    /* B_BI_* */
 101     {0,0},                  /* B_8x8 */
 102     {0,0}                   /* B_SKIP */
 103 };
 104 static const int x264_mb_type_list1_table[19][2] =
 105 {
 106     {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
 107     {0,0},                  /* P_L0 */
 108     {0,0},                  /* P_8x8 */
 109     {0,0},                  /* P_SKIP */
 110     {0,0},                  /* B_DIRECT */
 111     {0,0}, {0,1}, {0,1},    /* B_L0_* */
 112     {1,0}, {1,1}, {1,1},    /* B_L1_* */
 113     {1,0}, {1,1}, {1,1},    /* B_BI_* */
 114     {0,0},                  /* B_8x8 */
 115     {0,0}                   /* B_SKIP */
 116 };
 117
 118 #define IS_SUB4x4(type) ( (type ==D_L0_4x4)||(type ==D_L1_4x4)||(type ==D_BI_4x4))
 119 #define IS_SUB4x8(type) ( (type ==D_L0_4x8)||(type ==D_L1_4x8)||(type ==D_BI_4x8))
 120 #define IS_SUB8x4(type) ( (type ==D_L0_8x4)||(type ==D_L1_8x4)||(type ==D_BI_8x4))
 121 #define IS_SUB8x8(type) ( (type ==D_L0_8x8)||(type ==D_L1_8x8)||(type ==D_BI_8x8)||(type ==D_DIRECT_8x8))
 122 enum mb_partition_e
 123 {
 124     /* sub partition type for P_8x8 and B_8x8 */
 125     D_L0_4x4        = 0,
 126     D_L0_8x4        = 1,
 127     D_L0_4x8        = 2,
 128     D_L0_8x8        = 3,
 129
 130     /* sub partition type for B_8x8 only */
 131     D_L1_4x4        = 4,
 132     D_L1_8x4        = 5,
 133     D_L1_4x8        = 6,
 134     D_L1_8x8        = 7,
 135
 136     D_BI_4x4        = 8,
 137     D_BI_8x4        = 9,
 138     D_BI_4x8        = 10,
 139     D_BI_8x8        = 11,
 140     D_DIRECT_8x8    = 12,
 141
 142     /* partition */
 143     D_8x8           = 13,
 144     D_16x8          = 14,
 145     D_8x16          = 15,
 146     D_16x16         = 16,
 147 };
 148
 149 static const int x264_mb_partition_listX_table[2][17] =
 150 {{
 151     1, 1, 1, 1, /* D_L0_* */
 152     0, 0, 0, 0, /* D_L1_* */
 153     1, 1, 1, 1, /* D_BI_* */
 154     0,          /* D_DIRECT_8x8 */
 155     0, 0, 0, 0  /* 8x8 .. 16x16 */
 156 },
 157 {
 158     0, 0, 0, 0, /* D_L0_* */
 159     1, 1, 1, 1, /* D_L1_* */
 160     1, 1, 1, 1, /* D_BI_* */
 161     0,          /* D_DIRECT_8x8 */
 162     0, 0, 0, 0  /* 8x8 .. 16x16 */
 163 }};
 164 static const int x264_mb_partition_count_table[17] =
 165 {
 166     /* sub L0 */
 167     4, 2, 2, 1,
 168     /* sub L1 */
 169     4, 2, 2, 1,
 170     /* sub BI */
 171     4, 2, 2, 1,
 172     /* Direct */
 173     1,
 174     /* Partition */
 175     4, 2, 2, 1
 176 };
 177 static const int x264_mb_partition_pixel_table[17] =
 178 {
 179     6, 4, 5, 3, 6, 4, 5, 3, 6, 4, 5, 3, 3, 3, 1, 2, 0
 180 };
 181
 182 /* zigzags are transposed with respect to the tables in the standard */
 183 static const int x264_zigzag_scan4[16] =
 184 {
 185     0,  4,  1,  2,  5,  8, 12,  9,  6,  3,  7, 10, 13, 14, 11, 15
 186 };
 187 static const int x264_zigzag_scan8[64] =
 188 {
 189     0,  8,  1,  2,  9, 16, 24, 17, 10,  3,  4, 11, 18, 25, 32, 40,
 190    33, 26, 19, 12,  5,  6, 13, 20, 27, 34, 41, 48, 56, 49, 42, 35,
 191    28, 21, 14,  7, 15, 22, 29, 36, 43, 50, 57, 58, 51, 44, 37, 30,
 192    23, 31, 38, 45, 52, 59, 60, 53, 46, 39, 47, 54, 61, 62, 55, 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
 211 static const int i_chroma_qp_table[52] =
 212 {
 213      0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
 214     10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
 215     20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
 216     29, 30, 31, 32, 32, 33, 34, 34, 35, 35,
 217     36, 36, 37, 37, 37, 38, 38, 38, 39, 39,
 218     39, 39
 219 };
 220
 221 enum cabac_ctx_block_cat_e
 222 {
 223     DCT_LUMA_DC   = 0,
 224     DCT_LUMA_AC   = 1,
 225     DCT_LUMA_4x4  = 2,
 226     DCT_CHROMA_DC = 3,
 227     DCT_CHROMA_AC = 4,
 228     DCT_LUMA_8x8  = 5,
 229 };
 230
 231
 232 void x264_macroblock_cache_init( x264_t *h );
 233 void x264_macroblock_slice_init( x264_t *h );
 234 void x264_macroblock_cache_load( x264_t *h, int i_mb_x, int i_mb_y );
 235 void x264_macroblock_cache_save( x264_t *h );
 236 void x264_macroblock_cache_end( x264_t *h );
 237
 238 void x264_macroblock_bipred_init( x264_t *h );
 239
 240 /* x264_mb_predict_mv_16x16:
 241  *      set mvp with predicted mv for D_16x16 block
 242  *      h->mb. need only valid values from other blocks */
 243 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int mvp[2] );
 244 /* x264_mb_predict_mv_pskip:
 245  *      set mvp with predicted mv for P_SKIP
 246  *      h->mb. need only valid values from other blocks */
 247 void x264_mb_predict_mv_pskip( x264_t *h, int mv[2] );
 248 /* x264_mb_predict_mv:
 249  *      set mvp with predicted mv for all blocks except SKIP and DIRECT
 250  *      h->mb. need valid ref/partition/sub of current block to be valid
 251  *      and valid mv/ref from other blocks. */
 252 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int mvp[2] );
 253 /* x264_mb_predict_mv_direct16x16:
 254  *      set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
 255  *      h->mb. need only valid values from other blocks.
 256  *      return 1 on success, 0 on failure.
 257  *      if b_changed != NULL, set it to whether refs or mvs differ from
 258  *      before this functioncall. */
 259 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed );
 260 /* x264_mb_load_mv_direct8x8:
 261  *      set h->mb.cache.mv and h->mb.cache.ref for B_DIRECT
 262  *      must be called only after x264_mb_predict_mv_direct16x16 */
 263 void x264_mb_load_mv_direct8x8( x264_t *h, int idx );
 264 /* x264_mb_predict_mv_ref16x16:
 265  *      set mvc with D_16x16 prediction.
 266  *      uses all neighbors, even those that didn't end up using this ref.
 267  *      h->mb. need only valid values from other blocks */
 268 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int mvc[8][2], int *i_mvc );
 269
 270
 271 int  x264_mb_predict_intra4x4_mode( x264_t *h, int idx );
 272 int  x264_mb_predict_non_zero_code( x264_t *h, int idx );
 273
 274 /* x264_mb_transform_8x8_allowed:
 275  *      check whether any partition is smaller than 8x8 (or at least
 276  *      might be, according to just partition type.)
 277  *      doesn't check for intra or cbp */
 278 int  x264_mb_transform_8x8_allowed( x264_t *h );
 279
 280 void x264_mb_encode_i4x4( x264_t *h, int idx, int i_qscale );
 281 void x264_mb_encode_i8x8( x264_t *h, int idx, int i_qscale );
 282
 283 void x264_mb_mc( x264_t *h );
 284 void x264_mb_mc_8x8( x264_t *h, int i8 );
 285
 286
 287 static inline void x264_macroblock_cache_ref( x264_t *h, int x, int y, int width, int height, int i_list, int ref )
 288 {
 289     int dy, dx;
 290     for( dy = 0; dy < height; dy++ )
 291     {
 292         for( dx = 0; dx < width; dx++ )
 293         {
 294             h->mb.cache.ref[i_list][X264_SCAN8_0+x+dx+8*(y+dy)] = ref;
 295         }
 296     }
 297 }
 298 static inline void x264_macroblock_cache_mv( x264_t *h, int x, int y, int width, int height, int i_list, int mvx, int mvy )
 299 {
 300     int dy, dx;
 301     for( dy = 0; dy < height; dy++ )
 302     {
 303         for( dx = 0; dx < width; dx++ )
 304         {
 305             h->mb.cache.mv[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][0] = mvx;
 306             h->mb.cache.mv[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][1] = mvy;
 307         }
 308     }
 309 }
 310 static inline void x264_macroblock_cache_mvd( x264_t *h, int x, int y, int width, int height, int i_list, int mdx, int mdy )
 311 {
 312     int dy, dx;
 313     for( dy = 0; dy < height; dy++ )
 314     {
 315         for( dx = 0; dx < width; dx++ )
 316         {
 317             h->mb.cache.mvd[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][0] = mdx;
 318             h->mb.cache.mvd[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][1] = mdy;
 319         }
 320     }
 321 }
 322 static inline void x264_macroblock_cache_skip( x264_t *h, int x, int y, int width, int height, int b_skip )
 323 {
 324     int dy, dx;
 325     for( dy = 0; dy < height; dy++ )
 326     {
 327         for( dx = 0; dx < width; dx++ )
 328         {
 329             h->mb.cache.skip[X264_SCAN8_0+x+dx+8*(y+dy)] = b_skip;
 330         }
 331     }
 332 }
 333 static inline void x264_macroblock_cache_intra8x8_pred( x264_t *h, int x, int y, int i_mode )
 334 {
 335     int *cache = &h->mb.cache.intra4x4_pred_mode[X264_SCAN8_0+x+8*y];
 336     cache[0] = cache[1] = cache[8] = cache[9] = i_mode;
 337 }
 338
 339 #endif
 340