faster decimation
[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 /* (ref: JVT-B118)
151  * x264_mb_decimate_score: given dct coeffs it returns a score to see if we could empty this dct coeffs
152  * to 0 (low score means set it to null)
153  * Used in inter macroblock (luma and chroma)
154  *  luma: for a 8x8 block: if score < 4 -> null
155  *        for the complete mb: if score < 6 -> null
156  *  chroma: for the complete mb: if score < 7 -> null
157  */
158 static int x264_mb_decimate_score( int *dct, int i_max )
159 {
160     static const int i_ds_table4[16] = {
161         3,2,2,1,1,1,0,0,0,0,0,0,0,0,0,0 };
162     static const int i_ds_table8[64] = {
163         3,3,3,3,2,2,2,2,2,2,2,2,1,1,1,1,
164         1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,
165         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
166         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
167
168     const int *ds_table = (i_max == 64) ? i_ds_table8 : i_ds_table4;
169     int i_score = 0;
170     int idx = i_max - 1;
171
172     while( idx >= 0 && dct[idx] == 0 )
173         idx--;
174
175     while( idx >= 0 )
176     {
177         int i_run;
178
179         if( abs( dct[idx--] ) > 1 )
180             return 9;
181
182         i_run = 0;
183         while( idx >= 0 && dct[idx] == 0 )
184         {
185             idx--;
186             i_run++;
187         }
188         i_score += ds_table[i_run];
189     }
190
191     return i_score;
192 }
193
194 void x264_mb_encode_i4x4( x264_t *h, int idx, int i_qscale )
195 {
196     const int i_stride = h->mb.pic.i_stride[0];
197     const int i_offset = 4 * block_idx_x[idx] + 4 * block_idx_y[idx] * i_stride;
198     uint8_t *p_src = &h->mb.pic.p_fenc[0][i_offset];
199     uint8_t *p_dst = &h->mb.pic.p_fdec[0][i_offset];
200     int16_t dct4x4[4][4];
201
202     if( h->mb.b_lossless )
203     {
204         sub_zigzag_4x4full( h->dct.block[idx].luma4x4, p_src, p_dst, i_stride );
205         return;
206     }
207
208     h->dctf.sub4x4_dct( dct4x4, p_src, i_stride, p_dst, i_stride );
209     quant_4x4( h, dct4x4, h->quant4_mf[CQM_4IY], i_qscale, 1 );
210     scan_zigzag_4x4full( h->dct.block[idx].luma4x4, dct4x4 );
211     x264_mb_dequant_4x4( dct4x4, h->dequant4_mf[CQM_4IY], i_qscale );
212
213     /* output samples to fdec */
214     h->dctf.add4x4_idct( p_dst, i_stride, dct4x4 );
215 }
216
217 void x264_mb_encode_i8x8( x264_t *h, int idx, int i_qscale )
218 {
219     const int i_stride = h->mb.pic.i_stride[0];
220     const int i_offset = 8 * (idx&1) + 8 * (idx>>1) * i_stride;
221     uint8_t *p_src = &h->mb.pic.p_fenc[0][i_offset];
222     uint8_t *p_dst = &h->mb.pic.p_fdec[0][i_offset];
223     int16_t dct8x8[8][8];
224
225     h->dctf.sub8x8_dct8( dct8x8, p_src, i_stride, p_dst, i_stride );
226     quant_8x8( h, dct8x8, h->quant8_mf[CQM_8IY], i_qscale, 1 );
227     scan_zigzag_8x8full( h->dct.luma8x8[idx], dct8x8 );
228     x264_mb_dequant_8x8( dct8x8, h->dequant8_mf[CQM_8IY], i_qscale );
229     h->dctf.add8x8_idct8( p_dst, i_stride, dct8x8 );
230 }
231
232 static void x264_mb_encode_i16x16( x264_t *h, int i_qscale )
233 {
234     const int i_stride = h->mb.pic.i_stride[0];
235     uint8_t  *p_src = h->mb.pic.p_fenc[0];
236     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
237
238     int16_t dct4x4[16+1][4][4];
239
240     int i;
241
242     if( h->mb.b_lossless )
243     {
244         for( i = 0; i < 16; i++ )
245         {
246             int o = block_idx_x[i]*4 + block_idx_y[i]*4*i_stride;
247             sub_zigzag_4x4( h->dct.block[i].residual_ac, p_src+o, p_dst+o, i_stride );
248             dct4x4[0][block_idx_y[i]][block_idx_x[i]] = p_src[o] - p_dst[o];
249             p_dst[o] = p_src[o];
250         }
251         scan_zigzag_4x4full( h->dct.luma16x16_dc, dct4x4[0] );
252         return;
253     }
254
255     h->dctf.sub16x16_dct( &dct4x4[1], p_src, i_stride, p_dst, i_stride );
256     for( i = 0; i < 16; i++ )
257     {
258         /* copy dc coeff */
259         dct4x4[0][block_idx_y[i]][block_idx_x[i]] = dct4x4[1+i][0][0];
260
261         /* quant/scan/dequant */
262         quant_4x4( h, dct4x4[1+i], h->quant4_mf[CQM_4IY], i_qscale, 1 );
263         scan_zigzag_4x4( h->dct.block[i].residual_ac, dct4x4[1+i] );
264         x264_mb_dequant_4x4( dct4x4[1+i], h->dequant4_mf[CQM_4IY], i_qscale );
265     }
266
267     h->dctf.dct4x4dc( dct4x4[0] );
268     quant_4x4_dc( h, dct4x4[0], h->quant4_mf[CQM_4IY], i_qscale );
269     scan_zigzag_4x4full( h->dct.luma16x16_dc, dct4x4[0] );
270
271     /* output samples to fdec */
272     h->dctf.idct4x4dc( dct4x4[0] );
273     x264_mb_dequant_4x4_dc( dct4x4[0], h->dequant4_mf[CQM_4IY], i_qscale );  /* XXX not inversed */
274
275     /* calculate dct coeffs */
276     for( i = 0; i < 16; i++ )
277     {
278         /* copy dc coeff */
279         dct4x4[1+i][0][0] = dct4x4[0][block_idx_y[i]][block_idx_x[i]];
280     }
281     /* put pixels to fdec */
282     h->dctf.add16x16_idct( p_dst, i_stride, &dct4x4[1] );
283 }
284
285 static void x264_mb_encode_8x8_chroma( x264_t *h, int b_inter, int i_qscale )
286 {
287     int i, ch;
288
289     for( ch = 0; ch < 2; ch++ )
290     {
291         const int i_stride = h->mb.pic.i_stride[1+ch];
292         uint8_t  *p_src = h->mb.pic.p_fenc[1+ch];
293         uint8_t  *p_dst = h->mb.pic.p_fdec[1+ch];
294         int i_decimate_score = 0;
295
296         int16_t dct2x2[2][2];
297         int16_t dct4x4[4][4][4];
298
299         if( h->mb.b_lossless )
300         {
301             for( i = 0; i < 4; i++ )
302             {
303                 int o = block_idx_x[i]*4 + block_idx_y[i]*4*i_stride;
304                 sub_zigzag_4x4( h->dct.block[16+i+ch*4].residual_ac, p_src+o, p_dst+o, i_stride );
305                 h->dct.chroma_dc[ch][i] = p_src[o] - p_dst[o];
306                 p_dst[o] = p_src[o];
307             }
308             continue;
309         }
310             
311         h->dctf.sub8x8_dct( dct4x4, p_src, i_stride, p_dst, i_stride );
312         /* calculate dct coeffs */
313         for( i = 0; i < 4; i++ )
314         {
315             /* copy dc coeff */
316             dct2x2[block_idx_y[i]][block_idx_x[i]] = dct4x4[i][0][0];
317
318             quant_4x4( h, dct4x4[i], h->quant4_mf[CQM_4IC + b_inter], i_qscale, !b_inter );
319             scan_zigzag_4x4( h->dct.block[16+i+ch*4].residual_ac, dct4x4[i] );
320             x264_mb_dequant_4x4( dct4x4[i], h->dequant4_mf[CQM_4IC + b_inter], i_qscale );
321
322             if( b_inter )
323             {
324                 i_decimate_score += x264_mb_decimate_score( h->dct.block[16+i+ch*4].residual_ac, 15 );
325             }
326         }
327
328         h->dctf.dct2x2dc( dct2x2 );
329         quant_2x2_dc( h, dct2x2, h->quant4_mf[CQM_4IC + b_inter], i_qscale, !b_inter );
330         scan_zigzag_2x2_dc( h->dct.chroma_dc[ch], dct2x2 );
331
332         /* output samples to fdec */
333         h->dctf.idct2x2dc( dct2x2 );
334         x264_mb_dequant_2x2_dc( dct2x2, h->dequant4_mf[CQM_4IC + b_inter], i_qscale );  /* XXX not inversed */
335
336         if( b_inter && i_decimate_score < 7 )
337         {
338             /* Near null chroma 8x8 block so make it null (bits saving) */
339             memset( dct4x4, 0, sizeof( dct4x4 ) );
340             memset( &h->dct.block[16+ch*4], 0, 4 * sizeof( *h->dct.block ) );
341         }
342
343         /* calculate dct coeffs */
344         for( i = 0; i < 4; i++ )
345         {
346             /* copy dc coeff */
347             dct4x4[i][0][0] = dct2x2[block_idx_y[i]][block_idx_x[i]];
348         }
349         h->dctf.add8x8_idct( p_dst, i_stride, dct4x4 );
350     }
351 }
352
353 static void x264_macroblock_encode_skip( x264_t *h )
354 {
355     int i;
356     h->mb.i_cbp_luma = 0x00;
357     h->mb.i_cbp_chroma = 0x00;
358
359     for( i = 0; i < 16+8; i++ )
360     {
361         h->mb.cache.non_zero_count[x264_scan8[i]] = 0;
362     }
363
364     /* store cbp */
365     h->mb.cbp[h->mb.i_mb_xy] = 0;
366 }
367
368 /*****************************************************************************
369  * x264_macroblock_encode_pskip:
370  *  Encode an already marked skip block
371  *****************************************************************************/
372 void x264_macroblock_encode_pskip( x264_t *h )
373 {
374     const int mvx = x264_clip3( h->mb.cache.mv[0][x264_scan8[0]][0],
375                                 h->mb.mv_min[0], h->mb.mv_max[0] );
376     const int mvy = x264_clip3( h->mb.cache.mv[0][x264_scan8[0]][1],
377                                 h->mb.mv_min[1], h->mb.mv_max[1] );
378
379     /* Motion compensation XXX probably unneeded */
380     h->mc.mc_luma( h->mb.pic.p_fref[0][0], h->mb.pic.i_stride[0],
381                     h->mb.pic.p_fdec[0],       h->mb.pic.i_stride[0],
382                     mvx, mvy, 16, 16 );
383
384     /* Chroma MC */
385     h->mc.mc_chroma( h->mb.pic.p_fref[0][0][4], h->mb.pic.i_stride[1],
386                       h->mb.pic.p_fdec[1],       h->mb.pic.i_stride[1],
387                       mvx, mvy, 8, 8 );
388
389     h->mc.mc_chroma( h->mb.pic.p_fref[0][0][5], h->mb.pic.i_stride[2],
390                       h->mb.pic.p_fdec[2],       h->mb.pic.i_stride[2],
391                       mvx, mvy, 8, 8 );
392
393     x264_macroblock_encode_skip( h );
394 }
395
396 /*****************************************************************************
397  * x264_macroblock_encode:
398  *****************************************************************************/
399 void x264_macroblock_encode( x264_t *h )
400 {
401     int i_cbp_dc = 0;
402     int i_qp = h->mb.i_qp;
403     int i;
404
405     if( h->mb.i_type == P_SKIP )
406     {
407         /* A bit special */
408         x264_macroblock_encode_pskip( h );
409         return;
410     }
411     if( h->mb.i_type == B_SKIP )
412     {
413         /* XXX motion compensation is probably unneeded */
414         x264_mb_mc( h );
415         x264_macroblock_encode_skip( h );
416         return;
417     }
418
419     if( h->mb.i_type == I_16x16 )
420     {
421         const int i_mode = h->mb.i_intra16x16_pred_mode;
422         h->mb.b_transform_8x8 = 0;
423         /* do the right prediction */
424         h->predict_16x16[i_mode]( h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0] );
425
426         /* encode the 16x16 macroblock */
427         x264_mb_encode_i16x16( h, i_qp );
428     }
429     else if( h->mb.i_type == I_8x8 )
430     {
431         h->mb.b_transform_8x8 = 1;
432         for( i = 0; i < 4; i++ )
433         {
434             const int i_dst = h->mb.pic.i_stride[0];
435             uint8_t  *p_dst = &h->mb.pic.p_fdec[0][8 * (i&1) + 8 * (i>>1) * i_dst];
436             int      i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[4*i]];
437
438             h->predict_8x8[i_mode]( p_dst, i_dst, h->mb.i_neighbour8[i] );
439             x264_mb_encode_i8x8( h, i, i_qp );
440         }
441     }
442     else if( h->mb.i_type == I_4x4 )
443     {
444         h->mb.b_transform_8x8 = 0;
445         for( i = 0; i < 16; i++ )
446         {
447             const int i_dst = h->mb.pic.i_stride[0];
448             uint8_t  *p_dst = &h->mb.pic.p_fdec[0][4 * block_idx_x[i] + 4 * block_idx_y[i] * i_dst];
449             int      i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[i]];
450
451             if( (h->mb.i_neighbour4[i] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
452                 /* emulate missing topright samples */
453                 *(uint32_t*) &p_dst[4 - i_dst] = p_dst[3 - i_dst] * 0x01010101U;
454
455             h->predict_4x4[i_mode]( p_dst, i_dst );
456             x264_mb_encode_i4x4( h, i, i_qp );
457         }
458     }
459     else    /* Inter MB */
460     {
461         int i8x8, i4x4, idx;
462         int i_decimate_mb = 0;
463
464         /* Motion compensation */
465         x264_mb_mc( h );
466
467         if( h->mb.b_lossless )
468         {
469             for( i4x4 = 0; i4x4 < 16; i4x4++ )
470             {
471                 int o = block_idx_x[i4x4]*4 + block_idx_y[i4x4]*4 * h->mb.pic.i_stride[0];
472                 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] );
473             }
474         }
475         else if( h->mb.b_transform_8x8 )
476         {
477             int16_t dct8x8[4][8][8];
478             h->dctf.sub16x16_dct8( dct8x8,
479                                    h->mb.pic.p_fenc[0], h->mb.pic.i_stride[0],
480                                    h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0] );
481
482             for( idx = 0; idx < 4; idx++ )
483             {
484                 int i_decimate_8x8;
485
486                 quant_8x8( h, dct8x8[idx], h->quant8_mf[CQM_8PY], i_qp, 0 );
487                 scan_zigzag_8x8full( h->dct.luma8x8[idx], dct8x8[idx] );
488                 x264_mb_dequant_8x8( dct8x8[idx], h->dequant8_mf[CQM_8PY], i_qp );
489
490                 i_decimate_8x8 = x264_mb_decimate_score( h->dct.luma8x8[idx], 64 );
491                 i_decimate_mb += i_decimate_8x8;
492                 if( i_decimate_8x8 < 4 )
493                 {
494                     memset( h->dct.luma8x8[idx], 0, sizeof( h->dct.luma8x8[idx] ) );
495                     memset( dct8x8[idx], 0, sizeof( dct8x8[idx] ) );
496                 }
497             }
498
499             if( i_decimate_mb < 6 )
500                 memset( h->dct.luma8x8, 0, sizeof( h->dct.luma8x8 ) );
501             else
502                 h->dctf.add16x16_idct8( h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0], dct8x8 );
503         }
504         else
505         {
506             int16_t dct4x4[16][4][4];
507             h->dctf.sub16x16_dct( dct4x4,
508                                   h->mb.pic.p_fenc[0], h->mb.pic.i_stride[0],
509                                   h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0] );
510
511             for( i8x8 = 0; i8x8 < 4; i8x8++ )
512             {
513                 int i_decimate_8x8;
514
515                 /* encode one 4x4 block */
516                 i_decimate_8x8 = 0;
517                 for( i4x4 = 0; i4x4 < 4; i4x4++ )
518                 {
519                     idx = i8x8 * 4 + i4x4;
520
521                     quant_4x4( h, dct4x4[idx], h->quant4_mf[CQM_4PY], i_qp, 0 );
522                     scan_zigzag_4x4full( h->dct.block[idx].luma4x4, dct4x4[idx] );
523                     x264_mb_dequant_4x4( dct4x4[idx], h->dequant4_mf[CQM_4PY], i_qp );
524
525                     i_decimate_8x8 += x264_mb_decimate_score( h->dct.block[idx].luma4x4, 16 );
526                 }
527
528                 /* decimate this 8x8 block */
529                 i_decimate_mb += i_decimate_8x8;
530                 if( i_decimate_8x8 < 4 )
531                 {
532                     memset( &dct4x4[i8x8*4], 0, 4 * sizeof( *dct4x4 ) );
533                     memset( &h->dct.block[i8x8*4], 0, 4 * sizeof( *h->dct.block ) );
534                 }
535             }
536
537             if( i_decimate_mb < 6 )
538                 memset( h->dct.block, 0, 16 * sizeof( *h->dct.block ) );
539             else
540                 h->dctf.add16x16_idct( h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0], dct4x4 );
541         }
542     }
543
544     /* encode chroma */
545     i_qp = i_chroma_qp_table[x264_clip3( i_qp + h->pps->i_chroma_qp_index_offset, 0, 51 )];
546     if( IS_INTRA( h->mb.i_type ) )
547     {
548         const int i_mode = h->mb.i_chroma_pred_mode;
549         h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1], h->mb.pic.i_stride[1] );
550         h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2], h->mb.pic.i_stride[2] );
551     }
552
553     /* encode the 8x8 blocks */
554     x264_mb_encode_8x8_chroma( h, !IS_INTRA( h->mb.i_type ), i_qp );
555
556     /* Calculate the Luma/Chroma patern and non_zero_count */
557     h->mb.i_cbp_luma = 0x00;
558     if( h->mb.i_type == I_16x16 )
559     {
560         for( i = 0; i < 16; i++ )
561         {
562             const int nz = array_non_zero_count( h->dct.block[i].residual_ac, 15 );
563             h->mb.cache.non_zero_count[x264_scan8[i]] = nz;
564             if( nz > 0 )
565                 h->mb.i_cbp_luma = 0x0f;
566         }
567     }
568     else if( h->mb.b_transform_8x8 )
569     {
570         /* coded_block_flag is enough for CABAC.
571          * the full non_zero_count is done only in CAVLC. */
572         for( i = 0; i < 4; i++ )
573         {
574             const int nz = array_non_zero( h->dct.luma8x8[i], 64 );
575             int j;
576             for( j = 0; j < 4; j++ )
577                 h->mb.cache.non_zero_count[x264_scan8[4*i+j]] = nz;
578             if( nz > 0 )
579                 h->mb.i_cbp_luma |= 1 << i;
580         }
581     }
582     else
583     {
584         for( i = 0; i < 16; i++ )
585         {
586             const int nz = array_non_zero_count( h->dct.block[i].luma4x4, 16 );
587             h->mb.cache.non_zero_count[x264_scan8[i]] = nz;
588             if( nz > 0 )
589                 h->mb.i_cbp_luma |= 1 << (i/4);
590         }
591     }
592
593     /* Calculate the chroma patern */
594     h->mb.i_cbp_chroma = 0x00;
595     for( i = 0; i < 8; i++ )
596     {
597         const int nz = array_non_zero_count( h->dct.block[16+i].residual_ac, 15 );
598         h->mb.cache.non_zero_count[x264_scan8[16+i]] = nz;
599         if( nz > 0 )
600         {
601             h->mb.i_cbp_chroma = 0x02;    /* dc+ac (we can't do only ac) */
602         }
603     }
604     if( h->mb.i_cbp_chroma == 0x00 &&
605         ( array_non_zero_count( h->dct.chroma_dc[0], 4 ) > 0 || array_non_zero_count( h->dct.chroma_dc[1], 4 ) ) > 0 )
606     {
607         h->mb.i_cbp_chroma = 0x01;    /* dc only */
608     }
609
610     if( h->param.b_cabac )
611     {
612         if( h->mb.i_type == I_16x16 && array_non_zero_count( h->dct.luma16x16_dc, 16 ) > 0 )
613             i_cbp_dc = 0x01;
614         else
615             i_cbp_dc = 0x00;
616
617         if( array_non_zero_count( h->dct.chroma_dc[0], 4 ) > 0 )
618             i_cbp_dc |= 0x02;
619         if( array_non_zero_count( h->dct.chroma_dc[1], 4 ) > 0 )
620             i_cbp_dc |= 0x04;
621     }
622
623     /* store cbp */
624     h->mb.cbp[h->mb.i_mb_xy] = (i_cbp_dc << 8) | (h->mb.i_cbp_chroma << 4) | h->mb.i_cbp_luma;
625
626     /* Check for P_SKIP
627      * XXX: in the me perhaps we should take x264_mb_predict_mv_pskip into account
628      *      (if multiple mv give same result)*/
629     if( h->mb.i_type == P_L0 && h->mb.i_partition == D_16x16 &&
630         h->mb.i_cbp_luma == 0x00 && h->mb.i_cbp_chroma== 0x00 &&
631         h->mb.cache.ref[0][x264_scan8[0]] == 0 )
632     {
633         int mvp[2];
634
635         x264_mb_predict_mv_pskip( h, mvp );
636         if( h->mb.cache.mv[0][x264_scan8[0]][0] == mvp[0] &&
637             h->mb.cache.mv[0][x264_scan8[0]][1] == mvp[1] )
638         {
639             h->mb.i_type = P_SKIP;
640         }
641     }
642
643     /* Check for B_SKIP */
644     if( h->mb.i_type == B_DIRECT &&
645         h->mb.i_cbp_luma == 0x00 && h->mb.i_cbp_chroma== 0x00 )
646     {
647         h->mb.i_type = B_SKIP;
648     }
649 }
650
651 /*****************************************************************************
652  * x264_macroblock_probe_skip:
653  *  Check if the current MB could be encoded as a [PB]_SKIP (it supposes you use
654  *  the previous QP
655  *****************************************************************************/
656 int x264_macroblock_probe_skip( x264_t *h, int b_bidir )
657 {
658     DECLARE_ALIGNED( int16_t, dct4x4[16][4][4], 16 );
659     DECLARE_ALIGNED( int16_t, dct2x2[2][2], 16 );
660     DECLARE_ALIGNED( int,     dctscan[16], 16 );
661
662     int i_qp = h->mb.i_qp;
663     int mvp[2];
664     int ch;
665
666     int i8x8, i4x4;
667     int i_decimate_mb;
668
669     if( !b_bidir )
670     {
671         /* Get the MV */
672         x264_mb_predict_mv_pskip( h, mvp );
673         mvp[0] = x264_clip3( mvp[0], h->mb.mv_min[0], h->mb.mv_max[0] );
674         mvp[1] = x264_clip3( mvp[1], h->mb.mv_min[1], h->mb.mv_max[1] );
675
676         /* Motion compensation */
677         h->mc.mc_luma( h->mb.pic.p_fref[0][0], h->mb.pic.i_stride[0],
678                         h->mb.pic.p_fdec[0],   h->mb.pic.i_stride[0],
679                         mvp[0], mvp[1], 16, 16 );
680     }
681
682     /* get luma diff */
683     h->dctf.sub16x16_dct( dct4x4, h->mb.pic.p_fenc[0], h->mb.pic.i_stride[0],
684                                   h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0] );
685
686     for( i8x8 = 0, i_decimate_mb = 0; i8x8 < 4; i8x8++ )
687     {
688         /* encode one 4x4 block */
689         for( i4x4 = 0; i4x4 < 4; i4x4++ )
690         {
691             const int idx = i8x8 * 4 + i4x4;
692
693             quant_4x4( h, dct4x4[idx], (int(*)[4][4])def_quant4_mf, i_qp, 0 );
694             scan_zigzag_4x4full( dctscan, dct4x4[idx] );
695
696             i_decimate_mb += x264_mb_decimate_score( dctscan, 16 );
697
698             if( i_decimate_mb >= 6 )
699             {
700                 /* not as P_SKIP */
701                 return 0;
702             }
703         }
704     }
705
706     /* encode chroma */
707     i_qp = i_chroma_qp_table[x264_clip3( i_qp + h->pps->i_chroma_qp_index_offset, 0, 51 )];
708
709     for( ch = 0; ch < 2; ch++ )
710     {
711         const int i_stride = h->mb.pic.i_stride[1+ch];
712         uint8_t  *p_src = h->mb.pic.p_fenc[1+ch];
713         uint8_t  *p_dst = h->mb.pic.p_fdec[1+ch];
714
715         if( !b_bidir )
716         {
717             h->mc.mc_chroma( h->mb.pic.p_fref[0][0][4+ch], i_stride,
718                               h->mb.pic.p_fdec[1+ch],       i_stride,
719                               mvp[0], mvp[1], 8, 8 );
720         }
721
722         h->dctf.sub8x8_dct( dct4x4, p_src, i_stride, p_dst, i_stride );
723
724         /* calculate dct DC */
725         dct2x2[0][0] = dct4x4[0][0][0];
726         dct2x2[0][1] = dct4x4[1][0][0];
727         dct2x2[1][0] = dct4x4[2][0][0];
728         dct2x2[1][1] = dct4x4[3][0][0];
729         h->dctf.dct2x2dc( dct2x2 );
730         quant_2x2_dc( h, dct2x2, (int(*)[4][4])def_quant4_mf, i_qp, 0 );
731         if( dct2x2[0][0] || dct2x2[0][1] || dct2x2[1][0] || dct2x2[1][1]  )
732         {
733             /* can't be */
734             return 0;
735         }
736
737         /* calculate dct coeffs */
738         for( i4x4 = 0, i_decimate_mb = 0; i4x4 < 4; i4x4++ )
739         {
740             quant_4x4( h, dct4x4[i4x4], (int(*)[4][4])def_quant4_mf, i_qp, 0 );
741             scan_zigzag_4x4( dctscan, dct4x4[i4x4] );
742
743             i_decimate_mb += x264_mb_decimate_score( dctscan, 15 );
744             if( i_decimate_mb >= 7 )
745             {
746                 return 0;
747             }
748         }
749     }
750
751     return 1;
752 }