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
39 static const uint8_t x264_pred_i4x4_neighbors[12] =
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
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 )
86 static const uint8_t x264_mb_type_fix[X264_MBTYPE_MAX] =
88 I_4x4, I_4x4, I_16x16, I_PCM,
90 B_DIRECT, B_L0_L0, B_L0_L1, B_L0_BI, B_L1_L0, B_L1_L1,
91 B_L1_BI, B_BI_L0, B_BI_L1, B_BI_BI, B_8x8, B_SKIP
93 static const uint8_t x264_mb_type_list0_table[X264_MBTYPE_MAX][2] =
95 {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
100 {1,1}, {1,0}, {1,1}, /* B_L0_* */
101 {0,1}, {0,0}, {0,1}, /* B_L1_* */
102 {1,1}, {1,0}, {1,1}, /* B_BI_* */
106 static const uint8_t x264_mb_type_list1_table[X264_MBTYPE_MAX][2] =
108 {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
112 {0,0}, /* B_DIRECT */
113 {0,0}, {0,1}, {0,1}, /* B_L0_* */
114 {1,0}, {1,1}, {1,1}, /* B_L1_* */
115 {1,0}, {1,1}, {1,1}, /* B_BI_* */
120 #define IS_SUB4x4(type) ( (type ==D_L0_4x4)||(type ==D_L1_4x4)||(type ==D_BI_4x4))
121 #define IS_SUB4x8(type) ( (type ==D_L0_4x8)||(type ==D_L1_4x8)||(type ==D_BI_4x8))
122 #define IS_SUB8x4(type) ( (type ==D_L0_8x4)||(type ==D_L1_8x4)||(type ==D_BI_8x4))
123 #define IS_SUB8x8(type) ( (type ==D_L0_8x8)||(type ==D_L1_8x8)||(type ==D_BI_8x8)||(type ==D_DIRECT_8x8))
126 /* sub partition type for P_8x8 and B_8x8 */
132 /* sub partition type for B_8x8 only */
151 static const uint8_t x264_mb_partition_listX_table[2][17] =
153 1, 1, 1, 1, /* D_L0_* */
154 0, 0, 0, 0, /* D_L1_* */
155 1, 1, 1, 1, /* D_BI_* */
156 0, /* D_DIRECT_8x8 */
157 0, 0, 0, 0 /* 8x8 .. 16x16 */
160 0, 0, 0, 0, /* D_L0_* */
161 1, 1, 1, 1, /* D_L1_* */
162 1, 1, 1, 1, /* D_BI_* */
163 0, /* D_DIRECT_8x8 */
164 0, 0, 0, 0 /* 8x8 .. 16x16 */
166 static const uint8_t x264_mb_partition_count_table[17] =
179 static const uint8_t x264_mb_partition_pixel_table[17] =
181 6, 4, 5, 3, 6, 4, 5, 3, 6, 4, 5, 3, 3, 3, 1, 2, 0
184 /* zigzags are transposed with respect to the tables in the standard */
185 static const uint8_t x264_zigzag_scan4[2][16] =
187 0, 4, 1, 2, 5, 8, 12, 9, 6, 3, 7, 10, 13, 14, 11, 15
190 0, 1, 4, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
192 static const uint8_t x264_zigzag_scan8[2][64] =
194 0, 8, 1, 2, 9, 16, 24, 17, 10, 3, 4, 11, 18, 25, 32, 40,
195 33, 26, 19, 12, 5, 6, 13, 20, 27, 34, 41, 48, 56, 49, 42, 35,
196 28, 21, 14, 7, 15, 22, 29, 36, 43, 50, 57, 58, 51, 44, 37, 30,
197 23, 31, 38, 45, 52, 59, 60, 53, 46, 39, 47, 54, 61, 62, 55, 63
200 0, 1, 2, 8, 9, 3, 4, 10, 16, 11, 5, 6, 7, 12, 17, 24,
201 18, 13, 14, 15, 19, 25, 32, 26, 20, 21, 22, 23, 27, 33, 40, 34,
202 28, 29, 30, 31, 35, 41, 48, 42, 36, 37, 38, 39, 43, 49, 50, 44,
203 45, 46, 47, 51, 56, 57, 52, 53, 54, 55, 58, 59, 60, 61, 62, 63
206 static const uint8_t block_idx_x[16] =
208 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
210 static const uint8_t block_idx_y[16] =
212 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
214 static const uint8_t block_idx_xy[4][4] =
222 static const uint8_t i_chroma_qp_table[52] =
224 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
225 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
226 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
227 29, 30, 31, 32, 32, 33, 34, 34, 35, 35,
228 36, 36, 37, 37, 37, 38, 38, 38, 39, 39,
232 enum cabac_ctx_block_cat_e
243 int x264_macroblock_cache_init( x264_t *h );
244 void x264_macroblock_slice_init( x264_t *h );
245 void x264_macroblock_cache_load( x264_t *h, int i_mb_x, int i_mb_y );
246 void x264_macroblock_cache_save( x264_t *h );
247 void x264_macroblock_cache_end( x264_t *h );
249 void x264_macroblock_bipred_init( x264_t *h );
251 void x264_prefetch_fenc( x264_t *h, x264_frame_t *fenc, int i_mb_x, int i_mb_y );
253 /* x264_mb_predict_mv_16x16:
254 * set mvp with predicted mv for D_16x16 block
255 * h->mb. need only valid values from other blocks */
256 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int mvp[2] );
257 /* x264_mb_predict_mv_pskip:
258 * set mvp with predicted mv for P_SKIP
259 * h->mb. need only valid values from other blocks */
260 void x264_mb_predict_mv_pskip( x264_t *h, int mv[2] );
261 /* x264_mb_predict_mv:
262 * set mvp with predicted mv for all blocks except SKIP and DIRECT
263 * h->mb. need valid ref/partition/sub of current block to be valid
264 * and valid mv/ref from other blocks. */
265 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int mvp[2] );
266 /* x264_mb_predict_mv_direct16x16:
267 * set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
268 * h->mb. need only valid values from other blocks.
269 * return 1 on success, 0 on failure.
270 * if b_changed != NULL, set it to whether refs or mvs differ from
271 * before this functioncall. */
272 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed );
273 /* x264_mb_load_mv_direct8x8:
274 * set h->mb.cache.mv and h->mb.cache.ref for B_DIRECT
275 * must be called only after x264_mb_predict_mv_direct16x16 */
276 void x264_mb_load_mv_direct8x8( x264_t *h, int idx );
277 /* x264_mb_predict_mv_ref16x16:
278 * set mvc with D_16x16 prediction.
279 * uses all neighbors, even those that didn't end up using this ref.
280 * h->mb. need only valid values from other blocks */
281 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int mvc[8][2], int *i_mvc );
284 int x264_mb_predict_intra4x4_mode( x264_t *h, int idx );
285 int x264_mb_predict_non_zero_code( x264_t *h, int idx );
287 /* x264_mb_transform_8x8_allowed:
288 * check whether any partition is smaller than 8x8 (or at least
289 * might be, according to just partition type.)
290 * doesn't check for cbp */
291 int x264_mb_transform_8x8_allowed( x264_t *h );
293 void x264_mb_mc( x264_t *h );
294 void x264_mb_mc_8x8( x264_t *h, int i8 );
297 static ALWAYS_INLINE void x264_macroblock_cache_rect1( void *dst, int width, int height, uint8_t val )
302 uint32_t val2 = val * 0x01010101;
303 for( dy = 0; dy < height; dy++ )
304 ((uint32_t*)dst)[2*dy] = val2;
308 uint32_t val2 = val * 0x0101;
309 for( dy = 0; dy < height; dy++ )
310 ((uint16_t*)dst)[4*dy] = val2;
313 static ALWAYS_INLINE void x264_macroblock_cache_rect4( void *dst, int width, int height, uint32_t val )
316 for( dy = 0; dy < height; dy++ )
317 for( dx = 0; dx < width; dx++ )
318 ((uint32_t*)dst)[dx+8*dy] = val;
320 static ALWAYS_INLINE uint32_t pack16to32_clip( int a, int b )
322 #ifdef WORDS_BIGENDIAN
323 return (b&0xFFFF) + (a<<16);
325 return (a&0xFFFF) + (b<<16);
329 static ALWAYS_INLINE void x264_macroblock_cache_ref( x264_t *h, int x, int y, int width, int height, int i_list, uint8_t ref )
331 x264_macroblock_cache_rect1( &h->mb.cache.ref[i_list][X264_SCAN8_0+x+8*y], width, height, ref );
333 static ALWAYS_INLINE void x264_macroblock_cache_mv( x264_t *h, int x, int y, int width, int height, int i_list, int mvx, int mvy )
335 x264_macroblock_cache_rect4( &h->mb.cache.mv[i_list][X264_SCAN8_0+x+8*y], width, height, pack16to32_clip(mvx,mvy) );
337 static ALWAYS_INLINE void x264_macroblock_cache_mvd( x264_t *h, int x, int y, int width, int height, int i_list, int mdx, int mdy )
339 x264_macroblock_cache_rect4( &h->mb.cache.mvd[i_list][X264_SCAN8_0+x+8*y], width, height, pack16to32_clip(mdx,mdy) );
341 static ALWAYS_INLINE void x264_macroblock_cache_skip( x264_t *h, int x, int y, int width, int height, int b_skip )
343 x264_macroblock_cache_rect1( &h->mb.cache.skip[X264_SCAN8_0+x+8*y], width, height, b_skip );
345 static ALWAYS_INLINE void x264_macroblock_cache_intra8x8_pred( x264_t *h, int x, int y, int i_mode )
347 int8_t *cache = &h->mb.cache.intra4x4_pred_mode[X264_SCAN8_0+x+8*y];
348 cache[0] = cache[1] = cache[8] = cache[9] = i_mode;