Various performance optimizations
[x262.git] / common / macroblock.h
1 /*****************************************************************************
2  * macroblock.h: h264 encoder library
3  *****************************************************************************
4  * Copyright (C) 2005-2008 x264 project
5  *
6  * Authors: Loren Merritt <lorenm@u.washington.edu>
7  *          Laurent Aimar <fenrir@via.ecp.fr>
8  *          Jason Garrett-Glaser <darkshikari@gmail.com>
9  *
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.
14  *
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.
19  *
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  *****************************************************************************/
24
25 #ifndef X264_MACROBLOCK_H
26 #define X264_MACROBLOCK_H
27
28 enum macroblock_position_e
29 {
30     MB_LEFT     = 0x01,
31     MB_TOP      = 0x02,
32     MB_TOPRIGHT = 0x04,
33     MB_TOPLEFT  = 0x08,
34
35     MB_PRIVATE  = 0x10,
36
37     ALL_NEIGHBORS = 0xf,
38 };
39
40 static const uint8_t x264_pred_i4x4_neighbors[12] =
41 {
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
54 };
55
56
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 )
61 enum mb_class_e
62 {
63     I_4x4           = 0,
64     I_8x8           = 1,
65     I_16x16         = 2,
66     I_PCM           = 3,
67
68     P_L0            = 4,
69     P_8x8           = 5,
70     P_SKIP          = 6,
71
72     B_DIRECT        = 7,
73     B_L0_L0         = 8,
74     B_L0_L1         = 9,
75     B_L0_BI         = 10,
76     B_L1_L0         = 11,
77     B_L1_L1         = 12,
78     B_L1_BI         = 13,
79     B_BI_L0         = 14,
80     B_BI_L1         = 15,
81     B_BI_BI         = 16,
82     B_8x8           = 17,
83     B_SKIP          = 18,
84
85     X264_MBTYPE_MAX = 19
86 };
87 static const uint8_t x264_mb_type_fix[X264_MBTYPE_MAX] =
88 {
89     I_4x4, I_4x4, I_16x16, I_PCM,
90     P_L0, P_8x8, P_SKIP,
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
93 };
94 static const uint8_t x264_mb_type_list_table[X264_MBTYPE_MAX][2][2] =
95 {
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 */
106 };
107
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))
112 enum mb_partition_e
113 {
114     /* sub partition type for P_8x8 and B_8x8 */
115     D_L0_4x4          = 0,
116     D_L0_8x4          = 1,
117     D_L0_4x8          = 2,
118     D_L0_8x8          = 3,
119
120     /* sub partition type for B_8x8 only */
121     D_L1_4x4          = 4,
122     D_L1_8x4          = 5,
123     D_L1_4x8          = 6,
124     D_L1_8x8          = 7,
125
126     D_BI_4x4          = 8,
127     D_BI_8x4          = 9,
128     D_BI_4x8          = 10,
129     D_BI_8x8          = 11,
130     D_DIRECT_8x8      = 12,
131
132     /* partition */
133     D_8x8             = 13,
134     D_16x8            = 14,
135     D_8x16            = 15,
136     D_16x16           = 16,
137     X264_PARTTYPE_MAX = 17,
138 };
139
140 static const uint8_t x264_mb_partition_listX_table[2][17] =
141 {{
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 */
147 },
148 {
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 */
154 }};
155 static const uint8_t x264_mb_partition_count_table[17] =
156 {
157     /* sub L0 */
158     4, 2, 2, 1,
159     /* sub L1 */
160     4, 2, 2, 1,
161     /* sub BI */
162     4, 2, 2, 1,
163     /* Direct */
164     1,
165     /* Partition */
166     4, 2, 2, 1
167 };
168 static const uint8_t x264_mb_partition_pixel_table[17] =
169 {
170     6, 4, 5, 3, 6, 4, 5, 3, 6, 4, 5, 3, 3, 3, 1, 2, 0
171 };
172
173 /* zigzags are transposed with respect to the tables in the standard */
174 static const uint8_t x264_zigzag_scan4[2][16] =
175 {{ // frame
176     0,  4,  1,  2,  5,  8, 12,  9,  6,  3,  7, 10, 13, 14, 11, 15
177 },
178 {  // field
179     0,  1,  4,  2,  3,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15
180 }};
181 static const uint8_t x264_zigzag_scan8[2][64] =
182 {{
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
187 },
188 {
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
193 }};
194
195 static const uint8_t block_idx_x[16] =
196 {
197     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
198 };
199 static const uint8_t block_idx_y[16] =
200 {
201     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
202 };
203 static const uint8_t block_idx_xy[4][4] =
204 {
205     { 0, 2, 8,  10 },
206     { 1, 3, 9,  11 },
207     { 4, 6, 12, 14 },
208     { 5, 7, 13, 15 }
209 };
210 static const uint8_t block_idx_xy_1d[16] =
211 {
212     0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15
213 };
214 static const uint8_t block_idx_yx_1d[16] =
215 {
216     0, 4, 1, 5, 8, 12, 9, 13, 2, 6, 3, 7, 10, 14, 11, 15
217 };
218 static const uint8_t block_idx_xy_fenc[16] =
219 {
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
228 };
229 static const uint16_t block_idx_xy_fdec[16] =
230 {
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
239 };
240
241 static const uint8_t i_chroma_qp_table[52+12*2] =
242 {
243      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
244      0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
245     10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
246     20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
247     29, 30, 31, 32, 32, 33, 34, 34, 35, 35,
248     36, 36, 37, 37, 37, 38, 38, 38, 39, 39,
249     39, 39,
250     39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
251 };
252
253 enum cabac_ctx_block_cat_e
254 {
255     DCT_LUMA_DC   = 0,
256     DCT_LUMA_AC   = 1,
257     DCT_LUMA_4x4  = 2,
258     DCT_CHROMA_DC = 3,
259     DCT_CHROMA_AC = 4,
260     DCT_LUMA_8x8  = 5,
261 };
262
263
264 int  x264_macroblock_cache_init( x264_t *h );
265 void x264_macroblock_slice_init( x264_t *h );
266 void x264_macroblock_thread_init( x264_t *h );
267 void x264_macroblock_cache_load( x264_t *h, int i_mb_x, int i_mb_y );
268 void x264_macroblock_cache_save( x264_t *h );
269 void x264_macroblock_cache_end( x264_t *h );
270
271 void x264_macroblock_bipred_init( x264_t *h );
272
273 void x264_prefetch_fenc( x264_t *h, x264_frame_t *fenc, int i_mb_x, int i_mb_y );
274
275 /* x264_mb_predict_mv_16x16:
276  *      set mvp with predicted mv for D_16x16 block
277  *      h->mb. need only valid values from other blocks */
278 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int16_t mvp[2] );
279 /* x264_mb_predict_mv_pskip:
280  *      set mvp with predicted mv for P_SKIP
281  *      h->mb. need only valid values from other blocks */
282 void x264_mb_predict_mv_pskip( x264_t *h, int16_t mv[2] );
283 /* x264_mb_predict_mv:
284  *      set mvp with predicted mv for all blocks except SKIP and DIRECT
285  *      h->mb. need valid ref/partition/sub of current block to be valid
286  *      and valid mv/ref from other blocks. */
287 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int16_t mvp[2] );
288 /* x264_mb_predict_mv_direct16x16:
289  *      set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
290  *      h->mb. need only valid values from other blocks.
291  *      return 1 on success, 0 on failure.
292  *      if b_changed != NULL, set it to whether refs or mvs differ from
293  *      before this functioncall. */
294 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed );
295 /* x264_mb_predict_mv_ref16x16:
296  *      set mvc with D_16x16 prediction.
297  *      uses all neighbors, even those that didn't end up using this ref.
298  *      h->mb. need only valid values from other blocks */
299 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int16_t mvc[8][2], int *i_mvc );
300
301 void x264_mb_mc( x264_t *h );
302 void x264_mb_mc_8x8( x264_t *h, int i8 );
303
304 static ALWAYS_INLINE uint32_t pack16to32( int a, int b )
305 {
306 #ifdef WORDS_BIGENDIAN
307    return b + (a<<16);
308 #else
309    return a + (b<<16);
310 #endif
311 }
312 static ALWAYS_INLINE uint32_t pack8to16( int a, int b )
313 {
314 #ifdef WORDS_BIGENDIAN
315    return b + (a<<8);
316 #else
317    return a + (b<<8);
318 #endif
319 }
320 static ALWAYS_INLINE uint32_t pack8to32( int a, int b, int c, int d )
321 {
322 #ifdef WORDS_BIGENDIAN
323    return d + (c<<8) + (b<<16) + (a<<24);
324 #else
325    return a + (b<<8) + (c<<16) + (d<<24);
326 #endif
327 }
328 static ALWAYS_INLINE uint32_t pack16to32_mask( int a, int b )
329 {
330 #ifdef WORDS_BIGENDIAN
331    return (b&0xFFFF) + (a<<16);
332 #else
333    return (a&0xFFFF) + (b<<16);
334 #endif
335 }
336 static ALWAYS_INLINE void x264_macroblock_cache_rect1( void *dst, int width, int height, uint8_t val )
337 {
338     uint32_t *d = dst;
339     if( width == 4 )
340     {
341         uint32_t val2 = val * 0x01010101;
342                           M32( d+0 ) = val2;
343         if( height >= 2 ) M32( d+2 ) = val2;
344         if( height == 4 ) M32( d+4 ) = val2;
345         if( height == 4 ) M32( d+6 ) = val2;
346     }
347     else // 2
348     {
349         uint32_t val2 = val * 0x0101;
350                           M16( d+0 ) = val2;
351         if( height >= 2 ) M16( d+2 ) = val2;
352         if( height == 4 ) M16( d+4 ) = val2;
353         if( height == 4 ) M16( d+6 ) = val2;
354     }
355 }
356 static ALWAYS_INLINE void x264_macroblock_cache_rect4( void *dst, int width, int height, uint32_t val )
357 {
358     int dy;
359     if( width == 1 || WORD_SIZE < 8 )
360     {
361         uint32_t *d = dst;
362         for( dy = 0; dy < height; dy++ )
363         {
364                              M32( d+8*dy+0 ) = val;
365             if( width >= 2 ) M32( d+8*dy+1 ) = val;
366             if( width == 4 ) M32( d+8*dy+2 ) = val;
367             if( width == 4 ) M32( d+8*dy+3 ) = val;
368         }
369     }
370     else
371     {
372         uint64_t val64 = val + ((uint64_t)val<<32);
373         uint64_t *d = dst;
374         for( dy = 0; dy < height; dy++ )
375         {
376                              M64( d+4*dy+0 ) = val64;
377             if( width == 4 ) M64( d+4*dy+1 ) = val64;
378         }
379     }
380 }
381 #define x264_macroblock_cache_mv_ptr( a, x, y, w, h, l, mv ) x264_macroblock_cache_mv( a, x, y, w, h, l, M32( mv ) )
382 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 )
383 {
384     x264_macroblock_cache_rect4( &h->mb.cache.mv[i_list][X264_SCAN8_0+x+8*y], width, height, mv );
385 }
386 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 )
387 {
388     x264_macroblock_cache_rect4( &h->mb.cache.mvd[i_list][X264_SCAN8_0+x+8*y], width, height, mv );
389 }
390 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 )
391 {
392     x264_macroblock_cache_rect1( &h->mb.cache.ref[i_list][X264_SCAN8_0+x+8*y], width, height, ref );
393 }
394 static ALWAYS_INLINE void x264_macroblock_cache_skip( x264_t *h, int x, int y, int width, int height, int b_skip )
395 {
396     x264_macroblock_cache_rect1( &h->mb.cache.skip[X264_SCAN8_0+x+8*y], width, height, b_skip );
397 }
398 static ALWAYS_INLINE void x264_macroblock_cache_intra8x8_pred( x264_t *h, int x, int y, int i_mode )
399 {
400     int8_t *cache = &h->mb.cache.intra4x4_pred_mode[X264_SCAN8_0+x+8*y];
401     cache[0] = cache[1] = cache[8] = cache[9] = i_mode;
402 }
403 #define array_non_zero(a) array_non_zero_int(a, sizeof(a))
404 #define array_non_zero_int array_non_zero_int
405 static ALWAYS_INLINE int array_non_zero_int( int16_t *v, int i_count )
406 {
407     if(i_count == 8)
408         return !!M64( &v[0] );
409     else if(i_count == 16)
410         return !!(M64( &v[0] ) | M64( &v[4] ));
411     else if(i_count == 32)
412         return !!(M64( &v[0] ) | M64( &v[4] ) | M64( &v[8] ) | M64( &v[12] ));
413     else
414     {
415         int i;
416         for( i = 0; i < i_count; i+=4 )
417             if( M64( &v[i] ) ) return 1;
418         return 0;
419     }
420 }
421 static inline int x264_mb_predict_intra4x4_mode( x264_t *h, int idx )
422 {
423     const int ma = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 1];
424     const int mb = h->mb.cache.intra4x4_pred_mode[x264_scan8[idx] - 8];
425     const int m  = X264_MIN( x264_mb_pred_mode4x4_fix(ma),
426                              x264_mb_pred_mode4x4_fix(mb) );
427
428     if( m < 0 )
429         return I_PRED_4x4_DC;
430
431     return m;
432 }
433 static inline int x264_mb_predict_non_zero_code( x264_t *h, int idx )
434 {
435     const int za = h->mb.cache.non_zero_count[x264_scan8[idx] - 1];
436     const int zb = h->mb.cache.non_zero_count[x264_scan8[idx] - 8];
437
438     int i_ret = za + zb;
439
440     if( i_ret < 0x80 )
441     {
442         i_ret = ( i_ret + 1 ) >> 1;
443     }
444     return i_ret & 0x7f;
445 }
446 /* x264_mb_transform_8x8_allowed:
447  *      check whether any partition is smaller than 8x8 (or at least
448  *      might be, according to just partition type.)
449  *      doesn't check for cbp */
450 static inline int x264_mb_transform_8x8_allowed( x264_t *h )
451 {
452     // intra and skip are disallowed
453     // large partitions are allowed
454     // direct and 8x8 are conditional
455     static const uint8_t partition_tab[X264_MBTYPE_MAX] = {
456         0,0,0,0,1,2,0,1,1,1,1,1,1,1,1,1,1,1,0,
457     };
458
459     if( !h->pps->b_transform_8x8_mode )
460         return 0;
461     if( h->mb.i_type != P_8x8 )
462         return partition_tab[h->mb.i_type];
463     return M32( h->mb.i_sub_partition ) == D_L0_8x8*0x01010101;
464 }
465
466 #endif
467