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