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