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