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 $
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
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.
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.
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 *****************************************************************************/
25 #define _MACROBLOCK_H 1
27 enum macroblock_position_e
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 )
66 static const int x264_mb_type_fix[19] =
68 I_4x4, I_4x4, I_16x16, I_PCM,
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
73 static const int x264_mb_type_list0_table[19][2] =
75 {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
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_* */
86 static const int x264_mb_type_list1_table[19][2] =
88 {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
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_* */
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))
106 /* sub partition type for P_8x8 and B_8x8 */
112 /* sub partition type for B_8x8 only */
131 static const int x264_mb_partition_listX_table[2][17] =
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 */
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 */
146 static const int x264_mb_partition_count_table[17] =
159 static const int x264_mb_partition_pixel_table[17] =
161 6, 4, 5, 3, 6, 4, 5, 3, 6, 4, 5, 3, 3, 3, 1, 2, 0
164 static const int x264_zigzag_scan4[16] =
166 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
168 static const int x264_zigzag_scan8[64] =
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
177 void x264_macroblock_cache_init( x264_t *h );
178 void x264_macroblock_slice_init( x264_t *h );
179 void x264_macroblock_cache_load( x264_t *h, int i_mb_x, int i_mb_y );
180 void x264_macroblock_cache_save( x264_t *h );
181 void x264_macroblock_cache_end( x264_t *h );
183 void x264_macroblock_bipred_init( x264_t *h );
185 void x264_mb_dequant_4x4_dc( int16_t dct[4][4], int dequant_mf[6][4][4], int i_qscale );
186 void x264_mb_dequant_2x2_dc( int16_t dct[2][2], int dequant_mf[6][4][4], int i_qscale );
187 void x264_mb_dequant_4x4( int16_t dct[4][4], int dequant_mf[6][4][4], int i_qscale );
188 void x264_mb_dequant_8x8( int16_t dct[8][8], int dequant_mf[6][8][8], int i_qscale );
190 /* x264_mb_predict_mv_16x16:
191 * set mvp with predicted mv for D_16x16 block
192 * h->mb. need only valid values from other blocks */
193 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int mvp[2] );
194 /* x264_mb_predict_mv_pskip:
195 * set mvp with predicted mv for P_SKIP
196 * h->mb. need only valid values from other blocks */
197 void x264_mb_predict_mv_pskip( x264_t *h, int mv[2] );
198 /* x264_mb_predict_mv:
199 * set mvp with predicted mv for all blocks except SKIP and DIRECT
200 * h->mb. need valid ref/partition/sub of current block to be valid
201 * and valid mv/ref from other blocks . */
202 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int mvp[2] );
203 /* x264_mb_predict_mv_direct16x16:
204 * set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
205 * h->mb. need only valid values from other blocks
206 * return 1 on success, 0 on failure */
207 int x264_mb_predict_mv_direct16x16( x264_t *h );
208 /* x264_mb_load_mv_direct8x8:
209 * set h->mb.cache.mv and h->mb.cache.ref for B_DIRECT
210 * must be called only after x264_mb_predict_mv_direct16x16 */
211 void x264_mb_load_mv_direct8x8( x264_t *h, int idx );
212 /* x264_mb_predict_mv_ref16x16:
213 * set mvc with D_16x16 prediction.
214 * uses all neighbors, even those that didn't end up using this ref.
215 * h->mb. need only valid values from other blocks */
216 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int mvc[8][2], int *i_mvc );
219 int x264_mb_predict_intra4x4_mode( x264_t *h, int idx );
220 int x264_mb_predict_non_zero_code( x264_t *h, int idx );
222 /* x264_mb_transform_8x8_allowed:
223 * check whether any partition is smaller than 8x8 (or at least
224 * might be, according to just partition type.)
225 * doesn't check for intra or cbp */
226 int x264_mb_transform_8x8_allowed( x264_t *h );
228 void x264_mb_encode_i4x4( x264_t *h, int idx, int i_qscale );
229 void x264_mb_encode_i8x8( x264_t *h, int idx, int i_qscale );
231 void x264_mb_mc( x264_t *h );
234 static inline void x264_macroblock_cache_ref( x264_t *h, int x, int y, int width, int height, int i_list, int ref )
237 for( dy = 0; dy < height; dy++ )
239 for( dx = 0; dx < width; dx++ )
241 h->mb.cache.ref[i_list][X264_SCAN8_0+x+dx+8*(y+dy)] = ref;
245 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 )
248 for( dy = 0; dy < height; dy++ )
250 for( dx = 0; dx < width; dx++ )
252 h->mb.cache.mv[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][0] = mvx;
253 h->mb.cache.mv[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][1] = mvy;
257 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 )
260 for( dy = 0; dy < height; dy++ )
262 for( dx = 0; dx < width; dx++ )
264 h->mb.cache.mvd[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][0] = mdx;
265 h->mb.cache.mvd[i_list][X264_SCAN8_0+x+dx+8*(y+dy)][1] = mdy;
269 static inline void x264_macroblock_cache_skip( x264_t *h, int x, int y, int width, int height, int b_skip )
272 for( dy = 0; dy < height; dy++ )
274 for( dx = 0; dx < width; dx++ )
276 h->mb.cache.skip[X264_SCAN8_0+x+dx+8*(y+dy)] = b_skip;
280 static inline void x264_macroblock_cache_intra8x8_pred( x264_t *h, int x, int y, int i_mode )
282 int *cache = &h->mb.cache.intra4x4_pred_mode[X264_SCAN8_0+x+8*y];
283 cache[0] = cache[1] = cache[8] = cache[9] = i_mode;