1 /*****************************************************************************
2 * macroblock.h: macroblock common functions
3 *****************************************************************************
4 * Copyright (C) 2005-2015 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.
24 * This program is also available under a commercial proprietary license.
25 * For more information, contact us at licensing@x264.com.
26 *****************************************************************************/
28 #ifndef X264_MACROBLOCK_H
29 #define X264_MACROBLOCK_H
31 enum macroblock_position_e
43 static const uint8_t x264_pred_i4x4_neighbors[12] =
45 MB_TOP, // I_PRED_4x4_V
46 MB_LEFT, // I_PRED_4x4_H
47 MB_LEFT | MB_TOP, // I_PRED_4x4_DC
48 MB_TOP | MB_TOPRIGHT, // I_PRED_4x4_DDL
49 MB_LEFT | MB_TOPLEFT | MB_TOP, // I_PRED_4x4_DDR
50 MB_LEFT | MB_TOPLEFT | MB_TOP, // I_PRED_4x4_VR
51 MB_LEFT | MB_TOPLEFT | MB_TOP, // I_PRED_4x4_HD
52 MB_TOP | MB_TOPRIGHT, // I_PRED_4x4_VL
53 MB_LEFT, // I_PRED_4x4_HU
54 MB_LEFT, // I_PRED_4x4_DC_LEFT
55 MB_TOP, // I_PRED_4x4_DC_TOP
56 0 // I_PRED_4x4_DC_128
60 /* XXX mb_type isn't the one written in the bitstream -> only internal usage */
61 #define IS_INTRA(type) ( (type) == I_4x4 || (type) == I_8x8 || (type) == I_16x16 || (type) == I_PCM )
62 #define IS_SKIP(type) ( (type) == P_SKIP || (type) == B_SKIP )
63 #define IS_DIRECT(type) ( (type) == B_DIRECT )
90 static const uint8_t x264_mb_type_fix[X264_MBTYPE_MAX] =
92 I_4x4, I_4x4, I_16x16, I_PCM,
94 B_DIRECT, B_L0_L0, B_L0_L1, B_L0_BI, B_L1_L0, B_L1_L1,
95 B_L1_BI, B_BI_L0, B_BI_L1, B_BI_BI, B_8x8, B_SKIP
97 static const uint8_t x264_mb_type_list_table[X264_MBTYPE_MAX][2][2] =
99 {{0,0},{0,0}}, {{0,0},{0,0}}, {{0,0},{0,0}}, {{0,0},{0,0}}, /* INTRA */
100 {{1,1},{0,0}}, /* P_L0 */
101 {{0,0},{0,0}}, /* P_8x8 */
102 {{1,1},{0,0}}, /* P_SKIP */
103 {{0,0},{0,0}}, /* B_DIRECT */
104 {{1,1},{0,0}}, {{1,0},{0,1}}, {{1,1},{0,1}}, /* B_L0_* */
105 {{0,1},{1,0}}, {{0,0},{1,1}}, {{0,1},{1,1}}, /* B_L1_* */
106 {{1,1},{1,0}}, {{1,0},{1,1}}, {{1,1},{1,1}}, /* B_BI_* */
107 {{0,0},{0,0}}, /* B_8x8 */
108 {{0,0},{0,0}} /* B_SKIP */
111 #define IS_SUB4x4(type) ( (type ==D_L0_4x4)||(type ==D_L1_4x4)||(type ==D_BI_4x4))
112 #define IS_SUB4x8(type) ( (type ==D_L0_4x8)||(type ==D_L1_4x8)||(type ==D_BI_4x8))
113 #define IS_SUB8x4(type) ( (type ==D_L0_8x4)||(type ==D_L1_8x4)||(type ==D_BI_8x4))
114 #define IS_SUB8x8(type) ( (type ==D_L0_8x8)||(type ==D_L1_8x8)||(type ==D_BI_8x8)||(type ==D_DIRECT_8x8))
117 /* sub partition type for P_8x8 and B_8x8 */
123 /* sub partition type for B_8x8 only */
140 X264_PARTTYPE_MAX = 17,
143 static const uint8_t x264_mb_partition_listX_table[2][17] =
145 1, 1, 1, 1, /* D_L0_* */
146 0, 0, 0, 0, /* D_L1_* */
147 1, 1, 1, 1, /* D_BI_* */
148 0, /* D_DIRECT_8x8 */
149 0, 0, 0, 0 /* 8x8 .. 16x16 */
152 0, 0, 0, 0, /* D_L0_* */
153 1, 1, 1, 1, /* D_L1_* */
154 1, 1, 1, 1, /* D_BI_* */
155 0, /* D_DIRECT_8x8 */
156 0, 0, 0, 0 /* 8x8 .. 16x16 */
158 static const uint8_t x264_mb_partition_count_table[17] =
171 static const uint8_t x264_mb_partition_pixel_table[17] =
173 PIXEL_4x4, PIXEL_8x4, PIXEL_4x8, PIXEL_8x8, /* D_L0_* */
174 PIXEL_4x4, PIXEL_8x4, PIXEL_4x8, PIXEL_8x8, /* D_L1_* */
175 PIXEL_4x4, PIXEL_8x4, PIXEL_4x8, PIXEL_8x8, /* D_BI_* */
176 PIXEL_8x8, /* D_DIRECT_8x8 */
177 PIXEL_8x8, PIXEL_16x8, PIXEL_8x16, PIXEL_16x16, /* 8x8 .. 16x16 */
180 /* zigzags are transposed with respect to the tables in the standard */
181 static const uint8_t x264_zigzag_scan4[2][16] =
183 0, 4, 1, 2, 5, 8, 12, 9, 6, 3, 7, 10, 13, 14, 11, 15
186 0, 1, 4, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
188 static const uint8_t x264_zigzag_scan8[2][64] =
190 0, 8, 1, 2, 9, 16, 24, 17, 10, 3, 4, 11, 18, 25, 32, 40,
191 33, 26, 19, 12, 5, 6, 13, 20, 27, 34, 41, 48, 56, 49, 42, 35,
192 28, 21, 14, 7, 15, 22, 29, 36, 43, 50, 57, 58, 51, 44, 37, 30,
193 23, 31, 38, 45, 52, 59, 60, 53, 46, 39, 47, 54, 61, 62, 55, 63
196 0, 1, 2, 8, 9, 3, 4, 10, 16, 11, 5, 6, 7, 12, 17, 24,
197 18, 13, 14, 15, 19, 25, 32, 26, 20, 21, 22, 23, 27, 33, 40, 34,
198 28, 29, 30, 31, 35, 41, 48, 42, 36, 37, 38, 39, 43, 49, 50, 44,
199 45, 46, 47, 51, 56, 57, 52, 53, 54, 55, 58, 59, 60, 61, 62, 63
202 static const uint8_t block_idx_x[16] =
204 0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
206 static const uint8_t block_idx_y[16] =
208 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
210 static const uint8_t block_idx_xy[4][4] =
217 static const uint8_t block_idx_xy_1d[16] =
219 0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15
221 static const uint8_t block_idx_yx_1d[16] =
223 0, 4, 1, 5, 8, 12, 9, 13, 2, 6, 3, 7, 10, 14, 11, 15
225 static const uint8_t block_idx_xy_fenc[16] =
227 0*4 + 0*4*FENC_STRIDE, 1*4 + 0*4*FENC_STRIDE,
228 0*4 + 1*4*FENC_STRIDE, 1*4 + 1*4*FENC_STRIDE,
229 2*4 + 0*4*FENC_STRIDE, 3*4 + 0*4*FENC_STRIDE,
230 2*4 + 1*4*FENC_STRIDE, 3*4 + 1*4*FENC_STRIDE,
231 0*4 + 2*4*FENC_STRIDE, 1*4 + 2*4*FENC_STRIDE,
232 0*4 + 3*4*FENC_STRIDE, 1*4 + 3*4*FENC_STRIDE,
233 2*4 + 2*4*FENC_STRIDE, 3*4 + 2*4*FENC_STRIDE,
234 2*4 + 3*4*FENC_STRIDE, 3*4 + 3*4*FENC_STRIDE
236 static const uint16_t block_idx_xy_fdec[16] =
238 0*4 + 0*4*FDEC_STRIDE, 1*4 + 0*4*FDEC_STRIDE,
239 0*4 + 1*4*FDEC_STRIDE, 1*4 + 1*4*FDEC_STRIDE,
240 2*4 + 0*4*FDEC_STRIDE, 3*4 + 0*4*FDEC_STRIDE,
241 2*4 + 1*4*FDEC_STRIDE, 3*4 + 1*4*FDEC_STRIDE,
242 0*4 + 2*4*FDEC_STRIDE, 1*4 + 2*4*FDEC_STRIDE,
243 0*4 + 3*4*FDEC_STRIDE, 1*4 + 3*4*FDEC_STRIDE,
244 2*4 + 2*4*FDEC_STRIDE, 3*4 + 2*4*FDEC_STRIDE,
245 2*4 + 3*4*FDEC_STRIDE, 3*4 + 3*4*FDEC_STRIDE
248 #define QP(qP) ( (qP)+QP_BD_OFFSET )
249 static const uint8_t i_chroma_qp_table[QP_MAX+1+12*2] =
254 QP(-12),QP(-11),QP(-10), QP(-9), QP(-8), QP(-7),
257 QP(-6), QP(-5), QP(-4), QP(-3), QP(-2), QP(-1),
259 QP(0), QP(1), QP(2), QP(3), QP(4), QP(5),
260 QP(6), QP(7), QP(8), QP(9), QP(10), QP(11),
261 QP(12), QP(13), QP(14), QP(15), QP(16), QP(17),
262 QP(18), QP(19), QP(20), QP(21), QP(22), QP(23),
263 QP(24), QP(25), QP(26), QP(27), QP(28), QP(29),
264 QP(29), QP(30), QP(31), QP(32), QP(32), QP(33),
265 QP(34), QP(34), QP(35), QP(35), QP(36), QP(36),
266 QP(37), QP(37), QP(37), QP(38), QP(38), QP(38),
267 QP(39), QP(39), QP(39), QP(39),
268 QP(39), QP(39), QP(39), QP(39), QP(39), QP(39),
269 QP(39), QP(39), QP(39), QP(39), QP(39), QP(39),
273 enum cabac_ctx_block_cat_e
287 DCT_CHROMAV_4x4 = 12,
288 DCT_CHROMAV_8x8 = 13,
291 static const uint8_t ctx_cat_plane[6][3] =
293 { DCT_LUMA_DC, DCT_CHROMAU_DC, DCT_CHROMAV_DC},
294 { DCT_LUMA_AC, DCT_CHROMAU_AC, DCT_CHROMAV_AC},
295 {DCT_LUMA_4x4, DCT_CHROMAU_4x4, DCT_CHROMAV_4x4},
298 {DCT_LUMA_8x8, DCT_CHROMAU_8x8, DCT_CHROMAV_8x8}
301 /* Per-frame allocation: is allocated per-thread only in frame-threads mode. */
302 int x264_macroblock_cache_allocate( x264_t *h );
303 void x264_macroblock_cache_free( x264_t *h );
305 /* Per-thread allocation: is allocated per-thread even in sliced-threads mode. */
306 int x264_macroblock_thread_allocate( x264_t *h, int b_lookahead );
307 void x264_macroblock_thread_free( x264_t *h, int b_lookahead );
309 void x264_macroblock_slice_init( x264_t *h );
310 void x264_macroblock_thread_init( x264_t *h );
311 void x264_macroblock_cache_load_progressive( x264_t *h, int mb_x, int mb_y );
312 void x264_macroblock_cache_load_interlaced( x264_t *h, int mb_x, int mb_y );
313 void x264_macroblock_deblock_strength( x264_t *h );
314 void x264_macroblock_cache_save( x264_t *h );
316 void x264_macroblock_bipred_init( x264_t *h );
318 void x264_prefetch_fenc( x264_t *h, x264_frame_t *fenc, int i_mb_x, int i_mb_y );
320 void x264_copy_column8( pixel *dst, pixel *src );
322 /* x264_mb_predict_mv_16x16:
323 * set mvp with predicted mv for D_16x16 block
324 * h->mb. need only valid values from other blocks */
325 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int16_t mvp[2] );
326 /* x264_mb_predict_mv_pskip:
327 * set mvp with predicted mv for P_SKIP
328 * h->mb. need only valid values from other blocks */
329 void x264_mb_predict_mv_pskip( x264_t *h, int16_t mv[2] );
330 /* x264_mb_predict_mv:
331 * set mvp with predicted mv for all blocks except SKIP and DIRECT
332 * h->mb. need valid ref/partition/sub of current block to be valid
333 * and valid mv/ref from other blocks. */
334 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int16_t mvp[2] );
335 /* x264_mb_predict_mv_direct16x16:
336 * set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
337 * h->mb. need only valid values from other blocks.
338 * return 1 on success, 0 on failure.
339 * if b_changed != NULL, set it to whether refs or mvs differ from
340 * before this functioncall. */
341 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed );
342 /* x264_mb_predict_mv_ref16x16:
343 * set mvc with D_16x16 prediction.
344 * uses all neighbors, even those that didn't end up using this ref.
345 * h->mb. need only valid values from other blocks */
346 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int16_t mvc[8][2], int *i_mvc );
348 void x264_mb_mc( x264_t *h );
349 void x264_mb_mc_8x8( x264_t *h, int i8 );
351 static ALWAYS_INLINE uint32_t pack16to32( uint32_t a, uint32_t b )
359 static ALWAYS_INLINE uint32_t pack8to16( uint32_t a, uint32_t b )
367 static ALWAYS_INLINE uint32_t pack8to32( uint32_t a, uint32_t b, uint32_t c, uint32_t d )
370 return d + (c<<8) + (b<<16) + (a<<24);
372 return a + (b<<8) + (c<<16) + (d<<24);
375 static ALWAYS_INLINE uint32_t pack16to32_mask( int a, int b )
378 return (b&0xFFFF) + (a<<16);
380 return (a&0xFFFF) + (b<<16);
383 static ALWAYS_INLINE uint64_t pack32to64( uint32_t a, uint32_t b )
386 return b + ((uint64_t)a<<32);
388 return a + ((uint64_t)b<<32);
393 # define pack_pixel_1to2 pack16to32
394 # define pack_pixel_2to4 pack32to64
396 # define pack_pixel_1to2 pack8to16
397 # define pack_pixel_2to4 pack16to32
400 static ALWAYS_INLINE int x264_mb_predict_intra4x4_mode( x264_t *h, int idx )
402 const int ma = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 1];
403 const int mb = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 8];
404 const int m = X264_MIN( x264_mb_pred_mode4x4_fix(ma),
405 x264_mb_pred_mode4x4_fix(mb) );
408 return I_PRED_4x4_DC;
412 static ALWAYS_INLINE int x264_mb_predict_non_zero_code( x264_t *h, int idx )
414 const int za = h->mb.cache.non_zero_count[x264_scan8[idx] - 1];
415 const int zb = h->mb.cache.non_zero_count[x264_scan8[idx] - 8];
420 i_ret = ( i_ret + 1 ) >> 1;
424 /* intra and skip are disallowed, p8x8 is conditional. */
425 static const uint8_t x264_transform_allowed[X264_MBTYPE_MAX] =
427 0,0,0,0,1,2,0,1,1,1,1,1,1,1,1,1,1,1,0
430 /* x264_mb_transform_8x8_allowed:
431 * check whether any partition is smaller than 8x8 (or at least
432 * might be, according to just partition type.)
433 * doesn't check for cbp */
434 static ALWAYS_INLINE int x264_mb_transform_8x8_allowed( x264_t *h )
436 if( !h->pps->b_transform_8x8_mode )
438 if( h->mb.i_type != P_8x8 )
439 return x264_transform_allowed[h->mb.i_type];
440 return M32( h->mb.i_sub_partition ) == D_L0_8x8*0x01010101;