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 || (type) == I_PCM )
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_list_table[X264_MBTYPE_MAX][2][2] =
96 {{0,0},{0,0}}, {{0,0},{0,0}}, {{0,0},{0,0}}, {{0,0},{0,0}}, /* INTRA */
97 {{1,1},{0,0}}, /* P_L0 */
98 {{0,0},{0,0}}, /* P_8x8 */
99 {{1,1},{0,0}}, /* P_SKIP */
100 {{0,0},{0,0}}, /* B_DIRECT */
101 {{1,1},{0,0}}, {{1,0},{0,1}}, {{1,1},{0,1}}, /* B_L0_* */
102 {{0,1},{1,0}}, {{0,0},{1,1}}, {{0,1},{1,1}}, /* B_L1_* */
103 {{1,1},{1,0}}, {{1,0},{1,1}}, {{1,1},{1,1}}, /* B_BI_* */
104 {{0,0},{0,0}}, /* B_8x8 */
105 {{0,0},{0,0}} /* B_SKIP */
108 #define IS_SUB4x4(type) ( (type ==D_L0_4x4)||(type ==D_L1_4x4)||(type ==D_BI_4x4))
109 #define IS_SUB4x8(type) ( (type ==D_L0_4x8)||(type ==D_L1_4x8)||(type ==D_BI_4x8))
110 #define IS_SUB8x4(type) ( (type ==D_L0_8x4)||(type ==D_L1_8x4)||(type ==D_BI_8x4))
111 #define IS_SUB8x8(type) ( (type ==D_L0_8x8)||(type ==D_L1_8x8)||(type ==D_BI_8x8)||(type ==D_DIRECT_8x8))
114 /* sub partition type for P_8x8 and B_8x8 */
120 /* sub partition type for B_8x8 only */
137 X264_PARTTYPE_MAX = 17,
140 static const uint8_t x264_mb_partition_listX_table[2][17] =
142 1, 1, 1, 1, /* D_L0_* */
143 0, 0, 0, 0, /* D_L1_* */
144 1, 1, 1, 1, /* D_BI_* */
145 0, /* D_DIRECT_8x8 */
146 0, 0, 0, 0 /* 8x8 .. 16x16 */
149 0, 0, 0, 0, /* D_L0_* */
150 1, 1, 1, 1, /* D_L1_* */
151 1, 1, 1, 1, /* D_BI_* */
152 0, /* D_DIRECT_8x8 */
153 0, 0, 0, 0 /* 8x8 .. 16x16 */
155 static const uint8_t x264_mb_partition_count_table[17] =
168 static const uint8_t x264_mb_partition_pixel_table[17] =
170 6, 4, 5, 3, 6, 4, 5, 3, 6, 4, 5, 3, 3, 3, 1, 2, 0
173 /* zigzags are transposed with respect to the tables in the standard */
174 static const uint8_t x264_zigzag_scan4[2][16] =
176 0, 4, 1, 2, 5, 8, 12, 9, 6, 3, 7, 10, 13, 14, 11, 15
179 0, 1, 4, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
181 static const uint8_t x264_zigzag_scan8[2][64] =
183 0, 8, 1, 2, 9, 16, 24, 17, 10, 3, 4, 11, 18, 25, 32, 40,
184 33, 26, 19, 12, 5, 6, 13, 20, 27, 34, 41, 48, 56, 49, 42, 35,
185 28, 21, 14, 7, 15, 22, 29, 36, 43, 50, 57, 58, 51, 44, 37, 30,
186 23, 31, 38, 45, 52, 59, 60, 53, 46, 39, 47, 54, 61, 62, 55, 63
189 0, 1, 2, 8, 9, 3, 4, 10, 16, 11, 5, 6, 7, 12, 17, 24,
190 18, 13, 14, 15, 19, 25, 32, 26, 20, 21, 22, 23, 27, 33, 40, 34,
191 28, 29, 30, 31, 35, 41, 48, 42, 36, 37, 38, 39, 43, 49, 50, 44,
192 45, 46, 47, 51, 56, 57, 52, 53, 54, 55, 58, 59, 60, 61, 62, 63
195 static const uint8_t block_idx_x[16] =
197 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
199 static const uint8_t block_idx_y[16] =
201 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
203 static const uint8_t block_idx_xy[4][4] =
210 static const uint8_t block_idx_xy_1d[16] =
212 0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15
214 static const uint8_t block_idx_yx_1d[16] =
216 0, 4, 1, 5, 8, 12, 9, 13, 2, 6, 3, 7, 10, 14, 11, 15
218 static const uint8_t block_idx_xy_fenc[16] =
220 0*4 + 0*4*FENC_STRIDE, 1*4 + 0*4*FENC_STRIDE,
221 0*4 + 1*4*FENC_STRIDE, 1*4 + 1*4*FENC_STRIDE,
222 2*4 + 0*4*FENC_STRIDE, 3*4 + 0*4*FENC_STRIDE,
223 2*4 + 1*4*FENC_STRIDE, 3*4 + 1*4*FENC_STRIDE,
224 0*4 + 2*4*FENC_STRIDE, 1*4 + 2*4*FENC_STRIDE,
225 0*4 + 3*4*FENC_STRIDE, 1*4 + 3*4*FENC_STRIDE,
226 2*4 + 2*4*FENC_STRIDE, 3*4 + 2*4*FENC_STRIDE,
227 2*4 + 3*4*FENC_STRIDE, 3*4 + 3*4*FENC_STRIDE
229 static const uint16_t block_idx_xy_fdec[16] =
231 0*4 + 0*4*FDEC_STRIDE, 1*4 + 0*4*FDEC_STRIDE,
232 0*4 + 1*4*FDEC_STRIDE, 1*4 + 1*4*FDEC_STRIDE,
233 2*4 + 0*4*FDEC_STRIDE, 3*4 + 0*4*FDEC_STRIDE,
234 2*4 + 1*4*FDEC_STRIDE, 3*4 + 1*4*FDEC_STRIDE,
235 0*4 + 2*4*FDEC_STRIDE, 1*4 + 2*4*FDEC_STRIDE,
236 0*4 + 3*4*FDEC_STRIDE, 1*4 + 3*4*FDEC_STRIDE,
237 2*4 + 2*4*FDEC_STRIDE, 3*4 + 2*4*FDEC_STRIDE,
238 2*4 + 3*4*FDEC_STRIDE, 3*4 + 3*4*FDEC_STRIDE
241 #define QP(qP) ( (qP)+QP_BD_OFFSET )
242 static const uint8_t i_chroma_qp_table[QP_MAX+1+12*2] =
247 QP(-12),QP(-11),QP(-10), QP(-9), QP(-8), QP(-7),
250 QP(-6), QP(-5), QP(-4), QP(-3), QP(-2), QP(-1),
252 QP(0), QP(1), QP(2), QP(3), QP(4), QP(5),
253 QP(6), QP(7), QP(8), QP(9), QP(10), QP(11),
254 QP(12), QP(13), QP(14), QP(15), QP(16), QP(17),
255 QP(18), QP(19), QP(20), QP(21), QP(22), QP(23),
256 QP(24), QP(25), QP(26), QP(27), QP(28), QP(29),
257 QP(29), QP(30), QP(31), QP(32), QP(32), QP(33),
258 QP(34), QP(34), QP(35), QP(35), QP(36), QP(36),
259 QP(37), QP(37), QP(37), QP(38), QP(38), QP(38),
260 QP(39), QP(39), QP(39), QP(39),
261 QP(39), QP(39), QP(39), QP(39), QP(39), QP(39),
262 QP(39), QP(39), QP(39), QP(39), QP(39), QP(39),
266 enum cabac_ctx_block_cat_e
276 /* Per-frame allocation: is allocated per-thread only in frame-threads mode. */
277 int x264_macroblock_cache_allocate( x264_t *h );
278 void x264_macroblock_cache_free( x264_t *h );
280 /* Per-thread allocation: is allocated per-thread even in sliced-threads mode. */
281 int x264_macroblock_thread_allocate( x264_t *h, int b_lookahead );
282 void x264_macroblock_thread_free( x264_t *h, int b_lookahead );
284 void x264_macroblock_slice_init( x264_t *h );
285 void x264_macroblock_thread_init( x264_t *h );
286 void x264_macroblock_cache_load( x264_t *h, int mb_x, int mb_y );
287 void x264_macroblock_cache_load_deblock( x264_t *h );
288 void x264_macroblock_cache_load_neighbours_deblock( x264_t *h, int mb_x, int mb_y );
289 void x264_macroblock_cache_save( x264_t *h );
291 void x264_macroblock_bipred_init( x264_t *h );
293 void x264_prefetch_fenc( x264_t *h, x264_frame_t *fenc, int i_mb_x, int i_mb_y );
295 /* x264_mb_predict_mv_16x16:
296 * set mvp with predicted mv for D_16x16 block
297 * h->mb. need only valid values from other blocks */
298 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int16_t mvp[2] );
299 /* x264_mb_predict_mv_pskip:
300 * set mvp with predicted mv for P_SKIP
301 * h->mb. need only valid values from other blocks */
302 void x264_mb_predict_mv_pskip( x264_t *h, int16_t mv[2] );
303 /* x264_mb_predict_mv:
304 * set mvp with predicted mv for all blocks except SKIP and DIRECT
305 * h->mb. need valid ref/partition/sub of current block to be valid
306 * and valid mv/ref from other blocks. */
307 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int16_t mvp[2] );
308 /* x264_mb_predict_mv_direct16x16:
309 * set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
310 * h->mb. need only valid values from other blocks.
311 * return 1 on success, 0 on failure.
312 * if b_changed != NULL, set it to whether refs or mvs differ from
313 * before this functioncall. */
314 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed );
315 /* x264_mb_predict_mv_ref16x16:
316 * set mvc with D_16x16 prediction.
317 * uses all neighbors, even those that didn't end up using this ref.
318 * h->mb. need only valid values from other blocks */
319 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int16_t mvc[8][2], int *i_mvc );
321 void x264_mb_mc( x264_t *h );
322 void x264_mb_mc_8x8( x264_t *h, int i8 );
324 static ALWAYS_INLINE uint32_t pack16to32( int a, int b )
332 static ALWAYS_INLINE uint32_t pack8to16( int a, int b )
340 static ALWAYS_INLINE uint32_t pack8to32( int a, int b, int c, int d )
343 return d + (c<<8) + (b<<16) + (a<<24);
345 return a + (b<<8) + (c<<16) + (d<<24);
348 static ALWAYS_INLINE uint32_t pack16to32_mask( int a, int b )
351 return (b&0xFFFF) + (a<<16);
353 return (a&0xFFFF) + (b<<16);
356 static ALWAYS_INLINE uint64_t pack32to64( uint32_t a, uint32_t b )
358 #ifdef WORDS_BIGENDIAN
359 return b + ((uint64_t)a<<32);
361 return a + ((uint64_t)b<<32);
365 #if X264_HIGH_BIT_DEPTH
366 # define pack_pixel_1to2 pack16to32
367 # define pack_pixel_2to4 pack32to64
369 # define pack_pixel_1to2 pack8to16
370 # define pack_pixel_2to4 pack16to32
373 #define array_non_zero(a) array_non_zero_int(a, sizeof(a)/sizeof(dctcoef))
374 #define array_non_zero_int array_non_zero_int
375 static ALWAYS_INLINE int array_non_zero_int( dctcoef *v, int i_count )
377 for( int i = 0; i < i_count; i++ )
382 static ALWAYS_INLINE int x264_mb_predict_intra4x4_mode( x264_t *h, int idx )
384 const int ma = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 1];
385 const int mb = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 8];
386 const int m = X264_MIN( x264_mb_pred_mode4x4_fix(ma),
387 x264_mb_pred_mode4x4_fix(mb) );
390 return I_PRED_4x4_DC;
394 static ALWAYS_INLINE int x264_mb_predict_non_zero_code( x264_t *h, int idx )
396 const int za = h->mb.cache.non_zero_count[x264_scan8[idx] - 1];
397 const int zb = h->mb.cache.non_zero_count[x264_scan8[idx] - 8];
402 i_ret = ( i_ret + 1 ) >> 1;
405 /* x264_mb_transform_8x8_allowed:
406 * check whether any partition is smaller than 8x8 (or at least
407 * might be, according to just partition type.)
408 * doesn't check for cbp */
409 static ALWAYS_INLINE int x264_mb_transform_8x8_allowed( x264_t *h )
411 // intra and skip are disallowed
412 // large partitions are allowed
413 // direct and 8x8 are conditional
414 static const uint8_t partition_tab[X264_MBTYPE_MAX] = {
415 0,0,0,0,1,2,0,1,1,1,1,1,1,1,1,1,1,1,0,
418 if( !h->pps->b_transform_8x8_mode )
420 if( h->mb.i_type != P_8x8 )
421 return partition_tab[h->mb.i_type];
422 return M32( h->mb.i_sub_partition ) == D_L0_8x8*0x01010101;