Add L1 reflist and B macroblock types to x264 info
[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_list0_table[X264_MBTYPE_MAX][2] =
95 {
96     {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
97     {1,1},                  /* P_L0 */
98     {0,0},                  /* P_8x8 */
99     {1,1},                  /* P_SKIP */
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_* */
104     {0,0},                  /* B_8x8 */
105     {0,0}                   /* B_SKIP */
106 };
107 static const uint8_t x264_mb_type_list1_table[X264_MBTYPE_MAX][2] =
108 {
109     {0,0}, {0,0}, {0,0}, {0,0}, /* INTRA */
110     {0,0},                  /* P_L0 */
111     {0,0},                  /* P_8x8 */
112     {0,0},                  /* P_SKIP */
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_* */
117     {0,0},                  /* B_8x8 */
118     {0,0}                   /* B_SKIP */
119 };
120
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))
125 enum mb_partition_e
126 {
127     /* sub partition type for P_8x8 and B_8x8 */
128     D_L0_4x4          = 0,
129     D_L0_8x4          = 1,
130     D_L0_4x8          = 2,
131     D_L0_8x8          = 3,
132
133     /* sub partition type for B_8x8 only */
134     D_L1_4x4          = 4,
135     D_L1_8x4          = 5,
136     D_L1_4x8          = 6,
137     D_L1_8x8          = 7,
138
139     D_BI_4x4          = 8,
140     D_BI_8x4          = 9,
141     D_BI_4x8          = 10,
142     D_BI_8x8          = 11,
143     D_DIRECT_8x8      = 12,
144
145     /* partition */
146     D_8x8             = 13,
147     D_16x8            = 14,
148     D_8x16            = 15,
149     D_16x16           = 16,
150     X264_PARTTYPE_MAX = 17,
151 };
152
153 static const uint8_t x264_mb_partition_listX_table[2][17] =
154 {{
155     1, 1, 1, 1, /* D_L0_* */
156     0, 0, 0, 0, /* D_L1_* */
157     1, 1, 1, 1, /* D_BI_* */
158     0,          /* D_DIRECT_8x8 */
159     0, 0, 0, 0  /* 8x8 .. 16x16 */
160 },
161 {
162     0, 0, 0, 0, /* D_L0_* */
163     1, 1, 1, 1, /* D_L1_* */
164     1, 1, 1, 1, /* D_BI_* */
165     0,          /* D_DIRECT_8x8 */
166     0, 0, 0, 0  /* 8x8 .. 16x16 */
167 }};
168 static const uint8_t x264_mb_partition_count_table[17] =
169 {
170     /* sub L0 */
171     4, 2, 2, 1,
172     /* sub L1 */
173     4, 2, 2, 1,
174     /* sub BI */
175     4, 2, 2, 1,
176     /* Direct */
177     1,
178     /* Partition */
179     4, 2, 2, 1
180 };
181 static const uint8_t x264_mb_partition_pixel_table[17] =
182 {
183     6, 4, 5, 3, 6, 4, 5, 3, 6, 4, 5, 3, 3, 3, 1, 2, 0
184 };
185
186 /* zigzags are transposed with respect to the tables in the standard */
187 static const uint8_t x264_zigzag_scan4[2][16] =
188 {{ // frame
189     0,  4,  1,  2,  5,  8, 12,  9,  6,  3,  7, 10, 13, 14, 11, 15
190 },
191 {  // field
192     0,  1,  4,  2,  3,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15
193 }};
194 static const uint8_t x264_zigzag_scan8[2][64] =
195 {{
196     0,  8,  1,  2,  9, 16, 24, 17, 10,  3,  4, 11, 18, 25, 32, 40,
197    33, 26, 19, 12,  5,  6, 13, 20, 27, 34, 41, 48, 56, 49, 42, 35,
198    28, 21, 14,  7, 15, 22, 29, 36, 43, 50, 57, 58, 51, 44, 37, 30,
199    23, 31, 38, 45, 52, 59, 60, 53, 46, 39, 47, 54, 61, 62, 55, 63
200 },
201 {
202     0,  1,  2,  8,  9,  3,  4, 10, 16, 11,  5,  6,  7, 12, 17, 24,
203    18, 13, 14, 15, 19, 25, 32, 26, 20, 21, 22, 23, 27, 33, 40, 34,
204    28, 29, 30, 31, 35, 41, 48, 42, 36, 37, 38, 39, 43, 49, 50, 44,
205    45, 46, 47, 51, 56, 57, 52, 53, 54, 55, 58, 59, 60, 61, 62, 63
206 }};
207
208 static const uint8_t block_idx_x[16] =
209 {
210     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
211 };
212 static const uint8_t block_idx_y[16] =
213 {
214     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
215 };
216 static const uint8_t block_idx_xy[4][4] =
217 {
218     { 0, 2, 8,  10 },
219     { 1, 3, 9,  11 },
220     { 4, 6, 12, 14 },
221     { 5, 7, 13, 15 }
222 };
223 static const uint8_t block_idx_xy_1d[16] =
224 {
225     0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15
226 };
227 static const uint8_t block_idx_xy_fenc[16] =
228 {
229     0*4 + 0*4*FENC_STRIDE, 1*4 + 0*4*FENC_STRIDE,
230     0*4 + 1*4*FENC_STRIDE, 1*4 + 1*4*FENC_STRIDE,
231     2*4 + 0*4*FENC_STRIDE, 3*4 + 0*4*FENC_STRIDE,
232     2*4 + 1*4*FENC_STRIDE, 3*4 + 1*4*FENC_STRIDE,
233     0*4 + 2*4*FENC_STRIDE, 1*4 + 2*4*FENC_STRIDE,
234     0*4 + 3*4*FENC_STRIDE, 1*4 + 3*4*FENC_STRIDE,
235     2*4 + 2*4*FENC_STRIDE, 3*4 + 2*4*FENC_STRIDE,
236     2*4 + 3*4*FENC_STRIDE, 3*4 + 3*4*FENC_STRIDE
237 };
238 static const uint16_t block_idx_xy_fdec[16] =
239 {
240     0*4 + 0*4*FDEC_STRIDE, 1*4 + 0*4*FDEC_STRIDE,
241     0*4 + 1*4*FDEC_STRIDE, 1*4 + 1*4*FDEC_STRIDE,
242     2*4 + 0*4*FDEC_STRIDE, 3*4 + 0*4*FDEC_STRIDE,
243     2*4 + 1*4*FDEC_STRIDE, 3*4 + 1*4*FDEC_STRIDE,
244     0*4 + 2*4*FDEC_STRIDE, 1*4 + 2*4*FDEC_STRIDE,
245     0*4 + 3*4*FDEC_STRIDE, 1*4 + 3*4*FDEC_STRIDE,
246     2*4 + 2*4*FDEC_STRIDE, 3*4 + 2*4*FDEC_STRIDE,
247     2*4 + 3*4*FDEC_STRIDE, 3*4 + 3*4*FDEC_STRIDE
248 };
249
250 static const uint8_t i_chroma_qp_table[52] =
251 {
252      0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
253     10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
254     20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
255     29, 30, 31, 32, 32, 33, 34, 34, 35, 35,
256     36, 36, 37, 37, 37, 38, 38, 38, 39, 39,
257     39, 39
258 };
259
260 enum cabac_ctx_block_cat_e
261 {
262     DCT_LUMA_DC   = 0,
263     DCT_LUMA_AC   = 1,
264     DCT_LUMA_4x4  = 2,
265     DCT_CHROMA_DC = 3,
266     DCT_CHROMA_AC = 4,
267     DCT_LUMA_8x8  = 5,
268 };
269
270
271 int  x264_macroblock_cache_init( x264_t *h );
272 void x264_macroblock_slice_init( x264_t *h );
273 void x264_macroblock_cache_load( x264_t *h, int i_mb_x, int i_mb_y );
274 void x264_macroblock_cache_save( x264_t *h );
275 void x264_macroblock_cache_end( x264_t *h );
276
277 void x264_macroblock_bipred_init( x264_t *h );
278
279 void x264_prefetch_fenc( x264_t *h, x264_frame_t *fenc, int i_mb_x, int i_mb_y );
280
281 /* x264_mb_predict_mv_16x16:
282  *      set mvp with predicted mv for D_16x16 block
283  *      h->mb. need only valid values from other blocks */
284 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int16_t mvp[2] );
285 /* x264_mb_predict_mv_pskip:
286  *      set mvp with predicted mv for P_SKIP
287  *      h->mb. need only valid values from other blocks */
288 void x264_mb_predict_mv_pskip( x264_t *h, int16_t mv[2] );
289 /* x264_mb_predict_mv:
290  *      set mvp with predicted mv for all blocks except SKIP and DIRECT
291  *      h->mb. need valid ref/partition/sub of current block to be valid
292  *      and valid mv/ref from other blocks. */
293 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int16_t mvp[2] );
294 /* x264_mb_predict_mv_direct16x16:
295  *      set h->mb.cache.mv and h->mb.cache.ref for B_SKIP or B_DIRECT
296  *      h->mb. need only valid values from other blocks.
297  *      return 1 on success, 0 on failure.
298  *      if b_changed != NULL, set it to whether refs or mvs differ from
299  *      before this functioncall. */
300 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed );
301 /* x264_mb_load_mv_direct8x8:
302  *      set h->mb.cache.mv and h->mb.cache.ref for B_DIRECT
303  *      must be called only after x264_mb_predict_mv_direct16x16 */
304 void x264_mb_load_mv_direct8x8( x264_t *h, int idx );
305 /* x264_mb_predict_mv_ref16x16:
306  *      set mvc with D_16x16 prediction.
307  *      uses all neighbors, even those that didn't end up using this ref.
308  *      h->mb. need only valid values from other blocks */
309 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int16_t mvc[8][2], int *i_mvc );
310
311
312 int  x264_mb_predict_intra4x4_mode( x264_t *h, int idx );
313 int  x264_mb_predict_non_zero_code( x264_t *h, int idx );
314
315 /* x264_mb_transform_8x8_allowed:
316  *      check whether any partition is smaller than 8x8 (or at least
317  *      might be, according to just partition type.)
318  *      doesn't check for cbp */
319 int  x264_mb_transform_8x8_allowed( x264_t *h );
320
321 void x264_mb_mc( x264_t *h );
322 void x264_mb_mc_8x8( x264_t *h, int i8 );
323
324 static ALWAYS_INLINE uint32_t pack16to32( int a, int b )
325 {
326 #ifdef WORDS_BIGENDIAN
327    return b + (a<<16);
328 #else
329    return a + (b<<16);
330 #endif
331 }
332 static ALWAYS_INLINE uint32_t pack8to16( int a, int b )
333 {
334 #ifdef WORDS_BIGENDIAN
335    return b + (a<<8);
336 #else
337    return a + (b<<8);
338 #endif
339 }
340 static ALWAYS_INLINE uint32_t pack8to32( int a, int b, int c, int d )
341 {
342 #ifdef WORDS_BIGENDIAN
343    return d + (c<<8) + (b<<16) + (a<<24);
344 #else
345    return a + (b<<8) + (c<<16) + (d<<24);
346 #endif
347 }
348 static ALWAYS_INLINE uint32_t pack16to32_mask( int a, int b )
349 {
350 #ifdef WORDS_BIGENDIAN
351    return (b&0xFFFF) + (a<<16);
352 #else
353    return (a&0xFFFF) + (b<<16);
354 #endif
355 }
356 static ALWAYS_INLINE void x264_macroblock_cache_rect1( void *dst, int width, int height, uint8_t val )
357 {
358     int dy;
359     if( width == 4 )
360     {
361         uint32_t val2 = val * 0x01010101;
362         for( dy = 0; dy < height; dy++ )
363             ((uint32_t*)dst)[2*dy] = val2;
364     }
365     else // 2
366     {
367         uint32_t val2 = val * 0x0101;
368         for( dy = 0; dy < height; dy++ )
369             ((uint16_t*)dst)[4*dy] = val2;
370     }
371 }
372 static ALWAYS_INLINE void x264_macroblock_cache_rect4( void *dst, int width, int height, uint32_t val )
373 {
374     int dy, dx;
375     if( width == 1 || WORD_SIZE < 8 )
376     {
377         for( dy = 0; dy < height; dy++ )
378             for( dx = 0; dx < width; dx++ )
379                 ((uint32_t*)dst)[dx+8*dy] = val;
380     }
381     else
382     {
383         uint64_t val64 = val + ((uint64_t)val<<32);
384         for( dy = 0; dy < height; dy++ )
385             for( dx = 0; dx < width/2; dx++ )
386                 ((uint64_t*)dst)[dx+4*dy] = val64;
387     }
388 }
389 #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)
390 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 )
391 {
392     x264_macroblock_cache_rect4( &h->mb.cache.mv[i_list][X264_SCAN8_0+x+8*y], width, height, mv );
393 }
394 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 )
395 {
396     x264_macroblock_cache_rect4( &h->mb.cache.mvd[i_list][X264_SCAN8_0+x+8*y], width, height, mv );
397 }
398 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 )
399 {
400     x264_macroblock_cache_rect1( &h->mb.cache.ref[i_list][X264_SCAN8_0+x+8*y], width, height, ref );
401 }
402 static ALWAYS_INLINE void x264_macroblock_cache_skip( x264_t *h, int x, int y, int width, int height, int b_skip )
403 {
404     x264_macroblock_cache_rect1( &h->mb.cache.skip[X264_SCAN8_0+x+8*y], width, height, b_skip );
405 }
406 static ALWAYS_INLINE void x264_macroblock_cache_intra8x8_pred( x264_t *h, int x, int y, int i_mode )
407 {
408     int8_t *cache = &h->mb.cache.intra4x4_pred_mode[X264_SCAN8_0+x+8*y];
409     cache[0] = cache[1] = cache[8] = cache[9] = i_mode;
410 }
411 #define array_non_zero(a) array_non_zero_int(a, sizeof(a))
412 #define array_non_zero_int array_non_zero_int_c
413 static ALWAYS_INLINE int array_non_zero_int_c( void *v, int i_count )
414 {
415     uint64_t *x = v;
416     if(i_count == 8)
417         return !!x[0];
418     else if(i_count == 16)
419         return !!(x[0]|x[1]);
420     else if(i_count == 32)
421         return !!(x[0]|x[1]|x[2]|x[3]);
422     else
423     {
424         int i;
425         i_count /= sizeof(uint64_t);
426         for( i = 0; i < i_count; i++ )
427             if( x[i] ) return 1;
428         return 0;
429     }
430 }
431 /* This function and its MMX version only work on arrays of size 16 */
432 static ALWAYS_INLINE int array_non_zero_count( int16_t *v )
433 {
434     int i;
435     int i_nz;
436
437     for( i = 0, i_nz = 0; i < 16; i++ )
438         if( v[i] )
439             i_nz++;
440
441     return i_nz;
442 }
443
444 #endif
445