1 /*****************************************************************************
2 * macroblock.h: h264 encoder library
3 *****************************************************************************
4 * Copyright (C) 2005-2008 x264 project
6 * Authors: Loren Merritt <lorenm@u.washington.edu>
7 * Laurent Aimar <fenrir@via.ecp.fr>
8 * Fiona Glaser <fiona@x264.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
23 *****************************************************************************/
25 #ifndef X264_MACROBLOCK_H
26 #define X264_MACROBLOCK_H
28 enum macroblock_position_e
40 static const uint8_t x264_pred_i4x4_neighbors[12] =
42 MB_TOP, // I_PRED_4x4_V
43 MB_LEFT, // I_PRED_4x4_H
44 MB_LEFT | MB_TOP, // I_PRED_4x4_DC
45 MB_TOP | MB_TOPRIGHT, // I_PRED_4x4_DDL
46 MB_LEFT | MB_TOPLEFT | MB_TOP, // I_PRED_4x4_DDR
47 MB_LEFT | MB_TOPLEFT | MB_TOP, // I_PRED_4x4_VR
48 MB_LEFT | MB_TOPLEFT | MB_TOP, // I_PRED_4x4_HD
49 MB_TOP | MB_TOPRIGHT, // I_PRED_4x4_VL
50 MB_LEFT, // I_PRED_4x4_HU
51 MB_LEFT, // I_PRED_4x4_DC_LEFT
52 MB_TOP, // I_PRED_4x4_DC_TOP
53 0 // I_PRED_4x4_DC_128
57 /* XXX mb_type isn't the one written in the bitstream -> only internal usage */
58 #define IS_INTRA(type) ( (type) == I_4x4 || (type) == I_8x8 || (type) == I_16x16 )
59 #define IS_SKIP(type) ( (type) == P_SKIP || (type) == B_SKIP )
60 #define IS_DIRECT(type) ( (type) == B_DIRECT )
87 static const uint8_t x264_mb_type_fix[X264_MBTYPE_MAX] =
89 I_4x4, I_4x4, I_16x16, I_PCM,
91 B_DIRECT, B_L0_L0, B_L0_L1, B_L0_BI, B_L1_L0, B_L1_L1,
92 B_L1_BI, B_BI_L0, B_BI_L1, B_BI_BI, B_8x8, B_SKIP
94 static const uint8_t x264_mb_type_list0_table[X264_MBTYPE_MAX][2] =
96 {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
100 {0,0}, /* B_DIRECT */
101 {1,1}, {1,0}, {1,1}, /* B_L0_* */
102 {0,1}, {0,0}, {0,1}, /* B_L1_* */
103 {1,1}, {1,0}, {1,1}, /* B_BI_* */
107 static const uint8_t x264_mb_type_list1_table[X264_MBTYPE_MAX][2] =
109 {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
113 {0,0}, /* B_DIRECT */
114 {0,0}, {0,1}, {0,1}, /* B_L0_* */
115 {1,0}, {1,1}, {1,1}, /* B_L1_* */
116 {1,0}, {1,1}, {1,1}, /* B_BI_* */
121 #define IS_SUB4x4(type) ( (type ==D_L0_4x4)||(type ==D_L1_4x4)||(type ==D_BI_4x4))
122 #define IS_SUB4x8(type) ( (type ==D_L0_4x8)||(type ==D_L1_4x8)||(type ==D_BI_4x8))
123 #define IS_SUB8x4(type) ( (type ==D_L0_8x4)||(type ==D_L1_8x4)||(type ==D_BI_8x4))
124 #define IS_SUB8x8(type) ( (type ==D_L0_8x8)||(type ==D_L1_8x8)||(type ==D_BI_8x8)||(type ==D_DIRECT_8x8))
127 /* sub partition type for P_8x8 and B_8x8 */
133 /* sub partition type for B_8x8 only */
152 static const uint8_t x264_mb_partition_listX_table[2][17] =
154 1, 1, 1, 1, /* D_L0_* */
155 0, 0, 0, 0, /* D_L1_* */
156 1, 1, 1, 1, /* D_BI_* */
157 0, /* D_DIRECT_8x8 */
158 0, 0, 0, 0 /* 8x8 .. 16x16 */
161 0, 0, 0, 0, /* D_L0_* */
162 1, 1, 1, 1, /* D_L1_* */
163 1, 1, 1, 1, /* D_BI_* */
164 0, /* D_DIRECT_8x8 */
165 0, 0, 0, 0 /* 8x8 .. 16x16 */
167 static const uint8_t x264_mb_partition_count_table[17] =
180 static const uint8_t x264_mb_partition_pixel_table[17] =
182 6, 4, 5, 3, 6, 4, 5, 3, 6, 4, 5, 3, 3, 3, 1, 2, 0
185 /* zigzags are transposed with respect to the tables in the standard */
186 static const uint8_t x264_zigzag_scan4[2][16] =
188 0, 4, 1, 2, 5, 8, 12, 9, 6, 3, 7, 10, 13, 14, 11, 15
191 0, 1, 4, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
193 static const uint8_t x264_zigzag_scan8[2][64] =
195 0, 8, 1, 2, 9, 16, 24, 17, 10, 3, 4, 11, 18, 25, 32, 40,
196 33, 26, 19, 12, 5, 6, 13, 20, 27, 34, 41, 48, 56, 49, 42, 35,
197 28, 21, 14, 7, 15, 22, 29, 36, 43, 50, 57, 58, 51, 44, 37, 30,
198 23, 31, 38, 45, 52, 59, 60, 53, 46, 39, 47, 54, 61, 62, 55, 63
201 0, 1, 2, 8, 9, 3, 4, 10, 16, 11, 5, 6, 7, 12, 17, 24,
202 18, 13, 14, 15, 19, 25, 32, 26, 20, 21, 22, 23, 27, 33, 40, 34,
203 28, 29, 30, 31, 35, 41, 48, 42, 36, 37, 38, 39, 43, 49, 50, 44,
204 45, 46, 47, 51, 56, 57, 52, 53, 54, 55, 58, 59, 60, 61, 62, 63
207 static const uint8_t block_idx_x[16] =
209 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
211 static const uint8_t block_idx_y[16] =
213 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
215 static const uint8_t block_idx_xy[4][4] =
223 static const uint8_t i_chroma_qp_table[52] =
225 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
226 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
227 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
228 29, 30, 31, 32, 32, 33, 34, 34, 35, 35,
229 36, 36, 37, 37, 37, 38, 38, 38, 39, 39,
233 enum cabac_ctx_block_cat_e
244 int x264_macroblock_cache_init( x264_t *h );
245 void x264_macroblock_slice_init( x264_t *h );
246 void x264_macroblock_cache_load( x264_t *h, int i_mb_x, int i_mb_y );
247 void x264_macroblock_cache_save( x264_t *h );
248 void x264_macroblock_cache_end( x264_t *h );
250 void x264_macroblock_bipred_init( x264_t *h );
252 void x264_prefetch_fenc( x264_t *h, x264_frame_t *fenc, int i_mb_x, int i_mb_y );
254 /* x264_mb_predict_mv_16x16:
255 * set mvp with predicted mv for D_16x16 block
256 * h->mb. need only valid values from other blocks */
257 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int16_t mvp[2] );
258 /* x264_mb_predict_mv_pskip:
259 * set mvp with predicted mv for P_SKIP
260 * h->mb. need only valid values from other blocks */
261 void x264_mb_predict_mv_pskip( x264_t *h, int16_t mv[2] );
262 /* x264_mb_predict_mv:
263 * set mvp with predicted mv for all blocks except SKIP and DIRECT
264 * h->mb. need valid ref/partition/sub of current block to be valid
265 * and valid mv/ref from other blocks. */
266 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int16_t mvp[2] );
267 /* x264_mb_predict_mv_direct16x16:
268 * set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
269 * h->mb. need only valid values from other blocks.
270 * return 1 on success, 0 on failure.
271 * if b_changed != NULL, set it to whether refs or mvs differ from
272 * before this functioncall. */
273 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed );
274 /* x264_mb_load_mv_direct8x8:
275 * set h->mb.cache.mv and h->mb.cache.ref for B_DIRECT
276 * must be called only after x264_mb_predict_mv_direct16x16 */
277 void x264_mb_load_mv_direct8x8( x264_t *h, int idx );
278 /* x264_mb_predict_mv_ref16x16:
279 * set mvc with D_16x16 prediction.
280 * uses all neighbors, even those that didn't end up using this ref.
281 * h->mb. need only valid values from other blocks */
282 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int16_t mvc[8][2], int *i_mvc );
285 int x264_mb_predict_intra4x4_mode( x264_t *h, int idx );
286 int x264_mb_predict_non_zero_code( x264_t *h, int idx );
288 /* x264_mb_transform_8x8_allowed:
289 * check whether any partition is smaller than 8x8 (or at least
290 * might be, according to just partition type.)
291 * doesn't check for cbp */
292 int x264_mb_transform_8x8_allowed( x264_t *h );
294 void x264_mb_mc( x264_t *h );
295 void x264_mb_mc_8x8( x264_t *h, int i8 );
297 static ALWAYS_INLINE uint32_t pack16to32( int a, int b )
299 #ifdef WORDS_BIGENDIAN
305 static ALWAYS_INLINE uint32_t pack8to16( int a, int b )
307 #ifdef WORDS_BIGENDIAN
313 static ALWAYS_INLINE uint32_t pack8to32( int a, int b, int c, int d )
315 #ifdef WORDS_BIGENDIAN
316 return d + (c<<8) + (b<<16) + (a<<24);
318 return a + (b<<8) + (c<<16) + (d<<24);
321 static ALWAYS_INLINE uint32_t pack16to32_mask( int a, int b )
323 #ifdef WORDS_BIGENDIAN
324 return (b&0xFFFF) + (a<<16);
326 return (a&0xFFFF) + (b<<16);
329 static ALWAYS_INLINE void x264_macroblock_cache_rect1( void *dst, int width, int height, uint8_t val )
334 uint32_t val2 = val * 0x01010101;
335 for( dy = 0; dy < height; dy++ )
336 ((uint32_t*)dst)[2*dy] = val2;
340 uint32_t val2 = val * 0x0101;
341 for( dy = 0; dy < height; dy++ )
342 ((uint16_t*)dst)[4*dy] = val2;
345 static ALWAYS_INLINE void x264_macroblock_cache_rect4( void *dst, int width, int height, uint32_t val )
348 if( width == 1 || WORD_SIZE < 8 )
350 for( dy = 0; dy < height; dy++ )
351 for( dx = 0; dx < width; dx++ )
352 ((uint32_t*)dst)[dx+8*dy] = val;
356 uint64_t val64 = val + ((uint64_t)val<<32);
357 for( dy = 0; dy < height; dy++ )
358 for( dx = 0; dx < width/2; dx++ )
359 ((uint64_t*)dst)[dx+4*dy] = val64;
362 #define x264_macroblock_cache_mv_ptr(a,x,y,w,h,l,mv) x264_macroblock_cache_mv(a,x,y,w,h,l,*(uint32_t*)mv)
363 static ALWAYS_INLINE void x264_macroblock_cache_mv( x264_t *h, int x, int y, int width, int height, int i_list, uint32_t mv )
365 x264_macroblock_cache_rect4( &h->mb.cache.mv[i_list][X264_SCAN8_0+x+8*y], width, height, mv );
367 static ALWAYS_INLINE void x264_macroblock_cache_mvd( x264_t *h, int x, int y, int width, int height, int i_list, uint32_t mv )
369 x264_macroblock_cache_rect4( &h->mb.cache.mvd[i_list][X264_SCAN8_0+x+8*y], width, height, mv );
371 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 )
373 x264_macroblock_cache_rect1( &h->mb.cache.ref[i_list][X264_SCAN8_0+x+8*y], width, height, ref );
375 static ALWAYS_INLINE void x264_macroblock_cache_skip( x264_t *h, int x, int y, int width, int height, int b_skip )
377 x264_macroblock_cache_rect1( &h->mb.cache.skip[X264_SCAN8_0+x+8*y], width, height, b_skip );
379 static ALWAYS_INLINE void x264_macroblock_cache_intra8x8_pred( x264_t *h, int x, int y, int i_mode )
381 int8_t *cache = &h->mb.cache.intra4x4_pred_mode[X264_SCAN8_0+x+8*y];
382 cache[0] = cache[1] = cache[8] = cache[9] = i_mode;
384 #define array_non_zero(a) array_non_zero_int(a, sizeof(a))
385 #define array_non_zero_int array_non_zero_int_c
386 static ALWAYS_INLINE int array_non_zero_int_c( void *v, int i_count )
391 else if(i_count == 16)
392 return !!(x[0]|x[1]);
393 else if(i_count == 32)
394 return !!(x[0]|x[1]|x[2]|x[3]);
398 i_count /= sizeof(uint64_t);
399 for( i = 0; i < i_count; i++ )
404 /* This function and its MMX version only work on arrays of size 16 */
405 static ALWAYS_INLINE int array_non_zero_count( int16_t *v )
410 for( i = 0, i_nz = 0; i < 16; i++ )