rename 'core/' to 'common/', which avoids conflicts with libtool
[x262.git] / encoder / macroblock.c
1 /*****************************************************************************
2  * macroblock.c: h264 encoder library
3  *****************************************************************************
4  * Copyright (C) 2003 Laurent Aimar
5  * $Id: macroblock.c,v 1.1 2004/06/03 19:27:08 fenrir Exp $
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27
28 #include "../common/common.h"
29 #include "macroblock.h"
30
31
32 static const uint8_t block_idx_x[16] =
33 {
34     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
35 };
36 static const uint8_t block_idx_y[16] =
37 {
38     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
39 };
40 static const uint8_t block_idx_xy[4][4] =
41 {
42     { 0, 2, 8,  10},
43     { 1, 3, 9,  11},
44     { 4, 6, 12, 14},
45     { 5, 7, 13, 15}
46 };
47
48 static const int quant_mf[6][4][4] =
49 {
50     {  { 13107, 8066, 13107, 8066}, {  8066, 5243,  8066, 5243},
51        { 13107, 8066, 13107, 8066}, {  8066, 5243,  8066, 5243}  },
52     {  { 11916, 7490, 11916, 7490}, {  7490, 4660,  7490, 4660},
53        { 11916, 7490, 11916, 7490}, {  7490, 4660,  7490, 4660}  },
54     {  { 10082, 6554, 10082, 6554}, {  6554, 4194,  6554, 4194},
55        { 10082, 6554, 10082, 6554}, {  6554, 4194,  6554, 4194}  },
56     {  {  9362, 5825,  9362, 5825}, {  5825, 3647,  5825, 3647},
57        {  9362, 5825,  9362, 5825}, {  5825, 3647,  5825, 3647}  },
58     {  {  8192, 5243,  8192, 5243}, {  5243, 3355,  5243, 3355},
59        {  8192, 5243,  8192, 5243}, {  5243, 3355,  5243, 3355}  },
60     {  {  7282, 4559,  7282, 4559}, {  4559, 2893,  4559, 2893},
61        {  7282, 4559,  7282, 4559}, {  4559, 2893,  4559, 2893}  }
62 };
63
64 static const int i_chroma_qp_table[52] =
65 {
66      0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
67     10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
68     20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
69     29, 30, 31, 32, 32, 33, 34, 34, 35, 35,
70     36, 36, 37, 37, 37, 38, 38, 38, 39, 39,
71     39, 39
72 };
73
74 /****************************************************************************
75  * Scan and Quant functions
76  ****************************************************************************/
77 //static const int scan_zigzag_x[16]={0, 1, 0, 0, 1, 2, 3, 2, 1, 0, 1, 2, 3, 3, 2, 3};
78 //static const int scan_zigzag_y[16]={0, 0, 1, 2, 1, 0, 0, 1, 2, 3, 3, 2, 1, 2, 3, 3};
79
80 static inline void scan_zigzag_4x4full( int level[16], int16_t dct[4][4] )
81 {
82     level[0] = dct[0][0];
83     level[1] = dct[0][1];
84     level[2] = dct[1][0];
85     level[3] = dct[2][0];
86     level[4] = dct[1][1];
87     level[5] = dct[0][2];
88     level[6] = dct[0][3];
89     level[7] = dct[1][2];
90     level[8] = dct[2][1];
91     level[9] = dct[3][0];
92     level[10] = dct[3][1];
93     level[11] = dct[2][2];
94     level[12] = dct[1][3];
95     level[13] = dct[2][3];
96     level[14] = dct[3][2];
97     level[15] = dct[3][3];
98 #if 0
99     int i;
100     for( i = 0; i < 16; i++ )
101     {
102         level[i] = dct[scan_zigzag_y[i]][scan_zigzag_x[i]];
103     }
104 #endif
105 }
106 static inline void scan_zigzag_4x4( int level[15], int16_t dct[4][4] )
107 {
108     level[0] = dct[0][1];
109     level[1] = dct[1][0];
110     level[2] = dct[2][0];
111     level[3] = dct[1][1];
112     level[4] = dct[0][2];
113     level[5] = dct[0][3];
114     level[6] = dct[1][2];
115     level[7] = dct[2][1];
116     level[8] = dct[3][0];
117     level[9] = dct[3][1];
118     level[10] = dct[2][2];
119     level[11] = dct[1][3];
120     level[12] = dct[2][3];
121     level[13] = dct[3][2];
122     level[14] = dct[3][3];
123 #if 0
124     int i;
125     for( i = 1; i < 16; i++ )
126     {
127         level[i - 1] = dct[scan_zigzag_y[i]][scan_zigzag_x[i]];
128     }
129 #endif
130 }
131
132 static inline void scan_zigzag_2x2_dc( int level[4], int16_t dct[2][2] )
133 {
134     level[0] = dct[0][0];
135     level[1] = dct[0][1];
136     level[2] = dct[1][0];
137     level[3] = dct[1][1];
138 }
139
140
141 static void quant_4x4( int16_t dct[4][4], int i_qscale, int b_intra )
142 {
143     const int i_qbits = 15 + i_qscale / 6;
144     const int i_mf = i_qscale % 6;
145     const int f = ( 1 << i_qbits ) / ( b_intra ? 3 : 6 );
146
147     int x,y;
148     for( y = 0; y < 4; y++ )
149     {
150         for( x = 0; x < 4; x++ )
151         {
152             if( dct[y][x] > 0 )
153             {
154                 dct[y][x] =( f + dct[y][x]  * quant_mf[i_mf][y][x] ) >> i_qbits;
155             }
156             else
157             {
158                 dct[y][x] = - ( ( f - dct[y][x]  * quant_mf[i_mf][y][x] ) >> i_qbits );
159             }
160         }
161     }
162 }
163 static void quant_4x4_dc( int16_t dct[4][4], int i_qscale )
164 {
165     const int i_qbits = 15 + i_qscale / 6;
166     const int f2 = ( 2 << i_qbits ) / 3;
167     const int i_qmf = quant_mf[i_qscale%6][0][0];
168     int x,y;
169
170     for( y = 0; y < 4; y++ )
171     {
172         for( x = 0; x < 4; x++ )
173         {
174             if( dct[y][x] > 0 )
175             {
176                 dct[y][x] =( f2 + dct[y][x]  * i_qmf) >> ( 1 + i_qbits );
177             }
178             else
179             {
180                 dct[y][x] = - ( ( f2 - dct[y][x]  * i_qmf ) >> (1 + i_qbits ) );
181             }
182         }
183     }
184 }
185 static void quant_2x2_dc( int16_t dct[2][2], int i_qscale, int b_intra )
186 {
187     int const i_qbits = 15 + i_qscale / 6;
188     const int f2 = ( 2 << i_qbits ) / ( b_intra ? 3 : 6 );
189     const int i_qmf = quant_mf[i_qscale%6][0][0];
190
191     int x,y;
192     for( y = 0; y < 2; y++ )
193     {
194         for( x = 0; x < 2; x++ )
195         {
196             if( dct[y][x] > 0 )
197             {
198                 dct[y][x] =( f2 + dct[y][x]  * i_qmf) >> ( 1 + i_qbits );
199             }
200             else
201             {
202                 dct[y][x] = - ( ( f2 - dct[y][x]  * i_qmf ) >> (1 + i_qbits ) );
203             }
204         }
205     }
206 }
207 #if 0
208 /* From a JVT doc */
209 static const int f_deadzone_intra[4][4][2] = /* [num][den] */
210 {
211     { {1,2}, {3,7}, {2,5}, {1,3} },
212     { {3,7}, {2,5}, {1,3}, {1,4} },
213     { {2,5}, {1,3}, {1,4}, {1,5} },
214     { {1,3}, {1,4}, {1,5}, {1,5} }
215 };
216 static const int f_deadzone_inter[4][4][2] = /* [num][den] */
217 {
218     { {1,3}, {2,7}, {4,15},{2,9} },
219     { {2,7}, {4,15},{2,9}, {1,6} },
220     { {4,15},{2,9}, {1,6}, {1,7} },
221     { {2,9}, {1,6}, {1,7}, {2,15} }
222 };
223
224
225 static void quant_4x4( int16_t dct[4][4], int i_qscale, int b_intra )
226 {
227     const int(*f_deadzone)[4][4][2] = b_intra ? &f_deadzone_intra : &f_deadzone_inter;
228     const int i_qbits = 15 + i_qscale / 6;
229     const int i_mf = i_qscale % 6;
230
231     int x,y;
232     for( y = 0; y < 4; y++ )
233     {
234         for( x = 0; x < 4; x++ )
235         {
236 #if 0
237             const int f = b_intra ?
238                           (f_deadzone_intra[y][x][0] * ( 1 << i_qbits ) / f_deadzone_intra[y][x][1])
239                           :
240                           (f_deadzone_inter[y][x][0] * ( 1 << i_qbits ) / f_deadzone_inter[y][x][1]);
241 #else
242             const int f = (*f_deadzone)[y][x][0] * ( 1 << i_qbits ) / (*f_deadzone)[y][x][1];
243 #endif
244
245             if( dct[y][x] > 0 )
246             {
247                 dct[y][x] =( f + dct[y][x]  * quant_mf[i_mf][y][x] ) >> i_qbits;
248             }
249             else
250             {
251                 dct[y][x] = - ( ( f - dct[y][x]  * quant_mf[i_mf][y][x] ) >> i_qbits );
252             }
253         }
254     }
255 }
256
257 static void quant_4x4_dc( int16_t dct[4][4], int i_qscale )
258 {
259     const int i_qbits = 15 + i_qscale / 6;
260     const int i_qmf = quant_mf[i_qscale%6][0][0];
261     const int f2 = f_deadzone_intra[0][0][0] * ( 2 << i_qbits ) / f_deadzone_intra[0][0][1];
262     int x,y;
263
264     for( y = 0; y < 4; y++ )
265     {
266         for( x = 0; x < 4; x++ )
267         {
268
269             if( dct[y][x] > 0 )
270             {
271                 dct[y][x] =( f2 + dct[y][x]  * i_qmf) >> ( 1 + i_qbits );
272             }
273             else
274             {
275                 dct[y][x] = - ( ( f2 - dct[y][x]  * i_qmf ) >> (1 + i_qbits ) );
276             }
277         }
278     }
279 }
280
281 static void quant_2x2_dc( int16_t dct[2][2], int i_qscale, int b_intra )
282 {
283     int const i_qbits = 15 + i_qscale / 6;
284     const int i_qmf = quant_mf[i_qscale%6][0][0];
285     const int f2 = b_intra ?
286                    (f_deadzone_intra[0][0][0] * ( 2 << i_qbits ) / f_deadzone_intra[0][0][1])
287                    :
288                    (f_deadzone_inter[0][0][0] * ( 2 << i_qbits ) / f_deadzone_inter[0][0][1]);
289     int x,y;
290     for( y = 0; y < 2; y++ )
291     {
292         for( x = 0; x < 2; x++ )
293         {
294             if( dct[y][x] > 0 )
295             {
296                 dct[y][x] =( f2 + dct[y][x]  * i_qmf) >> ( 1 + i_qbits );
297             }
298             else
299             {
300                 dct[y][x] = - ( ( f2 - dct[y][x]  * i_qmf ) >> (1 + i_qbits ) );
301             }
302         }
303     }
304 }
305
306
307 #endif
308
309 static inline int array_non_zero_count( int *v, int i_count )
310 {
311     int i;
312     int i_nz;
313
314     for( i = 0, i_nz = 0; i < i_count; i++ )
315     {
316         if( v[i] )
317         {
318             i_nz++;
319         }
320     }
321     return i_nz;
322 }
323
324 /* (ref: JVT-B118)
325  * x264_mb_decimate_score: given dct coeffs it returns a score to see if we could empty this dct coeffs
326  * to 0 (low score means set it to null)
327  * Used in inter macroblock (luma and chroma)
328  *  luma: for a 8x8 block: if score < 4 -> null
329  *        for the complete mb: if score < 6 -> null
330  *  chroma: for the complete mb: if score < 7 -> null
331  */
332 static int x264_mb_decimate_score( int *dct, int i_max )
333 {
334     static const int i_ds_table[16] = { 3, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
335
336     int i_score = 0;
337     int idx = i_max - 1;
338
339     while( idx >= 0 && dct[idx] == 0 )
340     {
341         idx--;
342     }
343
344     while( idx >= 0 )
345     {
346         int i_run;
347
348         if( abs( dct[idx--] ) > 1 )
349         {
350             return 9;
351         }
352
353         i_run = 0;
354         while( idx >= 0 && dct[idx] == 0 )
355         {
356             idx--;
357             i_run++;
358         }
359         i_score += i_ds_table[i_run];
360     }
361
362     return i_score;
363 }
364
365 void x264_mb_encode_i4x4( x264_t *h, int idx, int i_qscale )
366 {
367     const int i_stride = h->mb.pic.i_stride[0];
368     uint8_t  *p_src = &h->mb.pic.p_fenc[0][4 * block_idx_x[idx] + 4 * block_idx_y[idx] * i_stride];
369     uint8_t  *p_dst = &h->mb.pic.p_fdec[0][4 * block_idx_x[idx] + 4 * block_idx_y[idx] * i_stride];
370
371     int16_t dct4x4[4][4];
372
373     h->dctf.sub4x4_dct( dct4x4, p_src, i_stride, p_dst, i_stride );
374
375     quant_4x4( dct4x4, i_qscale, 1 );
376
377     scan_zigzag_4x4full( h->dct.block[idx].luma4x4, dct4x4 );
378
379     x264_mb_dequant_4x4( dct4x4, i_qscale );
380
381     /* output samples to fdec */
382     h->dctf.add4x4_idct( p_dst, i_stride, dct4x4 );
383 }
384
385 static void x264_mb_encode_i16x16( x264_t *h, int i_qscale )
386 {
387     const int i_stride = h->mb.pic.i_stride[0];
388     uint8_t  *p_src = h->mb.pic.p_fenc[0];
389     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
390
391     int16_t dct4x4[16+1][4][4];
392
393     int i;
394
395     h->dctf.sub16x16_dct( &dct4x4[1], p_src, i_stride, p_dst, i_stride );
396     for( i = 0; i < 16; i++ )
397     {
398         /* copy dc coeff */
399         dct4x4[0][block_idx_y[i]][block_idx_x[i]] = dct4x4[1+i][0][0];
400
401         /* quant/scan/dequant */
402         quant_4x4( dct4x4[1+i], i_qscale, 1 );
403         scan_zigzag_4x4( h->dct.block[i].residual_ac, dct4x4[1+i] );
404         x264_mb_dequant_4x4( dct4x4[1+i], i_qscale );
405     }
406
407     h->dctf.dct4x4dc( dct4x4[0] );
408     quant_4x4_dc( dct4x4[0], i_qscale );
409     scan_zigzag_4x4full( h->dct.luma16x16_dc, dct4x4[0] );
410
411     /* output samples to fdec */
412     h->dctf.idct4x4dc( dct4x4[0] );
413     x264_mb_dequant_4x4_dc( dct4x4[0], i_qscale );  /* XXX not inversed */
414
415     /* calculate dct coeffs */
416     for( i = 0; i < 16; i++ )
417     {
418         /* copy dc coeff */
419         dct4x4[1+i][0][0] = dct4x4[0][block_idx_y[i]][block_idx_x[i]];
420     }
421     /* put pixels to fdec */
422     h->dctf.add16x16_idct( p_dst, i_stride, &dct4x4[1] );
423 }
424
425 static void x264_mb_encode_8x8( x264_t *h, int b_inter, int i_qscale )
426 {
427     int i, ch;
428
429     for( ch = 0; ch < 2; ch++ )
430     {
431         const int i_stride = h->mb.pic.i_stride[1+ch];
432         uint8_t  *p_src = h->mb.pic.p_fenc[1+ch];
433         uint8_t  *p_dst = h->mb.pic.p_fdec[1+ch];
434         int i_decimate_score = 0;
435
436         int16_t dct2x2[2][2];
437         int16_t dct4x4[4][4][4];
438
439         h->dctf.sub8x8_dct( dct4x4, p_src, i_stride, p_dst, i_stride );
440         /* calculate dct coeffs */
441         for( i = 0; i < 4; i++ )
442         {
443             /* copy dc coeff */
444             dct2x2[block_idx_y[i]][block_idx_x[i]] = dct4x4[i][0][0];
445
446             quant_4x4( dct4x4[i], i_qscale, b_inter ? 0 : 1 );
447             scan_zigzag_4x4( h->dct.block[16+i+ch*4].residual_ac, dct4x4[i] );
448             x264_mb_dequant_4x4( dct4x4[i], i_qscale );
449
450             if( b_inter )
451             {
452                 i_decimate_score += x264_mb_decimate_score( h->dct.block[16+i+ch*4].residual_ac, 15 );
453             }
454         }
455
456         h->dctf.dct2x2dc( dct2x2 );
457         quant_2x2_dc( dct2x2, i_qscale, b_inter ? 0 : 1 );
458         scan_zigzag_2x2_dc( h->dct.chroma_dc[ch], dct2x2 );
459
460         /* output samples to fdec */
461         h->dctf.idct2x2dc( dct2x2 );
462         x264_mb_dequant_2x2_dc( dct2x2, i_qscale );  /* XXX not inversed */
463
464         if( b_inter && i_decimate_score < 7 )
465         {
466             /* Near null chroma 8x8 block so make it null (bits saving) */
467             for( i = 0; i < 4; i++ )
468             {
469                 int x, y;
470                 for( x = 0; x < 15; x++ )
471                 {
472                     h->dct.block[16+i+ch*4].residual_ac[x] = 0;
473                 }
474                 for( x = 0; x < 4; x++ )
475                 {
476                     for( y = 0; y < 4; y++ )
477                     {
478                         dct4x4[i][x][y] = 0;
479                     }
480                 }
481             }
482         }
483
484         /* calculate dct coeffs */
485         for( i = 0; i < 4; i++ )
486         {
487             /* copy dc coeff */
488             dct4x4[i][0][0] = dct2x2[block_idx_y[i]][block_idx_x[i]];
489         }
490         h->dctf.add8x8_idct( p_dst, i_stride, dct4x4 );
491     }
492 }
493
494 /*****************************************************************************
495  * x264_macroblock_encode_pskip:
496  *  Encode an already marked skip block
497  *****************************************************************************/
498 void x264_macroblock_encode_pskip( x264_t *h )
499 {
500     const int mvx = h->mb.cache.mv[0][x264_scan8[0]][0];
501     const int mvy = h->mb.cache.mv[0][x264_scan8[0]][1];
502     int i;
503
504     /* Motion compensation XXX probably unneeded */
505     h->mc[MC_LUMA]( h->mb.pic.p_fref[0][0][0], h->mb.pic.i_stride[0],
506                     h->mb.pic.p_fdec[0],       h->mb.pic.i_stride[0],
507                     mvx, mvy, 16, 16 );
508
509     /* Chroma MC */
510     h->mc[MC_CHROMA]( h->mb.pic.p_fref[0][0][1], h->mb.pic.i_stride[1],
511                       h->mb.pic.p_fdec[1],       h->mb.pic.i_stride[1],
512                       mvx, mvy, 8, 8 );
513
514     h->mc[MC_CHROMA]( h->mb.pic.p_fref[0][0][2], h->mb.pic.i_stride[2],
515                       h->mb.pic.p_fdec[2],       h->mb.pic.i_stride[2],
516                       mvx, mvy, 8, 8 );
517
518     h->mb.i_cbp_luma = 0x00;
519     h->mb.i_cbp_chroma = 0x00;
520
521     for( i = 0; i < 16+8; i++ )
522     {
523         h->mb.cache.non_zero_count[x264_scan8[i]] = 0;
524     }
525
526     /* store cbp */
527     h->mb.cbp[h->mb.i_mb_xy] = 0;
528 }
529
530 /*****************************************************************************
531  * x264_macroblock_encode:
532  *****************************************************************************/
533 void x264_macroblock_encode( x264_t *h )
534 {
535     int i_cbp_dc = 0;
536     int i_qscale;
537     int i;
538
539     if( h->mb.i_type == P_SKIP )
540     {
541         /* A bit special */
542         x264_macroblock_encode_pskip( h );
543         return;
544     }
545
546     /* quantification scale */
547     i_qscale = h->mb.qp[h->mb.i_mb_xy];
548
549     if( h->mb.i_type == I_16x16 )
550     {
551         const int i_mode = h->mb.i_intra16x16_pred_mode;
552         /* do the right prediction */
553         h->predict_16x16[i_mode]( h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0] );
554
555         /* encode the 16x16 macroblock */
556         x264_mb_encode_i16x16( h, i_qscale );
557
558         /* fix the pred mode value */
559         h->mb.i_intra16x16_pred_mode = x264_mb_pred_mode16x16_fix[i_mode];
560     }
561     else if( h->mb.i_type == I_4x4 )
562     {
563         for( i = 0; i < 16; i++ )
564         {
565             const int i_dst = h->mb.pic.i_stride[0];
566             uint8_t  *p_dst = &h->mb.pic.p_fdec[0][4 * block_idx_x[i] + 4 * block_idx_y[i] * i_dst];
567             int      i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[i]];
568
569             /* Do the right prediction */
570             h->predict_4x4[i_mode]( p_dst, i_dst );
571
572             /* encode one 4x4 block */
573             x264_mb_encode_i4x4( h, i, i_qscale );
574
575             /* fix the pred mode value */
576             h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] = x264_mb_pred_mode4x4_fix[i_mode];
577         }
578     }
579     else    /* Inter MB */
580     {
581         int16_t dct4x4[16][4][4];
582
583         int i8x8, i4x4, idx;
584         int i_decimate_mb = 0;
585
586         /* Motion compensation */
587         x264_mb_mc( h );
588
589         h->dctf.sub16x16_dct( dct4x4,
590                               h->mb.pic.p_fenc[0], h->mb.pic.i_stride[0],
591                               h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0] );
592
593         for( i8x8 = 0; i8x8 < 4; i8x8++ )
594         {
595             int i_decimate_8x8;
596
597             /* encode one 4x4 block */
598             i_decimate_8x8 = 0;
599             for( i4x4 = 0; i4x4 < 4; i4x4++ )
600             {
601                 idx = i8x8 * 4 + i4x4;
602
603                 quant_4x4( dct4x4[idx], i_qscale, 0 );
604                 scan_zigzag_4x4full( h->dct.block[idx].luma4x4, dct4x4[idx] );
605                 x264_mb_dequant_4x4( dct4x4[idx], i_qscale );
606
607                 i_decimate_8x8 += x264_mb_decimate_score( h->dct.block[idx].luma4x4, 16 );
608             }
609
610             /* decimate this 8x8 block */
611             i_decimate_mb += i_decimate_8x8;
612             if( i_decimate_8x8 < 4 )
613             {
614                 for( i4x4 = 0; i4x4 < 4; i4x4++ )
615                 {
616                     int x, y;
617                     idx = i8x8 * 4 + i4x4;
618                     for( i = 0; i < 16; i++ )
619                     {
620                         h->dct.block[idx].luma4x4[i] = 0;
621                     }
622                     for( x = 0; x < 4; x++ )
623                     {
624                         for( y = 0; y < 4; y++ )
625                         {
626                             dct4x4[idx][x][y] = 0;
627                         }
628                     }
629                 }
630             }
631         }
632
633         if( i_decimate_mb < 6 )
634         {
635             for( idx = 0; idx < 16; idx++ )
636             {
637                 for( i = 0; i < 16; i++ )
638                 {
639                     h->dct.block[idx].luma4x4[i] = 0;
640                 }
641             }
642         }
643         else
644         {
645             h->dctf.add16x16_idct( h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0], dct4x4 );
646         }
647     }
648
649     /* encode chroma */
650     i_qscale = i_chroma_qp_table[x264_clip3( i_qscale + h->pps->i_chroma_qp_index_offset, 0, 51 )];
651     if( IS_INTRA( h->mb.i_type ) )
652     {
653         const int i_mode = h->mb.i_chroma_pred_mode;
654         /* do the right prediction */
655         h->predict_8x8[i_mode]( h->mb.pic.p_fdec[1], h->mb.pic.i_stride[1] );
656         h->predict_8x8[i_mode]( h->mb.pic.p_fdec[2], h->mb.pic.i_stride[2] );
657
658         /* fix the pred mode value */
659         h->mb.i_chroma_pred_mode = x264_mb_pred_mode8x8_fix[i_mode];
660     }
661
662     /* encode the 8x8 blocks */
663     x264_mb_encode_8x8( h, !IS_INTRA( h->mb.i_type ), i_qscale );
664
665     /* Calculate the Luma/Chroma patern and non_zero_count */
666     if( h->mb.i_type == I_16x16 )
667     {
668         h->mb.i_cbp_luma = 0x00;
669         for( i = 0; i < 16; i++ )
670         {
671             const int nz = array_non_zero_count( h->dct.block[i].residual_ac, 15 );
672             h->mb.cache.non_zero_count[x264_scan8[i]] = nz;
673             if( nz > 0 )
674             {
675                 h->mb.i_cbp_luma = 0x0f;
676             }
677         }
678     }
679     else
680     {
681         h->mb.i_cbp_luma = 0x00;
682         for( i = 0; i < 16; i++ )
683         {
684             const int nz = array_non_zero_count( h->dct.block[i].luma4x4, 16 );
685             h->mb.cache.non_zero_count[x264_scan8[i]] = nz;
686             if( nz > 0 )
687             {
688                 h->mb.i_cbp_luma |= 1 << (i/4);
689             }
690         }
691     }
692
693     /* Calculate the chroma patern */
694     h->mb.i_cbp_chroma = 0x00;
695     for( i = 0; i < 8; i++ )
696     {
697         const int nz = array_non_zero_count( h->dct.block[16+i].residual_ac, 15 );
698         h->mb.cache.non_zero_count[x264_scan8[16+i]] = nz;
699         if( nz > 0 )
700         {
701             h->mb.i_cbp_chroma = 0x02;    /* dc+ac (we can't do only ac) */
702         }
703     }
704     if( h->mb.i_cbp_chroma == 0x00 &&
705         ( array_non_zero_count( h->dct.chroma_dc[0], 4 ) > 0 || array_non_zero_count( h->dct.chroma_dc[1], 4 ) ) > 0 )
706     {
707         h->mb.i_cbp_chroma = 0x01;    /* dc only */
708     }
709
710     if( h->param.b_cabac )
711     {
712         if( h->mb.i_type == I_16x16 && array_non_zero_count( h->dct.luma16x16_dc, 16 ) > 0 )
713             i_cbp_dc = 0x01;
714         else
715             i_cbp_dc = 0x00;
716
717         if( array_non_zero_count( h->dct.chroma_dc[0], 4 ) > 0 )
718             i_cbp_dc |= 0x02;
719         if( array_non_zero_count( h->dct.chroma_dc[1], 4 ) > 0 )
720             i_cbp_dc |= 0x04;
721     }
722
723     /* store cbp */
724     h->mb.cbp[h->mb.i_mb_xy] = (i_cbp_dc << 8) | (h->mb.i_cbp_chroma << 4) | h->mb.i_cbp_luma;
725
726     if( h->mb.i_type != I_16x16 && h->mb.i_cbp_luma == 0 && h->mb.i_cbp_chroma == 0 )
727     {
728         /* It won'y change anything at the decoder side but it is needed else the
729          * decoder will fail to read the next QP */
730         h->mb.qp[h->mb.i_mb_xy] = h->mb.i_last_qp;
731     }
732
733
734     /* Check for P_SKIP
735      * XXX: in the me perhaps we should take x264_mb_predict_mv_pskip into account
736      *      (if multiple mv give same result)*/
737     if( h->mb.i_type == P_L0 && h->mb.i_partition == D_16x16 &&
738         h->mb.i_cbp_luma == 0x00 && h->mb.i_cbp_chroma== 0x00 )
739     {
740         if( h->mb.cache.ref[0][x264_scan8[0]] == 0 )
741         {
742             int mvp[2];
743
744             x264_mb_predict_mv_pskip( h, mvp );
745             if( h->mb.cache.mv[0][x264_scan8[0]][0] == mvp[0] &&
746                 h->mb.cache.mv[0][x264_scan8[0]][1] == mvp[1] )
747             {
748                 h->mb.type[h->mb.i_mb_xy] = h->mb.i_type = P_SKIP;
749                 h->mb.qp[h->mb.i_mb_xy] = h->mb.i_last_qp;  /* Needed */
750             }
751         }
752     }
753 }
754
755 /*****************************************************************************
756  * x264_macroblock_probe_pskip:
757  *  Check if the current MB could be encoded as a P_SKIP (it supposes you use
758  *  the previous QP
759  *****************************************************************************/
760 int x264_macroblock_probe_pskip( x264_t *h )
761 {
762     DECLARE_ALIGNED( int16_t, dct4x4[16][4][4], 16 );
763     DECLARE_ALIGNED( int16_t, dct2x2[2][2], 16 );
764     DECLARE_ALIGNED( int,     dctscan[16], 16 );
765
766     int i_qp;
767     int mvp[2];
768     int ch;
769     int n;
770
771     int i8x8, i4x4;
772     int i_decimate_mb;
773
774     /* quantification scale */
775     i_qp = h->mb.qp[h->mb.i_mb_xy];
776
777     /* Get the MV */
778     x264_mb_predict_mv_pskip( h, mvp );
779
780     /* Special case, need to clip the vector */
781     n = 16 * h->mb.i_mb_x + mvp[0];
782     if( n < -24 )
783         mvp[0] = -24 - 16*h->mb.i_mb_x;
784     else if( n > 16 * h->sps->i_mb_width + 24 )
785         mvp[0] = 16 * ( h->sps->i_mb_width - h->mb.i_mb_x ) + 24;
786
787     n = 16 * h->mb.i_mb_y + mvp[1];
788     if( n < -24 )
789         mvp[1] = -24 - 16*h->mb.i_mb_y;
790     else if( n > 16 * h->sps->i_mb_height + 8 )
791         mvp[1] = 16 * ( h->sps->i_mb_height - h->mb.i_mb_y ) + 8;
792
793
794     /* Motion compensation */
795     h->mc[MC_LUMA]( h->mb.pic.p_fref[0][0][0], h->mb.pic.i_stride[0],
796                     h->mb.pic.p_fdec[0],       h->mb.pic.i_stride[0],
797                     mvp[0], mvp[1], 16, 16 );
798
799     /* get luma diff */
800     h->dctf.sub16x16_dct( dct4x4, h->mb.pic.p_fenc[0], h->mb.pic.i_stride[0],
801                                   h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0] );
802
803     for( i8x8 = 0, i_decimate_mb = 0; i8x8 < 4; i8x8++ )
804     {
805         /* encode one 4x4 block */
806         for( i4x4 = 0; i4x4 < 4; i4x4++ )
807         {
808             const int idx = i8x8 * 4 + i4x4;
809
810             quant_4x4( dct4x4[idx], i_qp, 0 );
811             scan_zigzag_4x4full( dctscan, dct4x4[idx] );
812
813             i_decimate_mb += x264_mb_decimate_score( dctscan, 16 );
814
815             if( i_decimate_mb >= 6 )
816             {
817                 /* not as P_SKIP */
818                 return 0;
819             }
820         }
821     }
822
823     /* encode chroma */
824     i_qp = i_chroma_qp_table[x264_clip3( i_qp + h->pps->i_chroma_qp_index_offset, 0, 51 )];
825
826     for( ch = 0; ch < 2; ch++ )
827     {
828         const int i_stride = h->mb.pic.i_stride[1+ch];
829         uint8_t  *p_src = h->mb.pic.p_fenc[1+ch];
830         uint8_t  *p_dst = h->mb.pic.p_fdec[1+ch];
831
832         h->mc[MC_CHROMA]( h->mb.pic.p_fref[0][0][1+ch], i_stride,
833                           h->mb.pic.p_fdec[1+ch],       i_stride,
834                           mvp[0], mvp[1], 8, 8 );
835
836         h->dctf.sub8x8_dct( dct4x4, p_src, i_stride, p_dst, i_stride );
837
838         /* calculate dct DC */
839         dct2x2[0][0] = dct4x4[0][0][0];
840         dct2x2[0][1] = dct4x4[1][0][0];
841         dct2x2[1][0] = dct4x4[2][0][0];
842         dct2x2[1][1] = dct4x4[3][0][0];
843         h->dctf.dct2x2dc( dct2x2 );
844         quant_2x2_dc( dct2x2, i_qp, 0 );
845         if( dct2x2[0][0] || dct2x2[0][1] || dct2x2[1][0] || dct2x2[1][1]  )
846         {
847             /* can't be */
848             return 0;
849         }
850
851         /* calculate dct coeffs */
852         for( i4x4 = 0, i_decimate_mb = 0; i4x4 < 4; i4x4++ )
853         {
854             quant_4x4( dct4x4[i4x4], i_qp, 0 );
855             scan_zigzag_4x4( dctscan, dct4x4[i4x4] );
856
857             i_decimate_mb += x264_mb_decimate_score( dctscan, 15 );
858             if( i_decimate_mb >= 7 )
859             {
860                 return 0;
861             }
862         }
863     }
864
865     return 1;
866 }