0b767038bdd511aec1e38c1b1b4505a7cc8cc30c
[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         /* fix the pred mode value */
571         h->mb.i_intra16x16_pred_mode = x264_mb_pred_mode16x16_fix[i_mode];
572     }
573     else if( h->mb.i_type == I_8x8 )
574     {
575         h->mb.b_transform_8x8 = 1;
576         for( i = 0; i < 4; i++ )
577         {
578             const int i_dst = h->mb.pic.i_stride[0];
579             uint8_t  *p_dst = &h->mb.pic.p_fdec[0][8 * (i&1) + 8 * (i>>1) * i_dst];
580             int      i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[4*i]];
581
582             h->predict_8x8[i_mode]( p_dst, i_dst, h->mb.i_neighbour8[i] );
583             x264_mb_encode_i8x8( h, i, i_qp );
584             h->mb.cache.intra4x4_pred_mode[x264_scan8[4*i]] = x264_mb_pred_mode4x4_fix(i_mode);
585         }
586     }
587     else if( h->mb.i_type == I_4x4 )
588     {
589         h->mb.b_transform_8x8 = 0;
590         for( i = 0; i < 16; i++ )
591         {
592             const int i_dst = h->mb.pic.i_stride[0];
593             uint8_t  *p_dst = &h->mb.pic.p_fdec[0][4 * block_idx_x[i] + 4 * block_idx_y[i] * i_dst];
594             int      i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[i]];
595
596             if( (h->mb.i_neighbour4[i] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
597                 /* emulate missing topright samples */
598                 *(uint32_t*) &p_dst[4 - i_dst] = p_dst[3 - i_dst] * 0x01010101U;
599
600             h->predict_4x4[i_mode]( p_dst, i_dst );
601             x264_mb_encode_i4x4( h, i, i_qp );
602             h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] = x264_mb_pred_mode4x4_fix(i_mode);
603         }
604     }
605     else    /* Inter MB */
606     {
607         int i8x8, i4x4, idx;
608         int i_decimate_mb = 0;
609
610         /* Motion compensation */
611         x264_mb_mc( h );
612
613         if( h->mb.b_lossless )
614         {
615             for( i4x4 = 0; i4x4 < 16; i4x4++ )
616             {
617                 int o = block_idx_x[i4x4]*4 + block_idx_y[i4x4]*4 * h->mb.pic.i_stride[0];
618                 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] );
619             }
620         }
621         else if( h->mb.b_transform_8x8 )
622         {
623             int16_t dct8x8[4][8][8];
624             h->dctf.sub16x16_dct8( dct8x8,
625                                    h->mb.pic.p_fenc[0], h->mb.pic.i_stride[0],
626                                    h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0] );
627
628             for( idx = 0; idx < 4; idx++ )
629             {
630                 int i_decimate_8x8;
631
632                 quant_8x8( h, dct8x8[idx], h->quant8_mf[CQM_8PY], i_qp, 0 );
633                 scan_zigzag_8x8full( h->dct.luma8x8[idx], dct8x8[idx] );
634                 x264_mb_dequant_8x8( dct8x8[idx], h->dequant8_mf[CQM_8PY], i_qp );
635
636                 i_decimate_8x8 = x264_mb_decimate_score( h->dct.luma8x8[idx], 64 );
637                 i_decimate_mb += i_decimate_8x8;
638                 if( i_decimate_8x8 < 4 )
639                 {
640                     memset( h->dct.luma8x8[idx], 0, sizeof( h->dct.luma8x8[idx] ) );
641                     memset( dct8x8[idx], 0, sizeof( dct8x8[idx] ) );
642                 }
643             }
644
645             if( i_decimate_mb < 6 )
646                 memset( h->dct.luma8x8, 0, sizeof( h->dct.luma8x8 ) );
647             else
648                 h->dctf.add16x16_idct8( h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0], dct8x8 );
649         }
650         else
651         {
652             int16_t dct4x4[16][4][4];
653             h->dctf.sub16x16_dct( dct4x4,
654                                   h->mb.pic.p_fenc[0], h->mb.pic.i_stride[0],
655                                   h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0] );
656
657             for( i8x8 = 0; i8x8 < 4; i8x8++ )
658             {
659                 int i_decimate_8x8;
660
661                 /* encode one 4x4 block */
662                 i_decimate_8x8 = 0;
663                 for( i4x4 = 0; i4x4 < 4; i4x4++ )
664                 {
665                     idx = i8x8 * 4 + i4x4;
666
667                     quant_4x4( h, dct4x4[idx], h->quant4_mf[CQM_4PY], i_qp, 0 );
668                     scan_zigzag_4x4full( h->dct.block[idx].luma4x4, dct4x4[idx] );
669                     x264_mb_dequant_4x4( dct4x4[idx], h->dequant4_mf[CQM_4PY], i_qp );
670
671                     i_decimate_8x8 += x264_mb_decimate_score( h->dct.block[idx].luma4x4, 16 );
672                 }
673
674                 /* decimate this 8x8 block */
675                 i_decimate_mb += i_decimate_8x8;
676                 if( i_decimate_8x8 < 4 )
677                 {
678                     for( i4x4 = 0; i4x4 < 4; i4x4++ )
679                     {
680                         int x, y;
681                         idx = i8x8 * 4 + i4x4;
682                         for( i = 0; i < 16; i++ )
683                             h->dct.block[idx].luma4x4[i] = 0;
684                         for( x = 0; x < 4; x++ )
685                             for( y = 0; y < 4; y++ )
686                                 dct4x4[idx][x][y] = 0;
687                     }
688                 }
689             }
690
691             if( i_decimate_mb < 6 )
692                 for( idx = 0; idx < 16; idx++ )
693                     for( i = 0; i < 16; i++ )
694                         h->dct.block[idx].luma4x4[i] = 0;
695             else
696                 h->dctf.add16x16_idct( h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0], dct4x4 );
697         }
698     }
699
700     /* encode chroma */
701     i_qp = i_chroma_qp_table[x264_clip3( i_qp + h->pps->i_chroma_qp_index_offset, 0, 51 )];
702     if( IS_INTRA( h->mb.i_type ) )
703     {
704         const int i_mode = h->mb.i_chroma_pred_mode;
705         h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1], h->mb.pic.i_stride[1] );
706         h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2], h->mb.pic.i_stride[2] );
707     }
708
709     /* encode the 8x8 blocks */
710     x264_mb_encode_8x8_chroma( h, !IS_INTRA( h->mb.i_type ), i_qp );
711
712     /* Calculate the Luma/Chroma patern and non_zero_count */
713     h->mb.i_cbp_luma = 0x00;
714     if( h->mb.i_type == I_16x16 )
715     {
716         for( i = 0; i < 16; i++ )
717         {
718             const int nz = array_non_zero_count( h->dct.block[i].residual_ac, 15 );
719             h->mb.cache.non_zero_count[x264_scan8[i]] = nz;
720             if( nz > 0 )
721                 h->mb.i_cbp_luma = 0x0f;
722         }
723     }
724     else if( h->mb.b_transform_8x8 )
725     {
726         /* coded_block_flag is enough for CABAC.
727          * the full non_zero_count is done only in CAVLC. */
728         for( i = 0; i < 4; i++ )
729         {
730             const int nz = array_non_zero( h->dct.luma8x8[i], 64 );
731             int j;
732             for( j = 0; j < 4; j++ )
733                 h->mb.cache.non_zero_count[x264_scan8[4*i+j]] = nz;
734             if( nz > 0 )
735                 h->mb.i_cbp_luma |= 1 << i;
736         }
737     }
738     else
739     {
740         for( i = 0; i < 16; i++ )
741         {
742             const int nz = array_non_zero_count( h->dct.block[i].luma4x4, 16 );
743             h->mb.cache.non_zero_count[x264_scan8[i]] = nz;
744             if( nz > 0 )
745                 h->mb.i_cbp_luma |= 1 << (i/4);
746         }
747     }
748
749     /* Calculate the chroma patern */
750     h->mb.i_cbp_chroma = 0x00;
751     for( i = 0; i < 8; i++ )
752     {
753         const int nz = array_non_zero_count( h->dct.block[16+i].residual_ac, 15 );
754         h->mb.cache.non_zero_count[x264_scan8[16+i]] = nz;
755         if( nz > 0 )
756         {
757             h->mb.i_cbp_chroma = 0x02;    /* dc+ac (we can't do only ac) */
758         }
759     }
760     if( h->mb.i_cbp_chroma == 0x00 &&
761         ( array_non_zero_count( h->dct.chroma_dc[0], 4 ) > 0 || array_non_zero_count( h->dct.chroma_dc[1], 4 ) ) > 0 )
762     {
763         h->mb.i_cbp_chroma = 0x01;    /* dc only */
764     }
765
766     if( h->param.b_cabac )
767     {
768         if( h->mb.i_type == I_16x16 && array_non_zero_count( h->dct.luma16x16_dc, 16 ) > 0 )
769             i_cbp_dc = 0x01;
770         else
771             i_cbp_dc = 0x00;
772
773         if( array_non_zero_count( h->dct.chroma_dc[0], 4 ) > 0 )
774             i_cbp_dc |= 0x02;
775         if( array_non_zero_count( h->dct.chroma_dc[1], 4 ) > 0 )
776             i_cbp_dc |= 0x04;
777     }
778
779     /* store cbp */
780     h->mb.cbp[h->mb.i_mb_xy] = (i_cbp_dc << 8) | (h->mb.i_cbp_chroma << 4) | h->mb.i_cbp_luma;
781
782     if( h->mb.i_type != I_16x16 && h->mb.i_cbp_luma == 0 && h->mb.i_cbp_chroma == 0 )
783     {
784         /* It won'y change anything at the decoder side but it is needed else the
785          * decoder will fail to read the next QP */
786         h->mb.qp[h->mb.i_mb_xy] = h->mb.i_last_qp;
787     }
788
789
790     /* Check for P_SKIP
791      * XXX: in the me perhaps we should take x264_mb_predict_mv_pskip into account
792      *      (if multiple mv give same result)*/
793     if( h->mb.i_type == P_L0 && h->mb.i_partition == D_16x16 &&
794         h->mb.i_cbp_luma == 0x00 && h->mb.i_cbp_chroma== 0x00 &&
795         h->mb.cache.ref[0][x264_scan8[0]] == 0 )
796     {
797         int mvp[2];
798
799         x264_mb_predict_mv_pskip( h, mvp );
800         if( h->mb.cache.mv[0][x264_scan8[0]][0] == mvp[0] &&
801             h->mb.cache.mv[0][x264_scan8[0]][1] == mvp[1] )
802         {
803             h->mb.i_type = P_SKIP;
804             h->mb.qp[h->mb.i_mb_xy] = h->mb.i_last_qp;  /* Needed */
805             /* XXX qp reset may have issues when used in RD instead of the real encode */
806         }
807     }
808
809     /* Check for B_SKIP */
810     if( h->mb.i_type == B_DIRECT &&
811         h->mb.i_cbp_luma == 0x00 && h->mb.i_cbp_chroma== 0x00 )
812     {
813         h->mb.i_type = B_SKIP;
814         h->mb.qp[h->mb.i_mb_xy] = h->mb.i_last_qp;  /* Needed */
815     }
816
817     if( h->mb.i_cbp_luma == 0 && h->mb.i_type != I_8x8 )
818         h->mb.b_transform_8x8 = 0;
819 }
820
821 /*****************************************************************************
822  * x264_macroblock_probe_skip:
823  *  Check if the current MB could be encoded as a [PB]_SKIP (it supposes you use
824  *  the previous QP
825  *****************************************************************************/
826 int x264_macroblock_probe_skip( x264_t *h, int b_bidir )
827 {
828     DECLARE_ALIGNED( int16_t, dct4x4[16][4][4], 16 );
829     DECLARE_ALIGNED( int16_t, dct2x2[2][2], 16 );
830     DECLARE_ALIGNED( int,     dctscan[16], 16 );
831
832     int i_qp = h->mb.i_qp;
833     int mvp[2];
834     int ch;
835
836     int i8x8, i4x4;
837     int i_decimate_mb;
838
839     if( !b_bidir )
840     {
841         /* Get the MV */
842         x264_mb_predict_mv_pskip( h, mvp );
843         mvp[0] = x264_clip3( mvp[0], h->mb.mv_min[0], h->mb.mv_max[0] );
844         mvp[1] = x264_clip3( mvp[1], h->mb.mv_min[1], h->mb.mv_max[1] );
845
846         /* Motion compensation */
847         h->mc.mc_luma( h->mb.pic.p_fref[0][0], h->mb.pic.i_stride[0],
848                         h->mb.pic.p_fdec[0],   h->mb.pic.i_stride[0],
849                         mvp[0], mvp[1], 16, 16 );
850     }
851
852     /* get luma diff */
853     h->dctf.sub16x16_dct( dct4x4, h->mb.pic.p_fenc[0], h->mb.pic.i_stride[0],
854                                   h->mb.pic.p_fdec[0], h->mb.pic.i_stride[0] );
855
856     for( i8x8 = 0, i_decimate_mb = 0; i8x8 < 4; i8x8++ )
857     {
858         /* encode one 4x4 block */
859         for( i4x4 = 0; i4x4 < 4; i4x4++ )
860         {
861             const int idx = i8x8 * 4 + i4x4;
862
863             quant_4x4( h, dct4x4[idx], (int(*)[4][4])def_quant4_mf, i_qp, 0 );
864             scan_zigzag_4x4full( dctscan, dct4x4[idx] );
865
866             i_decimate_mb += x264_mb_decimate_score( dctscan, 16 );
867
868             if( i_decimate_mb >= 6 )
869             {
870                 /* not as P_SKIP */
871                 return 0;
872             }
873         }
874     }
875
876     /* encode chroma */
877     i_qp = i_chroma_qp_table[x264_clip3( i_qp + h->pps->i_chroma_qp_index_offset, 0, 51 )];
878
879     for( ch = 0; ch < 2; ch++ )
880     {
881         const int i_stride = h->mb.pic.i_stride[1+ch];
882         uint8_t  *p_src = h->mb.pic.p_fenc[1+ch];
883         uint8_t  *p_dst = h->mb.pic.p_fdec[1+ch];
884
885         if( !b_bidir )
886         {
887             h->mc.mc_chroma( h->mb.pic.p_fref[0][0][4+ch], i_stride,
888                               h->mb.pic.p_fdec[1+ch],       i_stride,
889                               mvp[0], mvp[1], 8, 8 );
890         }
891
892         h->dctf.sub8x8_dct( dct4x4, p_src, i_stride, p_dst, i_stride );
893
894         /* calculate dct DC */
895         dct2x2[0][0] = dct4x4[0][0][0];
896         dct2x2[0][1] = dct4x4[1][0][0];
897         dct2x2[1][0] = dct4x4[2][0][0];
898         dct2x2[1][1] = dct4x4[3][0][0];
899         h->dctf.dct2x2dc( dct2x2 );
900         quant_2x2_dc( h, dct2x2, (int(*)[4][4])def_quant4_mf, i_qp, 0 );
901         if( dct2x2[0][0] || dct2x2[0][1] || dct2x2[1][0] || dct2x2[1][1]  )
902         {
903             /* can't be */
904             return 0;
905         }
906
907         /* calculate dct coeffs */
908         for( i4x4 = 0, i_decimate_mb = 0; i4x4 < 4; i4x4++ )
909         {
910             quant_4x4( h, dct4x4[i4x4], (int(*)[4][4])def_quant4_mf, i_qp, 0 );
911             scan_zigzag_4x4( dctscan, dct4x4[i4x4] );
912
913             i_decimate_mb += x264_mb_decimate_score( dctscan, 15 );
914             if( i_decimate_mb >= 7 )
915             {
916                 return 0;
917             }
918         }
919     }
920
921     return 1;
922 }