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