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