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
  33     MB_PRIVATE  = 0x10,
  34 };
  35
  36
  37 /* XXX mb_type isn't the one written in the bitstream -> only internal usage */
  38 #define IS_INTRA(type) ( (type) == I_4x4 || (type) == I_16x16 )
  39 #define IS_SKIP(type)  ( (type) == P_SKIP || (type) == B_SKIP )
  40 #define IS_DIRECT(type)  ( (type) == B_DIRECT )
  41 enum mb_class_e
  42 {
  43     I_4x4           = 0,
  44     I_16x16         = 1,
  45     I_PCM           = 2,
  46
  47     P_L0            = 3,
  48     P_8x8           = 4,
  49     P_SKIP          = 5,
  50
  51     B_DIRECT        = 6,
  52     B_L0_L0         = 7,
  53     B_L0_L1         = 8,
  54     B_L0_BI         = 9,
  55     B_L1_L0         = 10,
  56     B_L1_L1         = 11,
  57     B_L1_BI         = 12,
  58     B_BI_L0         = 13,
  59     B_BI_L1         = 14,
  60     B_BI_BI         = 15,
  61     B_8x8           = 16,
  62     B_SKIP          = 17,
  63 };
  64 static const int x264_mb_type_list0_table[18][2] =
  65 {
  66     {0,0}, {0,0}, {0,0},    /* INTRA */
  67     {1,1},                  /* P_L0 */
  68     {0,0},                  /* P_8x8 */
  69     {1,1},                  /* P_SKIP */
  70     {0,0},                  /* B_DIRECT */
  71     {1,1}, {1,0}, {1,1},    /* B_L0_* */
  72     {0,1}, {0,0}, {0,1},    /* B_L1_* */
  73     {1,1}, {1,0}, {1,1},    /* B_BI_* */
  74     {0,0},                  /* B_8x8 */
  75     {0,0}                   /* B_SKIP */
  76 };
  77 static const int x264_mb_type_list1_table[18][2] =
  78 {
  79     {0,0}, {0,0}, {0,0},    /* INTRA */
  80     {0,0},                  /* P_L0 */
  81     {0,0},                  /* P_8x8 */
  82     {0,0},                  /* P_SKIP */
  83     {0,0},                  /* B_DIRECT */
  84     {0,0}, {0,1}, {0,1},    /* B_L0_* */
  85     {1,0}, {1,1}, {1,1},    /* B_L1_* */
  86     {1,0}, {1,1}, {1,1},    /* B_BI_* */
  87     {0,0},                  /* B_8x8 */
  88     {0,0}                   /* B_SKIP */
  89 };
  90
  91 #define IS_SUB4x4(type) ( (type ==D_L0_4x4)||(type ==D_L1_4x4)||(type ==D_BI_4x4))
  92 #define IS_SUB4x8(type) ( (type ==D_L0_4x8)||(type ==D_L1_4x8)||(type ==D_BI_4x8))
  93 #define IS_SUB8x4(type) ( (type ==D_L0_8x4)||(type ==D_L1_8x4)||(type ==D_BI_8x4))
  94 #define IS_SUB8x8(type) ( (type ==D_L0_8x8)||(type ==D_L1_8x8)||(type ==D_BI_8x8)||(type ==D_DIRECT_8x8))
  95 enum mb_partition_e
  96 {
  97     /* sub partition type for P_8x8 and B_8x8 */
  98     D_L0_4x4        = 0,
  99     D_L0_8x4        = 1,
 100     D_L0_4x8        = 2,
 101     D_L0_8x8        = 3,
 102
 103     /* sub partition type for B_8x8 only */
 104     D_L1_4x4        = 4,
 105     D_L1_8x4        = 5,
 106     D_L1_4x8        = 6,
 107     D_L1_8x8        = 7,
 108
 109     D_BI_4x4        = 8,
 110     D_BI_8x4        = 9,
 111     D_BI_4x8        = 10,
 112     D_BI_8x8        = 11,
 113     D_DIRECT_8x8    = 12,
 114
 115     /* partition */
 116     D_8x8           = 13,
 117     D_16x8          = 14,
 118     D_8x16          = 15,
 119     D_16x16         = 16,
 120 };
 121
 122 static const int x264_mb_partition_listX_table[2][17] =
 123 {{
 124     1, 1, 1, 1, /* D_L0_* */
 125     0, 0, 0, 0, /* D_L1_* */
 126     1, 1, 1, 1, /* D_BI_* */
 127     0,          /* D_DIRECT_8x8 */
 128     0, 0, 0, 0  /* 8x8 .. 16x16 */
 129 },
 130 {
 131     0, 0, 0, 0, /* D_L0_* */
 132     1, 1, 1, 1, /* D_L1_* */
 133     1, 1, 1, 1, /* D_BI_* */
 134     0,          /* D_DIRECT_8x8 */
 135     0, 0, 0, 0  /* 8x8 .. 16x16 */
 136 }};
 137 static const int x264_mb_partition_count_table[17] =
 138 {
 139     /* sub L0 */
 140     4, 2, 2, 1,
 141     /* sub L1 */
 142     4, 2, 2, 1,
 143     /* sub BI */
 144     4, 2, 2, 1,
 145     /* Direct */
 146     1,
 147     /* Partition */
 148     4, 2, 2, 1
 149 };
 150
 151 void x264_macroblock_cache_init( x264_t *h );
 152 void x264_macroblock_slice_init( x264_t *h );
 153 void x264_macroblock_cache_load( x264_t *h, int i_mb_x, int i_mb_y );
 154 void x264_macroblock_cache_save( x264_t *h );
 155 void x264_macroblock_cache_end( x264_t *h );
 156
 157 void x264_macroblock_bipred_init( x264_t *h );
 158
 159 void x264_mb_dequant_4x4_dc( int16_t dct[4][4], int i_qscale );
 160 void x264_mb_dequant_2x2_dc( int16_t dct[2][2], int i_qscale );
 161 void x264_mb_dequant_4x4( int16_t dct[4][4], int i_qscale );
 162
 163 /* x264_mb_predict_mv_16x16:
 164  *      set mvp with predicted mv for D_16x16 block
 165  *      h->mb. need only valid values from other blocks */
 166 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int mvp[2] );
 167 /* x264_mb_predict_mv_pskip:
 168  *      set mvp with predicted mv for P_SKIP
 169  *      h->mb. need only valid values from other blocks */
 170 void x264_mb_predict_mv_pskip( x264_t *h, int mv[2] );
 171 /* x264_mb_predict_mv:
 172  *      set mvp with predicted mv for all blocks except SKIP and DIRECT
 173  *      h->mb. need valid ref/partition/sub of current block to be valid
 174  *      and valid mv/ref from other blocks . */
 175 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int mvp[2] );
 176 /* x264_mb_predict_mv_direct16x16:
 177  *      set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
 178  *      h->mb. need only valid values from other blocks
 179  *      return 1 on success, 0 on failure */
 180 int x264_mb_predict_mv_direct16x16( x264_t *h );
 181 /* x264_mb_load_mv_direct8x8:
 182  *      set h->mb.cache.mv and h->mb.cache.ref for B_DIRECT
 183  *      must be called only after x264_mb_predict_mv_direct16x16 */
 184 void x264_mb_load_mv_direct8x8( x264_t *h, int idx );
 185 /* x264_mb_predict_mv_ref16x16:
 186  *      set mvc with D_16x16 prediction.
 187  *      uses all neighbors, even those that didn't end up using this ref.
 188  *      h->mb. need only valid values from other blocks */
 189 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int mvc[5][2], int *i_mvc );
 190
 191
 192 int  x264_mb_predict_intra4x4_mode( x264_t *h, int idx );
 193 int  x264_mb_predict_non_zero_code( x264_t *h, int idx );
 194
 195 void x264_mb_encode_i4x4( x264_t *h, int idx, int i_qscale );
 196
 197 void x264_mb_mc( x264_t *h );
 198
 199
 200 static inline void x264_macroblock_cache_ref( x264_t *h, int x, int y, int width, int height, int i_list, int ref )
 201 {
 202     int dy, dx;
 203     for( dy = 0; dy < height; dy++ )
 204     {
 205         for( dx = 0; dx < width; dx++ )
 206         {
 207             h->mb.cache.ref[i_list][X264_SCAN8_0+x+dx+8*(y+dy)] = ref;
 208         }
 209     }
 210 }
 211 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 )
 212 {
 213     int dy, dx;
 214     for( dy = 0; dy < height; dy++ )
 215     {
 216         for( dx = 0; dx < width; dx++ )
 217         {
 218             h->mb.cache.mv[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][0] = mvx;
 219             h->mb.cache.mv[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][1] = mvy;
 220         }
 221     }
 222 }
 223 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 )
 224 {
 225     int dy, dx;
 226     for( dy = 0; dy < height; dy++ )
 227     {
 228         for( dx = 0; dx < width; dx++ )
 229         {
 230             h->mb.cache.mvd[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][0] = mdx;
 231             h->mb.cache.mvd[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][1] = mdy;
 232         }
 233     }
 234 }
 235 static inline void x264_macroblock_cache_skip( x264_t *h, int x, int y, int width, int height, int b_skip )
 236 {
 237     int dy, dx;
 238     for( dy = 0; dy < height; dy++ )
 239     {
 240         for( dx = 0; dx < width; dx++ )
 241         {
 242             h->mb.cache.skip[X264_SCAN8_0+x+dx+8*(y+dy)] = b_skip;
 243         }
 244     }
 245 }
 246
 247 #endif
 248