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