Simplify decimate checks in macroblock_encode
[x264/x264-sandbox.git] / encoder / analyse.c
1 /*****************************************************************************
2  * analyse.c: h264 encoder library
3  *****************************************************************************
4  * Copyright (C) 2003-2008 x264 project
5  *
6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7  *          Loren Merritt <lorenm@u.washington.edu>
8  *          Fiona Glaser <fiona@x264.com>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 #define _ISOC99_SOURCE
26 #include <math.h>
27 #include <unistd.h>
28
29 #include "common/common.h"
30 #include "common/cpu.h"
31 #include "macroblock.h"
32 #include "me.h"
33 #include "ratecontrol.h"
34 #include "analyse.h"
35 #include "rdo.c"
36
37 typedef struct
38 {
39     /* 16x16 */
40     int i_ref;
41     int       i_rd16x16;
42     x264_me_t me16x16;
43     x264_me_t bi16x16;      /* for b16x16 BI mode, since MVs can differ from l0/l1 */
44
45     /* 8x8 */
46     int       i_cost8x8;
47     /* [ref][0] is 16x16 mv, [ref][1..4] are 8x8 mv from partition [0..3] */
48     ALIGNED_4( int16_t mvc[32][5][2] );
49     x264_me_t me8x8[4];
50
51     /* Sub 4x4 */
52     int       i_cost4x4[4]; /* cost per 8x8 partition */
53     x264_me_t me4x4[4][4];
54
55     /* Sub 8x4 */
56     int       i_cost8x4[4]; /* cost per 8x8 partition */
57     x264_me_t me8x4[4][2];
58
59     /* Sub 4x8 */
60     int       i_cost4x8[4]; /* cost per 8x8 partition */
61     x264_me_t me4x8[4][2];
62
63     /* 16x8 */
64     int       i_cost16x8;
65     x264_me_t me16x8[2];
66
67     /* 8x16 */
68     int       i_cost8x16;
69     x264_me_t me8x16[2];
70
71 } x264_mb_analysis_list_t;
72
73 typedef struct
74 {
75     /* conduct the analysis using this lamda and QP */
76     int i_lambda;
77     int i_lambda2;
78     int i_qp;
79     uint16_t *p_cost_mv;
80     uint16_t *p_cost_ref[2];
81     int i_mbrd;
82
83
84     /* I: Intra part */
85     /* Take some shortcuts in intra search if intra is deemed unlikely */
86     int b_fast_intra;
87     int b_force_intra; /* For Periodic Intra Refresh.  Only supported in P-frames. */
88     int b_try_pskip;
89
90     /* Luma part */
91     int i_satd_i16x16;
92     int i_satd_i16x16_dir[7];
93     int i_predict16x16;
94
95     int i_satd_i8x8;
96     int i_cbp_i8x8_luma;
97     int i_satd_i8x8_dir[12][4];
98     int i_predict8x8[4];
99
100     int i_satd_i4x4;
101     int i_predict4x4[16];
102
103     int i_satd_pcm;
104
105     /* Chroma part */
106     int i_satd_i8x8chroma;
107     int i_satd_i8x8chroma_dir[7];
108     int i_predict8x8chroma;
109
110     /* II: Inter part P/B frame */
111     x264_mb_analysis_list_t l0;
112     x264_mb_analysis_list_t l1;
113
114     int i_cost16x16bi; /* used the same ref and mv as l0 and l1 (at least for now) */
115     int i_cost16x16direct;
116     int i_cost8x8bi;
117     int i_cost8x8direct[4];
118     int i_cost16x8bi;
119     int i_cost8x16bi;
120     int i_rd16x16bi;
121     int i_rd16x16direct;
122     int i_rd16x8bi;
123     int i_rd8x16bi;
124     int i_rd8x8bi;
125
126     int i_mb_partition16x8[2]; /* mb_partition_e */
127     int i_mb_partition8x16[2];
128     int i_mb_type16x8; /* mb_class_e */
129     int i_mb_type8x16;
130
131     int b_direct_available;
132
133 } x264_mb_analysis_t;
134
135 /* lambda = pow(2,qp/6-2) */
136 const uint8_t x264_lambda_tab[52] = {
137    1, 1, 1, 1, 1, 1, 1, 1,  /*  0-7 */
138    1, 1, 1, 1,              /*  8-11 */
139    1, 1, 1, 1, 2, 2, 2, 2,  /* 12-19 */
140    3, 3, 3, 4, 4, 4, 5, 6,  /* 20-27 */
141    6, 7, 8, 9,10,11,13,14,  /* 28-35 */
142   16,18,20,23,25,29,32,36,  /* 36-43 */
143   40,45,51,57,64,72,81,91   /* 44-51 */
144 };
145
146 /* lambda2 = pow(lambda,2) * .9 * 256 */
147 const int x264_lambda2_tab[52] = {
148     14,      18,      22,      28,     36,     45,     57,     72, /*  0 -  7 */
149     91,     115,     145,     182,    230,    290,    365,    460, /*  8 - 15 */
150    580,     731,     921,    1161,   1462,   1843,   2322,   2925, /* 16 - 23 */
151   3686,    4644,    5851,    7372,   9289,  11703,  14745,  18578, /* 24 - 31 */
152  23407,   29491,   37156,   46814,  58982,  74313,  93628, 117964, /* 32 - 39 */
153 148626,  187257,  235929,  297252, 374514, 471859, 594505, 749029, /* 40 - 47 */
154 943718, 1189010, 1498059, 1887436                                  /* 48 - 51 */
155 };
156
157 const uint8_t x264_exp2_lut[64] = {
158       0,   3,   6,   8,  11,  14,  17,  20,  23,  26,  29,  32,  36,  39,  42,  45,
159      48,  52,  55,  58,  62,  65,  69,  72,  76,  80,  83,  87,  91,  94,  98, 102,
160     106, 110, 114, 118, 122, 126, 130, 135, 139, 143, 147, 152, 156, 161, 165, 170,
161     175, 179, 184, 189, 194, 198, 203, 208, 214, 219, 224, 229, 234, 240, 245, 250
162 };
163
164 const float x264_log2_lut[128] = {
165     0.00000, 0.01123, 0.02237, 0.03342, 0.04439, 0.05528, 0.06609, 0.07682,
166     0.08746, 0.09803, 0.10852, 0.11894, 0.12928, 0.13955, 0.14975, 0.15987,
167     0.16993, 0.17991, 0.18982, 0.19967, 0.20945, 0.21917, 0.22882, 0.23840,
168     0.24793, 0.25739, 0.26679, 0.27612, 0.28540, 0.29462, 0.30378, 0.31288,
169     0.32193, 0.33092, 0.33985, 0.34873, 0.35755, 0.36632, 0.37504, 0.38370,
170     0.39232, 0.40088, 0.40939, 0.41785, 0.42626, 0.43463, 0.44294, 0.45121,
171     0.45943, 0.46761, 0.47573, 0.48382, 0.49185, 0.49985, 0.50779, 0.51570,
172     0.52356, 0.53138, 0.53916, 0.54689, 0.55459, 0.56224, 0.56986, 0.57743,
173     0.58496, 0.59246, 0.59991, 0.60733, 0.61471, 0.62205, 0.62936, 0.63662,
174     0.64386, 0.65105, 0.65821, 0.66534, 0.67243, 0.67948, 0.68650, 0.69349,
175     0.70044, 0.70736, 0.71425, 0.72110, 0.72792, 0.73471, 0.74147, 0.74819,
176     0.75489, 0.76155, 0.76818, 0.77479, 0.78136, 0.78790, 0.79442, 0.80090,
177     0.80735, 0.81378, 0.82018, 0.82655, 0.83289, 0.83920, 0.84549, 0.85175,
178     0.85798, 0.86419, 0.87036, 0.87652, 0.88264, 0.88874, 0.89482, 0.90087,
179     0.90689, 0.91289, 0.91886, 0.92481, 0.93074, 0.93664, 0.94251, 0.94837,
180     0.95420, 0.96000, 0.96578, 0.97154, 0.97728, 0.98299, 0.98868, 0.99435,
181 };
182
183 /* Avoid an int/float conversion. */
184 const float x264_log2_lz_lut[32] = {
185     31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0
186 };
187
188 // should the intra and inter lambdas be different?
189 // I'm just matching the behaviour of deadzone quant.
190 static const int x264_trellis_lambda2_tab[2][52] = {
191     // inter lambda = .85 * .85 * 2**(qp/3. + 10 - LAMBDA_BITS)
192     {    46,      58,      73,      92,     117,     147,
193         185,     233,     294,     370,     466,     587,
194         740,     932,    1174,    1480,    1864,    2349,
195        2959,    3728,    4697,    5918,    7457,    9395,
196       11837,   14914,   18790,   23674,   29828,   37581,
197       47349,   59656,   75163,   94699,  119313,  150326,
198      189399,  238627,  300652,  378798,  477255,  601304,
199      757596,  954511, 1202608, 1515192, 1909022, 2405217,
200     3030384, 3818045, 4810435, 6060769 },
201     // intra lambda = .65 * .65 * 2**(qp/3. + 10 - LAMBDA_BITS)
202     {    27,      34,      43,      54,      68,      86,
203         108,     136,     172,     216,     273,     343,
204         433,     545,     687,     865,    1090,    1374,
205        1731,    2180,    2747,    3461,    4361,    5494,
206        6922,    8721,   10988,   13844,   17442,   21976,
207       27688,   34885,   43953,   55377,   69771,   87906,
208      110755,  139543,  175813,  221511,  279087,  351627,
209      443023,  558174,  703255,  886046, 1116348, 1406511,
210     1772093, 2232697, 2813022, 3544186 }
211 };
212
213 static const uint16_t x264_chroma_lambda2_offset_tab[] = {
214        16,    20,    25,    32,    40,    50,
215        64,    80,   101,   128,   161,   203,
216       256,   322,   406,   512,   645,   812,
217      1024,  1290,  1625,  2048,  2580,  3250,
218      4096,  5160,  6501,  8192, 10321, 13003,
219     16384, 20642, 26007, 32768, 41285, 52015,
220     65535
221 };
222
223 /* TODO: calculate CABAC costs */
224 static const uint8_t i_mb_b_cost_table[X264_MBTYPE_MAX] = {
225     9, 9, 9, 9, 0, 0, 0, 1, 3, 7, 7, 7, 3, 7, 7, 7, 5, 9, 0
226 };
227 static const uint8_t i_mb_b16x8_cost_table[17] = {
228     0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 7, 7, 5, 7, 9, 9, 9
229 };
230 static const uint8_t i_sub_mb_b_cost_table[13] = {
231     7, 5, 5, 3, 7, 5, 7, 3, 7, 7, 7, 5, 1
232 };
233 static const uint8_t i_sub_mb_p_cost_table[4] = {
234     5, 3, 3, 1
235 };
236
237 static void x264_analyse_update_cache( x264_t *h, x264_mb_analysis_t *a );
238
239 static uint16_t x264_cost_ref[92][3][33];
240 static UNUSED x264_pthread_mutex_t cost_ref_mutex = X264_PTHREAD_MUTEX_INITIALIZER;
241
242 int x264_analyse_init_costs( x264_t *h, int qp )
243 {
244     int i, j;
245     int lambda = x264_lambda_tab[qp];
246     if( h->cost_mv[lambda] )
247         return 0;
248     /* factor of 4 from qpel, 2 from sign, and 2 because mv can be opposite from mvp */
249     CHECKED_MALLOC( h->cost_mv[lambda], (4*4*2048 + 1) * sizeof(uint16_t) );
250     h->cost_mv[lambda] += 2*4*2048;
251     for( i = 0; i <= 2*4*2048; i++ )
252     {
253         h->cost_mv[lambda][-i] =
254         h->cost_mv[lambda][i]  = lambda * (log2f(i+1)*2 + 0.718f + !!i) + .5f;
255     }
256     x264_pthread_mutex_lock( &cost_ref_mutex );
257     for( i = 0; i < 3; i++ )
258         for( j = 0; j < 33; j++ )
259             x264_cost_ref[lambda][i][j] = i ? lambda * bs_size_te( i, j ) : 0;
260     x264_pthread_mutex_unlock( &cost_ref_mutex );
261     if( h->param.analyse.i_me_method >= X264_ME_ESA && !h->cost_mv_fpel[lambda][0] )
262     {
263         for( j=0; j<4; j++ )
264         {
265             CHECKED_MALLOC( h->cost_mv_fpel[lambda][j], (4*2048 + 1) * sizeof(uint16_t) );
266             h->cost_mv_fpel[lambda][j] += 2*2048;
267             for( i = -2*2048; i < 2*2048; i++ )
268                 h->cost_mv_fpel[lambda][j][i] = h->cost_mv[lambda][i*4+j];
269         }
270     }
271     return 0;
272 fail:
273     return -1;
274 }
275
276 void x264_analyse_free_costs( x264_t *h )
277 {
278     int i, j;
279     for( i = 0; i < 92; i++ )
280     {
281         if( h->cost_mv[i] )
282             x264_free( h->cost_mv[i] - 2*4*2048 );
283         if( h->cost_mv_fpel[i][0] )
284             for( j = 0; j < 4; j++ )
285                 x264_free( h->cost_mv_fpel[i][j] - 2*2048 );
286     }
287 }
288
289 void x264_analyse_weight_frame( x264_t *h, int end )
290 {
291     int j;
292     for( j=0; j<h->i_ref0; j++ )
293     {
294         if( h->sh.weight[j][0].weightfn )
295         {
296             x264_frame_t *frame = h->fref0[j];
297             int width = frame->i_width[0] + 2*PADH;
298             int i_padv = PADV << h->param.b_interlaced;
299             int offset, height;
300             uint8_t *src = frame->filtered[0] - frame->i_stride[0]*i_padv - PADH;
301             int k;
302             height = X264_MIN( 16 + end + i_padv, h->fref0[j]->i_lines[0] + i_padv*2 ) - h->fenc->i_lines_weighted;
303             offset = h->fenc->i_lines_weighted*frame->i_stride[0];
304             h->fenc->i_lines_weighted += height;
305             if( height )
306             {
307                 for( k = j; k < h->i_ref0; k++ )
308                     if( h->sh.weight[k][0].weightfn )
309                     {
310                         uint8_t *dst = h->fenc->weighted[k] - h->fenc->i_stride[0]*i_padv - PADH;
311                         x264_weight_scale_plane( h, dst + offset, frame->i_stride[0],
312                                                  src + offset, frame->i_stride[0],
313                                                  width, height, &h->sh.weight[k][0] );
314                     }
315             }
316             break;
317         }
318     }
319 }
320
321 /* initialize an array of lambda*nbits for all possible mvs */
322 static void x264_mb_analyse_load_costs( x264_t *h, x264_mb_analysis_t *a )
323 {
324     a->p_cost_mv = h->cost_mv[a->i_lambda];
325     a->p_cost_ref[0] = x264_cost_ref[a->i_lambda][x264_clip3(h->sh.i_num_ref_idx_l0_active-1,0,2)];
326     a->p_cost_ref[1] = x264_cost_ref[a->i_lambda][x264_clip3(h->sh.i_num_ref_idx_l1_active-1,0,2)];
327 }
328
329 static void x264_mb_analyse_init_qp( x264_t *h, x264_mb_analysis_t *a, int i_qp )
330 {
331     /* conduct the analysis using this lamda and QP */
332     a->i_qp = h->mb.i_qp = i_qp;
333     h->mb.i_chroma_qp = h->chroma_qp_table[i_qp];
334
335     a->i_lambda = x264_lambda_tab[i_qp];
336     a->i_lambda2 = x264_lambda2_tab[i_qp];
337
338     h->mb.b_trellis = h->param.analyse.i_trellis > 1 && a->i_mbrd;
339     if( h->param.analyse.i_trellis )
340     {
341         h->mb.i_trellis_lambda2[0][0] = x264_trellis_lambda2_tab[0][h->mb.i_qp];
342         h->mb.i_trellis_lambda2[0][1] = x264_trellis_lambda2_tab[1][h->mb.i_qp];
343         h->mb.i_trellis_lambda2[1][0] = x264_trellis_lambda2_tab[0][h->mb.i_chroma_qp];
344         h->mb.i_trellis_lambda2[1][1] = x264_trellis_lambda2_tab[1][h->mb.i_chroma_qp];
345     }
346     h->mb.i_psy_rd_lambda = a->i_lambda;
347     /* Adjusting chroma lambda based on QP offset hurts PSNR but improves visual quality. */
348     h->mb.i_chroma_lambda2_offset = h->param.analyse.b_psy ? x264_chroma_lambda2_offset_tab[h->mb.i_qp-h->mb.i_chroma_qp+12] : 256;
349
350 }
351
352 static void x264_mb_analyse_init( x264_t *h, x264_mb_analysis_t *a, int i_qp )
353 {
354     int i = h->param.analyse.i_subpel_refine - (h->sh.i_type == SLICE_TYPE_B);
355
356     /* mbrd == 1 -> RD mode decision */
357     /* mbrd == 2 -> RD refinement */
358     /* mbrd == 3 -> QPRD */
359     a->i_mbrd = (i>=6) + (i>=8) + (h->param.analyse.i_subpel_refine>=10);
360
361     x264_mb_analyse_init_qp( h, a, i_qp );
362
363     h->mb.i_me_method = h->param.analyse.i_me_method;
364     h->mb.i_subpel_refine = h->param.analyse.i_subpel_refine;
365     h->mb.b_chroma_me = h->param.analyse.b_chroma_me && h->sh.i_type == SLICE_TYPE_P
366                         && h->mb.i_subpel_refine >= 5;
367     h->mb.b_dct_decimate = h->sh.i_type == SLICE_TYPE_B ||
368                           (h->param.analyse.b_dct_decimate && h->sh.i_type != SLICE_TYPE_I);
369
370     h->mb.b_transform_8x8 = 0;
371     h->mb.b_noise_reduction = 0;
372
373     /* I: Intra part */
374     a->i_satd_i16x16 =
375     a->i_satd_i8x8   =
376     a->i_satd_i4x4   =
377     a->i_satd_i8x8chroma = COST_MAX;
378
379     /* non-RD PCM decision is inaccurate (as is psy-rd), so don't do it */
380     a->i_satd_pcm = !h->mb.i_psy_rd && a->i_mbrd ? ((uint64_t)X264_PCM_COST*a->i_lambda2 + 128) >> 8 : COST_MAX;
381
382     a->b_fast_intra = 0;
383     h->mb.i_skip_intra =
384         h->mb.b_lossless ? 0 :
385         a->i_mbrd ? 2 :
386         !h->param.analyse.i_trellis && !h->param.analyse.i_noise_reduction;
387
388     /* II: Inter part P/B frame */
389     if( h->sh.i_type != SLICE_TYPE_I )
390     {
391         int i, j;
392         int i_fmv_range = 4 * h->param.analyse.i_mv_range;
393         // limit motion search to a slightly smaller range than the theoretical limit,
394         // since the search may go a few iterations past its given range
395         int i_fpel_border = 6; // umh: 1 for diamond, 2 for octagon, 2 for hpel
396
397         /* Calculate max allowed MV range */
398 #define CLIP_FMV(mv) x264_clip3( mv, -i_fmv_range, i_fmv_range-1 )
399         h->mb.mv_min[0] = 4*( -16*h->mb.i_mb_x - 24 );
400         h->mb.mv_max[0] = 4*( 16*( h->sps->i_mb_width - h->mb.i_mb_x - 1 ) + 24 );
401         h->mb.mv_min_spel[0] = CLIP_FMV( h->mb.mv_min[0] );
402         h->mb.mv_max_spel[0] = CLIP_FMV( h->mb.mv_max[0] );
403         if( h->param.b_intra_refresh && h->sh.i_type == SLICE_TYPE_P )
404         {
405             int max_x = (h->fref0[0]->i_pir_end_col * 16 - 3)*4; /* 3 pixels of hpel border */
406             int max_mv = max_x - 4*16*h->mb.i_mb_x;
407             /* If we're left of the refresh bar, don't reference right of it. */
408             if( max_mv > 0 && h->mb.i_mb_x < h->fdec->i_pir_start_col )
409                 h->mb.mv_max_spel[0] = X264_MIN( h->mb.mv_max_spel[0], max_mv );
410         }
411         h->mb.mv_min_fpel[0] = (h->mb.mv_min_spel[0]>>2) + i_fpel_border;
412         h->mb.mv_max_fpel[0] = (h->mb.mv_max_spel[0]>>2) - i_fpel_border;
413         if( h->mb.i_mb_x == 0 )
414         {
415             int mb_y = h->mb.i_mb_y >> h->sh.b_mbaff;
416             int mb_height = h->sps->i_mb_height >> h->sh.b_mbaff;
417             int thread_mvy_range = i_fmv_range;
418
419             if( h->i_thread_frames > 1 )
420             {
421                 int pix_y = (h->mb.i_mb_y | h->mb.b_interlaced) * 16;
422                 int thresh = pix_y + h->param.analyse.i_mv_range_thread;
423                 for( i = (h->sh.i_type == SLICE_TYPE_B); i >= 0; i-- )
424                 {
425                     x264_frame_t **fref = i ? h->fref1 : h->fref0;
426                     int i_ref = i ? h->i_ref1 : h->i_ref0;
427                     for( j=0; j<i_ref; j++ )
428                     {
429                         x264_frame_cond_wait( fref[j]->orig, thresh );
430                         thread_mvy_range = X264_MIN( thread_mvy_range, fref[j]->orig->i_lines_completed - pix_y );
431                     }
432                 }
433
434                 if( h->param.b_deterministic )
435                     thread_mvy_range = h->param.analyse.i_mv_range_thread;
436                 if( h->mb.b_interlaced )
437                     thread_mvy_range >>= 1;
438
439                 x264_analyse_weight_frame( h, pix_y + thread_mvy_range );
440             }
441
442             h->mb.mv_min[1] = 4*( -16*mb_y - 24 );
443             h->mb.mv_max[1] = 4*( 16*( mb_height - mb_y - 1 ) + 24 );
444             h->mb.mv_min_spel[1] = x264_clip3( h->mb.mv_min[1], -i_fmv_range, i_fmv_range );
445             h->mb.mv_max_spel[1] = CLIP_FMV( h->mb.mv_max[1] );
446             h->mb.mv_max_spel[1] = X264_MIN( h->mb.mv_max_spel[1], thread_mvy_range*4 );
447             h->mb.mv_min_fpel[1] = (h->mb.mv_min_spel[1]>>2) + i_fpel_border;
448             h->mb.mv_max_fpel[1] = (h->mb.mv_max_spel[1]>>2) - i_fpel_border;
449         }
450 #undef CLIP_FMV
451
452         a->l0.me16x16.cost =
453         a->l0.i_rd16x16    =
454         a->l0.i_cost8x8    = COST_MAX;
455
456         for( i = 0; i < 4; i++ )
457         {
458             a->l0.i_cost4x4[i] =
459             a->l0.i_cost8x4[i] =
460             a->l0.i_cost4x8[i] = COST_MAX;
461         }
462
463         a->l0.i_cost16x8   =
464         a->l0.i_cost8x16   = COST_MAX;
465         if( h->sh.i_type == SLICE_TYPE_B )
466         {
467             a->l1.me16x16.cost =
468             a->l1.i_rd16x16    =
469             a->l1.i_cost8x8    = COST_MAX;
470
471             for( i = 0; i < 4; i++ )
472             {
473                 a->l1.i_cost4x4[i] =
474                 a->l1.i_cost8x4[i] =
475                 a->l1.i_cost4x8[i] =
476                 a->i_cost8x8direct[i] = COST_MAX;
477             }
478
479             a->l1.i_cost16x8   =
480             a->l1.i_cost8x16   =
481             a->i_rd16x16bi     =
482             a->i_rd16x16direct =
483             a->i_rd8x8bi       =
484             a->i_rd16x8bi      =
485             a->i_rd8x16bi      =
486             a->i_cost16x16bi   =
487             a->i_cost16x16direct =
488             a->i_cost8x8bi     =
489             a->i_cost16x8bi    =
490             a->i_cost8x16bi    = COST_MAX;
491         }
492
493         /* Fast intra decision */
494         if( h->mb.i_mb_xy - h->sh.i_first_mb > 4 )
495         {
496             if(   IS_INTRA( h->mb.i_mb_type_left )
497                || IS_INTRA( h->mb.i_mb_type_top )
498                || IS_INTRA( h->mb.i_mb_type_topleft )
499                || IS_INTRA( h->mb.i_mb_type_topright )
500                || (h->sh.i_type == SLICE_TYPE_P && IS_INTRA( h->fref0[0]->mb_type[h->mb.i_mb_xy] ))
501                || (h->mb.i_mb_xy - h->sh.i_first_mb < 3*(h->stat.frame.i_mb_count[I_4x4] + h->stat.frame.i_mb_count[I_8x8] + h->stat.frame.i_mb_count[I_16x16])) )
502             { /* intra is likely */ }
503             else
504             {
505                 a->b_fast_intra = 1;
506             }
507         }
508         h->mb.b_skip_mc = 0;
509         if( h->param.b_intra_refresh && h->sh.i_type == SLICE_TYPE_P &&
510             h->mb.i_mb_x >= h->fdec->i_pir_start_col && h->mb.i_mb_x <= h->fdec->i_pir_end_col )
511         {
512             a->b_force_intra = 1;
513             a->b_fast_intra = 0;
514         }
515         else
516             a->b_force_intra = 0;
517     }
518 }
519
520 /* Prediction modes allowed for various combinations of neighbors. */
521 /* Terminated by a -1. */
522 /* In order, no neighbors, left, top, top/left, top/left/topleft */
523 static const int8_t i16x16_mode_available[5][5] =
524 {
525     {I_PRED_16x16_DC_128, -1, -1, -1, -1},
526     {I_PRED_16x16_DC_LEFT, I_PRED_16x16_H, -1, -1, -1},
527     {I_PRED_16x16_DC_TOP, I_PRED_16x16_V, -1, -1, -1},
528     {I_PRED_16x16_V, I_PRED_16x16_H, I_PRED_16x16_DC, -1, -1},
529     {I_PRED_16x16_V, I_PRED_16x16_H, I_PRED_16x16_DC, I_PRED_16x16_P, -1},
530 };
531
532 static const int8_t i8x8chroma_mode_available[5][5] =
533 {
534     {I_PRED_CHROMA_DC_128, -1, -1, -1, -1},
535     {I_PRED_CHROMA_DC_LEFT, I_PRED_CHROMA_H, -1, -1, -1},
536     {I_PRED_CHROMA_DC_TOP, I_PRED_CHROMA_V, -1, -1, -1},
537     {I_PRED_CHROMA_V, I_PRED_CHROMA_H, I_PRED_CHROMA_DC, -1, -1},
538     {I_PRED_CHROMA_V, I_PRED_CHROMA_H, I_PRED_CHROMA_DC, I_PRED_CHROMA_P, -1},
539 };
540
541 static const int8_t i4x4_mode_available[5][10] =
542 {
543     {I_PRED_4x4_DC_128, -1, -1, -1, -1, -1, -1, -1, -1, -1},
544     {I_PRED_4x4_DC_LEFT, I_PRED_4x4_H, I_PRED_4x4_HU, -1, -1, -1, -1, -1, -1, -1},
545     {I_PRED_4x4_DC_TOP, I_PRED_4x4_V, I_PRED_4x4_DDL, I_PRED_4x4_VL, -1, -1, -1, -1, -1, -1},
546     {I_PRED_4x4_DC, I_PRED_4x4_H, I_PRED_4x4_V, I_PRED_4x4_DDL, I_PRED_4x4_VL, I_PRED_4x4_HU, -1, -1, -1, -1},
547     {I_PRED_4x4_DC, I_PRED_4x4_H, I_PRED_4x4_V, I_PRED_4x4_DDL, I_PRED_4x4_DDR, I_PRED_4x4_VR, I_PRED_4x4_HD, I_PRED_4x4_VL, I_PRED_4x4_HU, -1},
548 };
549
550 static inline const int8_t *predict_16x16_mode_available( int i_neighbour )
551 {
552     int idx = i_neighbour & (MB_TOP|MB_LEFT|MB_TOPLEFT);
553     return i16x16_mode_available[(idx&MB_TOPLEFT)?4:idx];
554 }
555
556 static inline const int8_t *predict_8x8chroma_mode_available( int i_neighbour )
557 {
558     int idx = i_neighbour & (MB_TOP|MB_LEFT|MB_TOPLEFT);
559     return i8x8chroma_mode_available[(idx&MB_TOPLEFT)?4:idx];
560 }
561
562 static inline const int8_t *predict_4x4_mode_available( int i_neighbour )
563 {
564     int idx = i_neighbour & (MB_TOP|MB_LEFT|MB_TOPLEFT);
565     return i4x4_mode_available[(idx&MB_TOPLEFT)?4:idx];
566 }
567
568 /* For trellis=2, we need to do this for both sizes of DCT, for trellis=1 we only need to use it on the chosen mode. */
569 static void inline x264_psy_trellis_init( x264_t *h, int do_both_dct )
570 {
571     ALIGNED_16( static uint8_t zero[16*FDEC_STRIDE] ) = {0};
572
573     if( do_both_dct || h->mb.b_transform_8x8 )
574         h->dctf.sub16x16_dct8( h->mb.pic.fenc_dct8, h->mb.pic.p_fenc[0], zero );
575     if( do_both_dct || !h->mb.b_transform_8x8 )
576         h->dctf.sub16x16_dct( h->mb.pic.fenc_dct4, h->mb.pic.p_fenc[0], zero );
577 }
578
579 /* Pre-calculate fenc satd scores for psy RD, minus DC coefficients */
580 static inline void x264_mb_cache_fenc_satd( x264_t *h )
581 {
582     ALIGNED_16( static uint8_t zero[16] ) = {0};
583     uint8_t *fenc;
584     int x, y, satd_sum = 0, sa8d_sum = 0;
585     if( h->param.analyse.i_trellis == 2 && h->mb.i_psy_trellis )
586         x264_psy_trellis_init( h, h->param.analyse.b_transform_8x8 );
587     if( !h->mb.i_psy_rd )
588         return;
589     for( y = 0; y < 4; y++ )
590         for( x = 0; x < 4; x++ )
591         {
592             fenc = h->mb.pic.p_fenc[0]+x*4+y*4*FENC_STRIDE;
593             h->mb.pic.fenc_satd[y][x] = h->pixf.satd[PIXEL_4x4]( zero, 0, fenc, FENC_STRIDE )
594                                       - (h->pixf.sad[PIXEL_4x4]( zero, 0, fenc, FENC_STRIDE )>>1);
595             satd_sum += h->mb.pic.fenc_satd[y][x];
596         }
597     for( y = 0; y < 2; y++ )
598         for( x = 0; x < 2; x++ )
599         {
600             fenc = h->mb.pic.p_fenc[0]+x*8+y*8*FENC_STRIDE;
601             h->mb.pic.fenc_sa8d[y][x] = h->pixf.sa8d[PIXEL_8x8]( zero, 0, fenc, FENC_STRIDE )
602                                       - (h->pixf.sad[PIXEL_8x8]( zero, 0, fenc, FENC_STRIDE )>>2);
603             sa8d_sum += h->mb.pic.fenc_sa8d[y][x];
604         }
605     h->mb.pic.fenc_satd_sum = satd_sum;
606     h->mb.pic.fenc_sa8d_sum = sa8d_sum;
607 }
608
609 static void x264_mb_analyse_intra_chroma( x264_t *h, x264_mb_analysis_t *a )
610 {
611     int b_merged_satd = !!h->pixf.intra_mbcmp_x3_8x8c && !h->mb.b_lossless;
612
613     if( a->i_satd_i8x8chroma < COST_MAX )
614         return;
615
616     const int8_t *predict_mode = predict_8x8chroma_mode_available( h->mb.i_neighbour_intra );
617
618     /* 8x8 prediction selection for chroma */
619     if( predict_mode[3] >= 0 && b_merged_satd )
620     {
621         int satdu[4], satdv[4];
622         h->pixf.intra_mbcmp_x3_8x8c( h->mb.pic.p_fenc[1], h->mb.pic.p_fdec[1], satdu );
623         h->pixf.intra_mbcmp_x3_8x8c( h->mb.pic.p_fenc[2], h->mb.pic.p_fdec[2], satdv );
624         h->predict_8x8c[I_PRED_CHROMA_P]( h->mb.pic.p_fdec[1] );
625         h->predict_8x8c[I_PRED_CHROMA_P]( h->mb.pic.p_fdec[2] );
626         satdu[I_PRED_CHROMA_P] = h->pixf.mbcmp[PIXEL_8x8]( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc[1], FENC_STRIDE );
627         satdv[I_PRED_CHROMA_P] = h->pixf.mbcmp[PIXEL_8x8]( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc[2], FENC_STRIDE );
628
629         for( ; *predict_mode >= 0; predict_mode++ )
630         {
631             int i_mode = *predict_mode;
632             int i_satd = satdu[i_mode] + satdv[i_mode] + a->i_lambda * bs_size_ue( i_mode );
633
634             a->i_satd_i8x8chroma_dir[i_mode] = i_satd;
635             COPY2_IF_LT( a->i_satd_i8x8chroma, i_satd, a->i_predict8x8chroma, i_mode );
636         }
637     }
638     else
639     {
640         for( ; *predict_mode >= 0; predict_mode++ )
641         {
642             int i_satd;
643             int i_mode = *predict_mode;
644
645             /* we do the prediction */
646             if( h->mb.b_lossless )
647                 x264_predict_lossless_8x8_chroma( h, i_mode );
648             else
649             {
650                 h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1] );
651                 h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2] );
652             }
653
654             /* we calculate the cost */
655             i_satd = h->pixf.mbcmp[PIXEL_8x8]( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc[1], FENC_STRIDE ) +
656                      h->pixf.mbcmp[PIXEL_8x8]( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc[2], FENC_STRIDE ) +
657                      a->i_lambda * bs_size_ue( x264_mb_pred_mode8x8c_fix[i_mode] );
658
659             a->i_satd_i8x8chroma_dir[i_mode] = i_satd;
660             COPY2_IF_LT( a->i_satd_i8x8chroma, i_satd, a->i_predict8x8chroma, i_mode );
661         }
662     }
663
664     h->mb.i_chroma_pred_mode = a->i_predict8x8chroma;
665 }
666
667 static void x264_mb_analyse_intra( x264_t *h, x264_mb_analysis_t *a, int i_satd_inter )
668 {
669     const unsigned int flags = h->sh.i_type == SLICE_TYPE_I ? h->param.analyse.intra : h->param.analyse.inter;
670     uint8_t  *p_src = h->mb.pic.p_fenc[0];
671     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
672
673     int i, idx;
674     int b_merged_satd = !!h->pixf.intra_mbcmp_x3_16x16 && !h->mb.b_lossless;
675
676     /*---------------- Try all mode and calculate their score ---------------*/
677
678     /* 16x16 prediction selection */
679     const int8_t *predict_mode = predict_16x16_mode_available( h->mb.i_neighbour_intra );
680
681     if( b_merged_satd && predict_mode[3] >= 0 )
682     {
683         h->pixf.intra_mbcmp_x3_16x16( p_src, p_dst, a->i_satd_i16x16_dir );
684         h->predict_16x16[I_PRED_16x16_P]( p_dst );
685         a->i_satd_i16x16_dir[I_PRED_16x16_P] =
686             h->pixf.mbcmp[PIXEL_16x16]( p_dst, FDEC_STRIDE, p_src, FENC_STRIDE );
687         for( i=0; i<4; i++ )
688         {
689             int cost = a->i_satd_i16x16_dir[i] += a->i_lambda * bs_size_ue(i);
690             COPY2_IF_LT( a->i_satd_i16x16, cost, a->i_predict16x16, i );
691         }
692     }
693     else
694     {
695         for( ; *predict_mode >= 0; predict_mode++ )
696         {
697             int i_satd;
698             int i_mode = *predict_mode;
699
700             if( h->mb.b_lossless )
701                 x264_predict_lossless_16x16( h, i_mode );
702             else
703                 h->predict_16x16[i_mode]( p_dst );
704
705             i_satd = h->pixf.mbcmp[PIXEL_16x16]( p_dst, FDEC_STRIDE, p_src, FENC_STRIDE ) +
706                     a->i_lambda * bs_size_ue( x264_mb_pred_mode16x16_fix[i_mode] );
707             COPY2_IF_LT( a->i_satd_i16x16, i_satd, a->i_predict16x16, i_mode );
708             a->i_satd_i16x16_dir[i_mode] = i_satd;
709         }
710     }
711
712     if( h->sh.i_type == SLICE_TYPE_B )
713         /* cavlc mb type prefix */
714         a->i_satd_i16x16 += a->i_lambda * i_mb_b_cost_table[I_16x16];
715     if( a->b_fast_intra && a->i_satd_i16x16 > 2*i_satd_inter )
716         return;
717
718     /* 8x8 prediction selection */
719     if( flags & X264_ANALYSE_I8x8 )
720     {
721         ALIGNED_ARRAY_16( uint8_t, edge,[33] );
722         x264_pixel_cmp_t sa8d = (h->pixf.mbcmp[0] == h->pixf.satd[0]) ? h->pixf.sa8d[PIXEL_8x8] : h->pixf.mbcmp[PIXEL_8x8];
723         int i_satd_thresh = a->i_mbrd ? COST_MAX : X264_MIN( i_satd_inter, a->i_satd_i16x16 );
724         int i_cost = 0;
725         h->mb.i_cbp_luma = 0;
726         b_merged_satd = h->pixf.intra_mbcmp_x3_8x8 && !h->mb.b_lossless;
727
728         // FIXME some bias like in i4x4?
729         if( h->sh.i_type == SLICE_TYPE_B )
730             i_cost += a->i_lambda * i_mb_b_cost_table[I_8x8];
731
732         for( idx = 0;; idx++ )
733         {
734             int x = idx&1;
735             int y = idx>>1;
736             uint8_t *p_src_by = p_src + 8*x + 8*y*FENC_STRIDE;
737             uint8_t *p_dst_by = p_dst + 8*x + 8*y*FDEC_STRIDE;
738             int i_best = COST_MAX;
739             int i_pred_mode = x264_mb_predict_intra4x4_mode( h, 4*idx );
740
741             predict_mode = predict_4x4_mode_available( h->mb.i_neighbour8[idx] );
742             h->predict_8x8_filter( p_dst_by, edge, h->mb.i_neighbour8[idx], ALL_NEIGHBORS );
743
744             if( b_merged_satd && predict_mode[8] >= 0 )
745             {
746                 int satd[9];
747                 h->pixf.intra_mbcmp_x3_8x8( p_src_by, edge, satd );
748                 satd[i_pred_mode] -= 3 * a->i_lambda;
749                 for( i=2; i>=0; i-- )
750                 {
751                     int cost = a->i_satd_i8x8_dir[i][idx] = satd[i] + 4 * a->i_lambda;
752                     COPY2_IF_LT( i_best, cost, a->i_predict8x8[idx], i );
753                 }
754                 predict_mode += 3;
755             }
756
757             for( ; *predict_mode >= 0; predict_mode++ )
758             {
759                 int i_satd;
760                 int i_mode = *predict_mode;
761
762                 if( h->mb.b_lossless )
763                     x264_predict_lossless_8x8( h, p_dst_by, idx, i_mode, edge );
764                 else
765                     h->predict_8x8[i_mode]( p_dst_by, edge );
766
767                 i_satd = sa8d( p_dst_by, FDEC_STRIDE, p_src_by, FENC_STRIDE ) + a->i_lambda * 4;
768                 if( i_pred_mode == x264_mb_pred_mode4x4_fix(i_mode) )
769                     i_satd -= a->i_lambda * 3;
770
771                 COPY2_IF_LT( i_best, i_satd, a->i_predict8x8[idx], i_mode );
772                 a->i_satd_i8x8_dir[i_mode][idx] = i_satd;
773             }
774             i_cost += i_best;
775
776             if( idx == 3 || i_cost > i_satd_thresh )
777                 break;
778
779             /* we need to encode this block now (for next ones) */
780             h->predict_8x8[a->i_predict8x8[idx]]( p_dst_by, edge );
781             x264_mb_encode_i8x8( h, idx, a->i_qp );
782
783             x264_macroblock_cache_intra8x8_pred( h, 2*x, 2*y, a->i_predict8x8[idx] );
784         }
785
786         if( idx == 3 )
787         {
788             a->i_satd_i8x8 = i_cost;
789             if( h->mb.i_skip_intra )
790             {
791                 h->mc.copy[PIXEL_16x16]( h->mb.pic.i8x8_fdec_buf, 16, p_dst, FDEC_STRIDE, 16 );
792                 h->mb.pic.i8x8_nnz_buf[0] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 0]] );
793                 h->mb.pic.i8x8_nnz_buf[1] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 2]] );
794                 h->mb.pic.i8x8_nnz_buf[2] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 8]] );
795                 h->mb.pic.i8x8_nnz_buf[3] = M32( &h->mb.cache.non_zero_count[x264_scan8[10]] );
796                 h->mb.pic.i8x8_cbp = h->mb.i_cbp_luma;
797                 if( h->mb.i_skip_intra == 2 )
798                     h->mc.memcpy_aligned( h->mb.pic.i8x8_dct_buf, h->dct.luma8x8, sizeof(h->mb.pic.i8x8_dct_buf) );
799             }
800         }
801         else
802         {
803             static const uint16_t cost_div_fix8[3] = {1024,512,341};
804             a->i_satd_i8x8 = COST_MAX;
805             i_cost = (i_cost * cost_div_fix8[idx]) >> 8;
806         }
807         if( X264_MIN(i_cost, a->i_satd_i16x16) > i_satd_inter*(5+!!a->i_mbrd)/4 )
808             return;
809     }
810
811     /* 4x4 prediction selection */
812     if( flags & X264_ANALYSE_I4x4 )
813     {
814         int i_cost;
815         int i_satd_thresh = X264_MIN3( i_satd_inter, a->i_satd_i16x16, a->i_satd_i8x8 );
816         h->mb.i_cbp_luma = 0;
817         b_merged_satd = h->pixf.intra_mbcmp_x3_4x4 && !h->mb.b_lossless;
818         if( a->i_mbrd )
819             i_satd_thresh = i_satd_thresh * (10-a->b_fast_intra)/8;
820
821         i_cost = a->i_lambda * 24;    /* from JVT (SATD0) */
822         if( h->sh.i_type == SLICE_TYPE_B )
823             i_cost += a->i_lambda * i_mb_b_cost_table[I_4x4];
824
825         for( idx = 0;; idx++ )
826         {
827             uint8_t *p_src_by = p_src + block_idx_xy_fenc[idx];
828             uint8_t *p_dst_by = p_dst + block_idx_xy_fdec[idx];
829             int i_best = COST_MAX;
830             int i_pred_mode = x264_mb_predict_intra4x4_mode( h, idx );
831
832             const int8_t *predict_mode = predict_4x4_mode_available( h->mb.i_neighbour4[idx] );
833
834             if( (h->mb.i_neighbour4[idx] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
835                 /* emulate missing topright samples */
836                 M32( &p_dst_by[4 - FDEC_STRIDE] ) = p_dst_by[3 - FDEC_STRIDE] * 0x01010101U;
837
838             if( b_merged_satd && predict_mode[5] >= 0 )
839             {
840                 int satd[9];
841                 h->pixf.intra_mbcmp_x3_4x4( p_src_by, p_dst_by, satd );
842                 satd[i_pred_mode] -= 3 * a->i_lambda;
843                 for( i=2; i>=0; i-- )
844                     COPY2_IF_LT( i_best, satd[i], a->i_predict4x4[idx], i );
845                 predict_mode += 3;
846             }
847
848             for( ; *predict_mode >= 0; predict_mode++ )
849             {
850                 int i_satd;
851                 int i_mode = *predict_mode;
852
853                 if( h->mb.b_lossless )
854                     x264_predict_lossless_4x4( h, p_dst_by, idx, i_mode );
855                 else
856                     h->predict_4x4[i_mode]( p_dst_by );
857
858                 i_satd = h->pixf.mbcmp[PIXEL_4x4]( p_dst_by, FDEC_STRIDE, p_src_by, FENC_STRIDE );
859                 if( i_pred_mode == x264_mb_pred_mode4x4_fix(i_mode) )
860                     i_satd -= a->i_lambda * 3;
861
862                 COPY2_IF_LT( i_best, i_satd, a->i_predict4x4[idx], i_mode );
863             }
864             i_cost += i_best + 4 * a->i_lambda;
865
866             if( i_cost > i_satd_thresh || idx == 15 )
867                 break;
868
869             /* we need to encode this block now (for next ones) */
870             h->predict_4x4[a->i_predict4x4[idx]]( p_dst_by );
871             x264_mb_encode_i4x4( h, idx, a->i_qp );
872
873             h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] = a->i_predict4x4[idx];
874         }
875         if( idx == 15 )
876         {
877             a->i_satd_i4x4 = i_cost;
878             if( h->mb.i_skip_intra )
879             {
880                 h->mc.copy[PIXEL_16x16]( h->mb.pic.i4x4_fdec_buf, 16, p_dst, FDEC_STRIDE, 16 );
881                 h->mb.pic.i4x4_nnz_buf[0] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 0]] );
882                 h->mb.pic.i4x4_nnz_buf[1] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 2]] );
883                 h->mb.pic.i4x4_nnz_buf[2] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 8]] );
884                 h->mb.pic.i4x4_nnz_buf[3] = M32( &h->mb.cache.non_zero_count[x264_scan8[10]] );
885                 h->mb.pic.i4x4_cbp = h->mb.i_cbp_luma;
886                 if( h->mb.i_skip_intra == 2 )
887                     h->mc.memcpy_aligned( h->mb.pic.i4x4_dct_buf, h->dct.luma4x4, sizeof(h->mb.pic.i4x4_dct_buf) );
888             }
889         }
890         else
891             a->i_satd_i4x4 = COST_MAX;
892     }
893 }
894
895 static void x264_intra_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd_thresh )
896 {
897     if( a->i_satd_i16x16 <= i_satd_thresh )
898     {
899         h->mb.i_type = I_16x16;
900         x264_analyse_update_cache( h, a );
901         a->i_satd_i16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
902     }
903     else
904         a->i_satd_i16x16 = COST_MAX;
905
906     if( a->i_satd_i4x4 <= i_satd_thresh && a->i_satd_i4x4 < COST_MAX )
907     {
908         h->mb.i_type = I_4x4;
909         x264_analyse_update_cache( h, a );
910         a->i_satd_i4x4 = x264_rd_cost_mb( h, a->i_lambda2 );
911     }
912     else
913         a->i_satd_i4x4 = COST_MAX;
914
915     if( a->i_satd_i8x8 <= i_satd_thresh && a->i_satd_i8x8 < COST_MAX )
916     {
917         h->mb.i_type = I_8x8;
918         x264_analyse_update_cache( h, a );
919         a->i_satd_i8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
920         a->i_cbp_i8x8_luma = h->mb.i_cbp_luma;
921     }
922     else
923         a->i_satd_i8x8 = COST_MAX;
924 }
925
926 static void x264_intra_rd_refine( x264_t *h, x264_mb_analysis_t *a )
927 {
928     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
929
930     int i, idx, x, y;
931     int i_mode, i_thresh;
932     uint64_t i_satd, i_best;
933     h->mb.i_skip_intra = 0;
934
935     if( h->mb.i_type == I_16x16 )
936     {
937         int old_pred_mode = a->i_predict16x16;
938         const int8_t *predict_mode = predict_16x16_mode_available( h->mb.i_neighbour_intra );
939         i_thresh = a->i_satd_i16x16_dir[old_pred_mode] * 9/8;
940         i_best = a->i_satd_i16x16;
941         for( ; *predict_mode >= 0; predict_mode++ )
942         {
943             int i_mode = *predict_mode;
944             if( i_mode == old_pred_mode || a->i_satd_i16x16_dir[i_mode] > i_thresh )
945                 continue;
946             h->mb.i_intra16x16_pred_mode = i_mode;
947             i_satd = x264_rd_cost_mb( h, a->i_lambda2 );
948             COPY2_IF_LT( i_best, i_satd, a->i_predict16x16, i_mode );
949         }
950     }
951
952     /* RD selection for chroma prediction */
953     const int8_t *predict_mode = predict_8x8chroma_mode_available( h->mb.i_neighbour_intra );
954     if( predict_mode[1] >= 0 )
955     {
956         int8_t predict_mode_sorted[4];
957         int i_max;
958         i_thresh = a->i_satd_i8x8chroma * 5/4;
959
960         for( i_max = 0; *predict_mode >= 0; predict_mode++ )
961         {
962             i_mode = *predict_mode;
963             if( a->i_satd_i8x8chroma_dir[i_mode] < i_thresh && i_mode != a->i_predict8x8chroma )
964                 predict_mode_sorted[i_max++] = i_mode;
965         }
966
967         if( i_max > 0 )
968         {
969             int i_cbp_chroma_best = h->mb.i_cbp_chroma;
970             int i_chroma_lambda = x264_lambda2_tab[h->mb.i_chroma_qp];
971             /* the previous thing encoded was x264_intra_rd(), so the pixels and
972              * coefs for the current chroma mode are still around, so we only
973              * have to recount the bits. */
974             i_best = x264_rd_cost_i8x8_chroma( h, i_chroma_lambda, a->i_predict8x8chroma, 0 );
975             for( i = 0; i < i_max; i++ )
976             {
977                 i_mode = predict_mode_sorted[i];
978                 if( h->mb.b_lossless )
979                     x264_predict_lossless_8x8_chroma( h, i_mode );
980                 else
981                 {
982                     h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1] );
983                     h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2] );
984                 }
985                 /* if we've already found a mode that needs no residual, then
986                  * probably any mode with a residual will be worse.
987                  * so avoid dct on the remaining modes to improve speed. */
988                 i_satd = x264_rd_cost_i8x8_chroma( h, i_chroma_lambda, i_mode, h->mb.i_cbp_chroma != 0x00 );
989                 COPY3_IF_LT( i_best, i_satd, a->i_predict8x8chroma, i_mode, i_cbp_chroma_best, h->mb.i_cbp_chroma );
990             }
991             h->mb.i_chroma_pred_mode = a->i_predict8x8chroma;
992             h->mb.i_cbp_chroma = i_cbp_chroma_best;
993         }
994     }
995
996     if( h->mb.i_type == I_4x4 )
997     {
998         uint32_t pels[4] = {0}; // doesn't need initting, just shuts up a gcc warning
999         int i_nnz = 0;
1000         for( idx = 0; idx < 16; idx++ )
1001         {
1002             uint8_t *p_dst_by = p_dst + block_idx_xy_fdec[idx];
1003             i_best = COST_MAX64;
1004
1005             const int8_t *predict_mode = predict_4x4_mode_available( h->mb.i_neighbour4[idx] );
1006
1007             if( (h->mb.i_neighbour4[idx] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
1008                 /* emulate missing topright samples */
1009                 M32( &p_dst_by[4 - FDEC_STRIDE] ) = p_dst_by[3 - FDEC_STRIDE] * 0x01010101U;
1010
1011             for( ; *predict_mode >= 0; predict_mode++ )
1012             {
1013                 i_mode = *predict_mode;
1014                 if( h->mb.b_lossless )
1015                     x264_predict_lossless_4x4( h, p_dst_by, idx, i_mode );
1016                 else
1017                     h->predict_4x4[i_mode]( p_dst_by );
1018                 i_satd = x264_rd_cost_i4x4( h, a->i_lambda2, idx, i_mode );
1019
1020                 if( i_best > i_satd )
1021                 {
1022                     a->i_predict4x4[idx] = i_mode;
1023                     i_best = i_satd;
1024                     pels[0] = M32( p_dst_by+0*FDEC_STRIDE );
1025                     pels[1] = M32( p_dst_by+1*FDEC_STRIDE );
1026                     pels[2] = M32( p_dst_by+2*FDEC_STRIDE );
1027                     pels[3] = M32( p_dst_by+3*FDEC_STRIDE );
1028                     i_nnz = h->mb.cache.non_zero_count[x264_scan8[idx]];
1029                 }
1030             }
1031
1032             M32( p_dst_by+0*FDEC_STRIDE ) = pels[0];
1033             M32( p_dst_by+1*FDEC_STRIDE ) = pels[1];
1034             M32( p_dst_by+2*FDEC_STRIDE ) = pels[2];
1035             M32( p_dst_by+3*FDEC_STRIDE ) = pels[3];
1036             h->mb.cache.non_zero_count[x264_scan8[idx]] = i_nnz;
1037
1038             h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] = a->i_predict4x4[idx];
1039         }
1040     }
1041     else if( h->mb.i_type == I_8x8 )
1042     {
1043         ALIGNED_ARRAY_16( uint8_t, edge,[33] );
1044         for( idx = 0; idx < 4; idx++ )
1045         {
1046             uint64_t pels_h = 0;
1047             uint8_t pels_v[7];
1048             uint16_t i_nnz[2] = {0}; //shut up gcc
1049             uint8_t *p_dst_by;
1050             int j;
1051             int cbp_luma_new = 0;
1052             i_thresh = a->i_satd_i8x8_dir[a->i_predict8x8[idx]][idx] * 11/8;
1053
1054             i_best = COST_MAX64;
1055             x = idx&1;
1056             y = idx>>1;
1057
1058             p_dst_by = p_dst + 8*x + 8*y*FDEC_STRIDE;
1059             const int8_t *predict_mode = predict_4x4_mode_available( h->mb.i_neighbour8[idx] );
1060             h->predict_8x8_filter( p_dst_by, edge, h->mb.i_neighbour8[idx], ALL_NEIGHBORS );
1061
1062             for( ; *predict_mode >= 0; predict_mode++ )
1063             {
1064                 i_mode = *predict_mode;
1065                 if( a->i_satd_i8x8_dir[i_mode][idx] > i_thresh )
1066                     continue;
1067
1068                 if( h->mb.b_lossless )
1069                     x264_predict_lossless_8x8( h, p_dst_by, idx, i_mode, edge );
1070                 else
1071                     h->predict_8x8[i_mode]( p_dst_by, edge );
1072                 h->mb.i_cbp_luma = a->i_cbp_i8x8_luma;
1073                 i_satd = x264_rd_cost_i8x8( h, a->i_lambda2, idx, i_mode );
1074
1075                 if( i_best > i_satd )
1076                 {
1077                     a->i_predict8x8[idx] = i_mode;
1078                     cbp_luma_new = h->mb.i_cbp_luma;
1079                     i_best = i_satd;
1080
1081                     pels_h = M64( p_dst_by+7*FDEC_STRIDE );
1082                     if( !(idx&1) )
1083                         for( j=0; j<7; j++ )
1084                             pels_v[j] = p_dst_by[7+j*FDEC_STRIDE];
1085                     i_nnz[0] = M16( &h->mb.cache.non_zero_count[x264_scan8[4*idx+0]] );
1086                     i_nnz[1] = M16( &h->mb.cache.non_zero_count[x264_scan8[4*idx+2]] );
1087                 }
1088             }
1089             a->i_cbp_i8x8_luma = cbp_luma_new;
1090             M64( p_dst_by+7*FDEC_STRIDE ) = pels_h;
1091             if( !(idx&1) )
1092                 for( j=0; j<7; j++ )
1093                     p_dst_by[7+j*FDEC_STRIDE] = pels_v[j];
1094             M16( &h->mb.cache.non_zero_count[x264_scan8[4*idx+0]] ) = i_nnz[0];
1095             M16( &h->mb.cache.non_zero_count[x264_scan8[4*idx+2]] ) = i_nnz[1];
1096
1097             x264_macroblock_cache_intra8x8_pred( h, 2*x, 2*y, a->i_predict8x8[idx] );
1098         }
1099     }
1100 }
1101
1102 #define LOAD_FENC( m, src, xoff, yoff) \
1103     (m)->p_cost_mv = a->p_cost_mv; \
1104     (m)->i_stride[0] = h->mb.pic.i_stride[0]; \
1105     (m)->i_stride[1] = h->mb.pic.i_stride[1]; \
1106     (m)->p_fenc[0] = &(src)[0][(xoff)+(yoff)*FENC_STRIDE]; \
1107     (m)->p_fenc[1] = &(src)[1][((xoff)>>1)+((yoff)>>1)*FENC_STRIDE]; \
1108     (m)->p_fenc[2] = &(src)[2][((xoff)>>1)+((yoff)>>1)*FENC_STRIDE];
1109
1110 #define LOAD_HPELS(m, src, list, ref, xoff, yoff) \
1111     (m)->p_fref_w = (m)->p_fref[0] = &(src)[0][(xoff)+(yoff)*(m)->i_stride[0]]; \
1112     (m)->p_fref[1] = &(src)[1][(xoff)+(yoff)*(m)->i_stride[0]]; \
1113     (m)->p_fref[2] = &(src)[2][(xoff)+(yoff)*(m)->i_stride[0]]; \
1114     (m)->p_fref[3] = &(src)[3][(xoff)+(yoff)*(m)->i_stride[0]]; \
1115     (m)->p_fref[4] = &(src)[4][((xoff)>>1)+((yoff)>>1)*(m)->i_stride[1]]; \
1116     (m)->p_fref[5] = &(src)[5][((xoff)>>1)+((yoff)>>1)*(m)->i_stride[1]]; \
1117     (m)->integral = &h->mb.pic.p_integral[list][ref][(xoff)+(yoff)*(m)->i_stride[0]]; \
1118     (m)->weight = weight_none; \
1119     (m)->i_ref = ref;
1120
1121 #define LOAD_WPELS(m, src, list, ref, xoff, yoff) \
1122     (m)->p_fref_w = &(src)[(xoff)+(yoff)*(m)->i_stride[0]]; \
1123     (m)->weight = h->sh.weight[i_ref];
1124
1125 #define REF_COST(list, ref) \
1126     (a->p_cost_ref[list][ref])
1127
1128 static void x264_mb_analyse_inter_p16x16( x264_t *h, x264_mb_analysis_t *a )
1129 {
1130     x264_me_t m;
1131     int i_ref, i_mvc;
1132     ALIGNED_4( int16_t mvc[8][2] );
1133     int i_halfpel_thresh = INT_MAX;
1134     int *p_halfpel_thresh = h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh : NULL;
1135
1136     /* 16x16 Search on all ref frame */
1137     m.i_pixel = PIXEL_16x16;
1138     LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 0 );
1139
1140     a->l0.me16x16.cost = INT_MAX;
1141     for( i_ref = 0; i_ref < h->mb.pic.i_fref[0]; i_ref++ )
1142     {
1143         const int i_ref_cost = REF_COST( 0, i_ref );
1144         i_halfpel_thresh -= i_ref_cost;
1145         m.i_ref_cost = i_ref_cost;
1146
1147         /* search with ref */
1148         LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 0 );
1149         LOAD_WPELS( &m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 0, 0 );
1150
1151         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
1152         x264_mb_predict_mv_ref16x16( h, 0, i_ref, mvc, &i_mvc );
1153
1154         if( h->mb.ref_blind_dupe == i_ref )
1155         {
1156             CP32( m.mv, a->l0.mvc[0][0] );
1157             x264_me_refine_qpel_refdupe( h, &m, p_halfpel_thresh );
1158         }
1159         else
1160             x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );
1161
1162         /* early termination
1163          * SSD threshold would probably be better than SATD */
1164         if( i_ref == 0
1165             && a->b_try_pskip
1166             && m.cost-m.cost_mv < 300*a->i_lambda
1167             &&  abs(m.mv[0]-h->mb.cache.pskip_mv[0])
1168               + abs(m.mv[1]-h->mb.cache.pskip_mv[1]) <= 1
1169             && x264_macroblock_probe_pskip( h ) )
1170         {
1171             h->mb.i_type = P_SKIP;
1172             x264_analyse_update_cache( h, a );
1173             assert( h->mb.cache.pskip_mv[1] <= h->mb.mv_max_spel[1] || h->i_thread_frames == 1 );
1174             return;
1175         }
1176
1177         m.cost += i_ref_cost;
1178         i_halfpel_thresh += i_ref_cost;
1179
1180         if( m.cost < a->l0.me16x16.cost )
1181             h->mc.memcpy_aligned( &a->l0.me16x16, &m, sizeof(x264_me_t) );
1182
1183         /* save mv for predicting neighbors */
1184         CP32( a->l0.mvc[i_ref][0], m.mv );
1185         CP32( h->mb.mvr[0][i_ref][h->mb.i_mb_xy], m.mv );
1186     }
1187
1188     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.me16x16.i_ref );
1189     assert( a->l0.me16x16.mv[1] <= h->mb.mv_max_spel[1] || h->i_thread_frames == 1 );
1190
1191     h->mb.i_type = P_L0;
1192     if( a->i_mbrd )
1193     {
1194         x264_mb_cache_fenc_satd( h );
1195         if( a->l0.me16x16.i_ref == 0 && M32( a->l0.me16x16.mv ) == M32( h->mb.cache.pskip_mv ) && !a->b_force_intra )
1196         {
1197             h->mb.i_partition = D_16x16;
1198             x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
1199             a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
1200             if( !(h->mb.i_cbp_luma|h->mb.i_cbp_chroma) )
1201                 h->mb.i_type = P_SKIP;
1202         }
1203     }
1204 }
1205
1206 static void x264_mb_analyse_inter_p8x8_mixed_ref( x264_t *h, x264_mb_analysis_t *a )
1207 {
1208     x264_me_t m;
1209     int i_ref;
1210     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1211     int i_halfpel_thresh = INT_MAX;
1212     int *p_halfpel_thresh = /*h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh : */NULL;
1213     int i;
1214     int i_maxref = h->mb.pic.i_fref[0]-1;
1215
1216     h->mb.i_partition = D_8x8;
1217
1218     #define CHECK_NEIGHBOUR(i)\
1219     {\
1220         int ref = h->mb.cache.ref[0][X264_SCAN8_0+i];\
1221         if( ref > i_maxref && ref != h->mb.ref_blind_dupe )\
1222             i_maxref = ref;\
1223     }
1224
1225     /* early termination: if 16x16 chose ref 0, then evalute no refs older
1226      * than those used by the neighbors */
1227     if( i_maxref > 0 && (a->l0.me16x16.i_ref == 0 || a->l0.me16x16.i_ref == h->mb.ref_blind_dupe) &&
1228         h->mb.i_mb_type_top && h->mb.i_mb_type_left )
1229     {
1230         i_maxref = 0;
1231         CHECK_NEIGHBOUR(  -8 - 1 );
1232         CHECK_NEIGHBOUR(  -8 + 0 );
1233         CHECK_NEIGHBOUR(  -8 + 2 );
1234         CHECK_NEIGHBOUR(  -8 + 4 );
1235         CHECK_NEIGHBOUR(   0 - 1 );
1236         CHECK_NEIGHBOUR( 2*8 - 1 );
1237     }
1238
1239     for( i_ref = 0; i_ref <= i_maxref; i_ref++ )
1240         CP32( a->l0.mvc[i_ref][0], h->mb.mvr[0][i_ref][h->mb.i_mb_xy] );
1241
1242     for( i = 0; i < 4; i++ )
1243     {
1244         x264_me_t *l0m = &a->l0.me8x8[i];
1245         const int x8 = i%2;
1246         const int y8 = i/2;
1247
1248         m.i_pixel = PIXEL_8x8;
1249
1250         LOAD_FENC( &m, p_fenc, 8*x8, 8*y8 );
1251         l0m->cost = INT_MAX;
1252         for( i_ref = 0; i_ref <= i_maxref || i_ref == h->mb.ref_blind_dupe; )
1253         {
1254             const int i_ref_cost = REF_COST( 0, i_ref );
1255             m.i_ref_cost = i_ref_cost;
1256
1257             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*x8, 8*y8 );
1258             LOAD_WPELS( &m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 8*x8, 8*y8 );
1259
1260             x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, i_ref );
1261             x264_mb_predict_mv( h, 0, 4*i, 2, m.mvp );
1262             if( h->mb.ref_blind_dupe == i_ref )
1263             {
1264                 CP32( m.mv, a->l0.mvc[0][i+1] );
1265                 x264_me_refine_qpel_refdupe( h, &m, p_halfpel_thresh );
1266             }
1267             else
1268                 x264_me_search_ref( h, &m, a->l0.mvc[i_ref], i+1, p_halfpel_thresh );
1269
1270             m.cost += i_ref_cost;
1271             i_halfpel_thresh += i_ref_cost;
1272             CP32( a->l0.mvc[i_ref][i+1], m.mv );
1273
1274             if( m.cost < l0m->cost )
1275                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
1276             if( i_ref == i_maxref && i_maxref < h->mb.ref_blind_dupe )
1277                 i_ref = h->mb.ref_blind_dupe;
1278             else
1279                 i_ref++;
1280         }
1281         x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, 0, l0m->mv );
1282         x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, l0m->i_ref );
1283
1284         /* If CABAC is on and we're not doing sub-8x8 analysis, the costs
1285            are effectively zero. */
1286         if( !h->param.b_cabac || (h->param.analyse.inter & X264_ANALYSE_PSUB8x8) )
1287             l0m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
1288     }
1289
1290     a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
1291                       a->l0.me8x8[2].cost + a->l0.me8x8[3].cost;
1292     /* P_8x8 ref0 has no ref cost */
1293     if( !h->param.b_cabac && !(a->l0.me8x8[0].i_ref | a->l0.me8x8[1].i_ref |
1294                                a->l0.me8x8[2].i_ref | a->l0.me8x8[3].i_ref) )
1295         a->l0.i_cost8x8 -= REF_COST( 0, 0 ) * 4;
1296     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
1297     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
1298 }
1299
1300 static void x264_mb_analyse_inter_p8x8( x264_t *h, x264_mb_analysis_t *a )
1301 {
1302     /* Duplicate refs are rarely useful in p8x8 due to the high cost of the
1303      * reference frame flags.  Thus, if we're not doing mixedrefs, just
1304      * don't bother analysing the dupes. */
1305     const int i_ref = h->mb.ref_blind_dupe == a->l0.me16x16.i_ref ? 0 : a->l0.me16x16.i_ref;
1306     const int i_ref_cost = h->param.b_cabac || i_ref ? REF_COST( 0, i_ref ) : 0;
1307     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1308     int i_mvc;
1309     int16_t (*mvc)[2] = a->l0.mvc[i_ref];
1310     int i;
1311
1312     /* XXX Needed for x264_mb_predict_mv */
1313     h->mb.i_partition = D_8x8;
1314
1315     i_mvc = 1;
1316     CP32( mvc[0], a->l0.me16x16.mv );
1317
1318     for( i = 0; i < 4; i++ )
1319     {
1320         x264_me_t *m = &a->l0.me8x8[i];
1321         const int x8 = i%2;
1322         const int y8 = i/2;
1323
1324         m->i_pixel = PIXEL_8x8;
1325         m->i_ref_cost = i_ref_cost;
1326
1327         LOAD_FENC( m, p_fenc, 8*x8, 8*y8 );
1328         LOAD_HPELS( m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*x8, 8*y8 );
1329         LOAD_WPELS( m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 8*x8, 8*y8 );
1330
1331         x264_mb_predict_mv( h, 0, 4*i, 2, m->mvp );
1332         x264_me_search( h, m, mvc, i_mvc );
1333
1334         x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, 0, m->mv );
1335
1336         CP32( mvc[i_mvc], m->mv );
1337         i_mvc++;
1338
1339         /* mb type cost */
1340         m->cost += i_ref_cost;
1341         if( !h->param.b_cabac || (h->param.analyse.inter & X264_ANALYSE_PSUB8x8) )
1342             m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
1343     }
1344
1345     a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
1346                       a->l0.me8x8[2].cost + a->l0.me8x8[3].cost;
1347     /* theoretically this should include 4*ref_cost,
1348      * but 3 seems a better approximation of cabac. */
1349     if( h->param.b_cabac )
1350         a->l0.i_cost8x8 -= i_ref_cost;
1351     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
1352     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
1353 }
1354
1355 static void x264_mb_analyse_inter_p16x8( x264_t *h, x264_mb_analysis_t *a )
1356 {
1357     x264_me_t m;
1358     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1359     ALIGNED_4( int16_t mvc[3][2] );
1360     int i, j;
1361
1362     /* XXX Needed for x264_mb_predict_mv */
1363     h->mb.i_partition = D_16x8;
1364
1365     for( i = 0; i < 2; i++ )
1366     {
1367         x264_me_t *l0m = &a->l0.me16x8[i];
1368         const int minref = X264_MIN( a->l0.me8x8[2*i].i_ref, a->l0.me8x8[2*i+1].i_ref );
1369         const int maxref = X264_MAX( a->l0.me8x8[2*i].i_ref, a->l0.me8x8[2*i+1].i_ref );
1370         const int ref8[2] = { minref, maxref };
1371         const int i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;
1372
1373         m.i_pixel = PIXEL_16x8;
1374
1375         LOAD_FENC( &m, p_fenc, 0, 8*i );
1376         l0m->cost = INT_MAX;
1377         for( j = 0; j < i_ref8s; j++ )
1378         {
1379             const int i_ref = ref8[j];
1380             const int i_ref_cost = REF_COST( 0, i_ref );
1381             m.i_ref_cost = i_ref_cost;
1382
1383             /* if we skipped the 16x16 predictor, we wouldn't have to copy anything... */
1384             CP32( mvc[0], a->l0.mvc[i_ref][0] );
1385             CP32( mvc[1], a->l0.mvc[i_ref][2*i+1] );
1386             CP32( mvc[2], a->l0.mvc[i_ref][2*i+2] );
1387
1388             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 8*i );
1389             LOAD_WPELS( &m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 0, 8*i );
1390
1391             x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, 0, i_ref );
1392             x264_mb_predict_mv( h, 0, 8*i, 4, m.mvp );
1393             /* We can only take this shortcut if the first search was performed on ref0. */
1394             if( h->mb.ref_blind_dupe == i_ref && !ref8[0] )
1395             {
1396                 /* We can just leave the MV from the previous ref search. */
1397                 x264_me_refine_qpel_refdupe( h, &m, NULL );
1398             }
1399             else
1400                 x264_me_search( h, &m, mvc, 3 );
1401
1402             m.cost += i_ref_cost;
1403
1404             if( m.cost < l0m->cost )
1405                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
1406         }
1407         x264_macroblock_cache_mv_ptr( h, 0, 2*i, 4, 2, 0, l0m->mv );
1408         x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, 0, l0m->i_ref );
1409     }
1410
1411     a->l0.i_cost16x8 = a->l0.me16x8[0].cost + a->l0.me16x8[1].cost;
1412 }
1413
1414 static void x264_mb_analyse_inter_p8x16( x264_t *h, x264_mb_analysis_t *a )
1415 {
1416     x264_me_t m;
1417     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1418     ALIGNED_4( int16_t mvc[3][2] );
1419     int i, j;
1420
1421     /* XXX Needed for x264_mb_predict_mv */
1422     h->mb.i_partition = D_8x16;
1423
1424     for( i = 0; i < 2; i++ )
1425     {
1426         x264_me_t *l0m = &a->l0.me8x16[i];
1427         const int minref = X264_MIN( a->l0.me8x8[i].i_ref, a->l0.me8x8[i+2].i_ref );
1428         const int maxref = X264_MAX( a->l0.me8x8[i].i_ref, a->l0.me8x8[i+2].i_ref );
1429         const int ref8[2] = { minref, maxref };
1430         const int i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;
1431
1432         m.i_pixel = PIXEL_8x16;
1433
1434         LOAD_FENC( &m, p_fenc, 8*i, 0 );
1435         l0m->cost = INT_MAX;
1436         for( j = 0; j < i_ref8s; j++ )
1437         {
1438             const int i_ref = ref8[j];
1439             const int i_ref_cost = REF_COST( 0, i_ref );
1440             m.i_ref_cost = i_ref_cost;
1441
1442             CP32( mvc[0], a->l0.mvc[i_ref][0] );
1443             CP32( mvc[1], a->l0.mvc[i_ref][i+1] );
1444             CP32( mvc[2], a->l0.mvc[i_ref][i+3] );
1445
1446             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*i, 0 );
1447             LOAD_WPELS( &m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 8*i, 0 );
1448
1449             x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, 0, i_ref );
1450             x264_mb_predict_mv( h, 0, 4*i, 2, m.mvp );
1451             /* We can only take this shortcut if the first search was performed on ref0. */
1452             if( h->mb.ref_blind_dupe == i_ref && !ref8[0] )
1453             {
1454                 /* We can just leave the MV from the previous ref search. */
1455                 x264_me_refine_qpel_refdupe( h, &m, NULL );
1456             }
1457             else
1458                 x264_me_search( h, &m, mvc, 3 );
1459
1460             m.cost += i_ref_cost;
1461
1462             if( m.cost < l0m->cost )
1463                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
1464         }
1465         x264_macroblock_cache_mv_ptr( h, 2*i, 0, 2, 4, 0, l0m->mv );
1466         x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, 0, l0m->i_ref );
1467     }
1468
1469     a->l0.i_cost8x16 = a->l0.me8x16[0].cost + a->l0.me8x16[1].cost;
1470 }
1471
1472 static int x264_mb_analyse_inter_p4x4_chroma( x264_t *h, x264_mb_analysis_t *a, uint8_t **p_fref, int i8x8, int pixel )
1473 {
1474     ALIGNED_ARRAY_8( uint8_t, pix1,[16*8] );
1475     uint8_t *pix2 = pix1+8;
1476     const int i_stride = h->mb.pic.i_stride[1];
1477     const int or = 4*(i8x8&1) + 2*(i8x8&2)*i_stride;
1478     const int oe = 4*(i8x8&1) + 2*(i8x8&2)*FENC_STRIDE;
1479     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1480     const int mvy_offset = h->mb.b_interlaced & i_ref ? (h->mb.i_mb_y & 1)*4 - 2 : 0;
1481     x264_weight_t *weight = h->sh.weight[i_ref];
1482
1483 #define CHROMA4x4MC( width, height, me, x, y ) \
1484     h->mc.mc_chroma( &pix1[x+y*16], 16, &p_fref[4][or+x+y*i_stride], i_stride, (me).mv[0], (me).mv[1]+mvy_offset, width, height ); \
1485     if( weight[1].weightfn ) \
1486         weight[1].weightfn[width>>2]( &pix1[x+y*16], 16, &pix1[x+y*16], 16, &weight[1], height ); \
1487     h->mc.mc_chroma( &pix2[x+y*16], 16, &p_fref[5][or+x+y*i_stride], i_stride, (me).mv[0], (me).mv[1]+mvy_offset, width, height ); \
1488     if( weight[2].weightfn ) \
1489         weight[1].weightfn[width>>2]( &pix2[x+y*16], 16, &pix2[x+y*16], 16, &weight[2], height );
1490
1491
1492     if( pixel == PIXEL_4x4 )
1493     {
1494         x264_me_t *m = a->l0.me4x4[i8x8];
1495         CHROMA4x4MC( 2,2, m[0], 0,0 );
1496         CHROMA4x4MC( 2,2, m[1], 2,0 );
1497         CHROMA4x4MC( 2,2, m[2], 0,2 );
1498         CHROMA4x4MC( 2,2, m[3], 2,2 );
1499     }
1500     else if( pixel == PIXEL_8x4 )
1501     {
1502         x264_me_t *m = a->l0.me8x4[i8x8];
1503         CHROMA4x4MC( 4,2, m[0], 0,0 );
1504         CHROMA4x4MC( 4,2, m[1], 0,2 );
1505     }
1506     else
1507     {
1508         x264_me_t *m = a->l0.me4x8[i8x8];
1509         CHROMA4x4MC( 2,4, m[0], 0,0 );
1510         CHROMA4x4MC( 2,4, m[1], 2,0 );
1511     }
1512
1513     return h->pixf.mbcmp[PIXEL_4x4]( &h->mb.pic.p_fenc[1][oe], FENC_STRIDE, pix1, 16 )
1514          + h->pixf.mbcmp[PIXEL_4x4]( &h->mb.pic.p_fenc[2][oe], FENC_STRIDE, pix2, 16 );
1515 }
1516
1517 static void x264_mb_analyse_inter_p4x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
1518 {
1519     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
1520     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1521     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1522     int i4x4;
1523
1524     /* XXX Needed for x264_mb_predict_mv */
1525     h->mb.i_partition = D_8x8;
1526
1527     for( i4x4 = 0; i4x4 < 4; i4x4++ )
1528     {
1529         const int idx = 4*i8x8 + i4x4;
1530         const int x4 = block_idx_x[idx];
1531         const int y4 = block_idx_y[idx];
1532         const int i_mvc = (i4x4 == 0);
1533
1534         x264_me_t *m = &a->l0.me4x4[i8x8][i4x4];
1535
1536         m->i_pixel = PIXEL_4x4;
1537
1538         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
1539         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
1540         LOAD_WPELS( m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 4*x4, 4*y4 );
1541
1542         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
1543         x264_me_search( h, m, &a->l0.me8x8[i8x8].mv, i_mvc );
1544
1545         x264_macroblock_cache_mv_ptr( h, x4, y4, 1, 1, 0, m->mv );
1546     }
1547     a->l0.i_cost4x4[i8x8] = a->l0.me4x4[i8x8][0].cost +
1548                             a->l0.me4x4[i8x8][1].cost +
1549                             a->l0.me4x4[i8x8][2].cost +
1550                             a->l0.me4x4[i8x8][3].cost +
1551                             REF_COST( 0, i_ref ) +
1552                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x4];
1553     if( h->mb.b_chroma_me )
1554         a->l0.i_cost4x4[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_4x4 );
1555 }
1556
1557 static void x264_mb_analyse_inter_p8x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
1558 {
1559     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
1560     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1561     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1562     int i8x4;
1563
1564     /* XXX Needed for x264_mb_predict_mv */
1565     h->mb.i_partition = D_8x8;
1566
1567     for( i8x4 = 0; i8x4 < 2; i8x4++ )
1568     {
1569         const int idx = 4*i8x8 + 2*i8x4;
1570         const int x4 = block_idx_x[idx];
1571         const int y4 = block_idx_y[idx];
1572         const int i_mvc = (i8x4 == 0);
1573
1574         x264_me_t *m = &a->l0.me8x4[i8x8][i8x4];
1575
1576         m->i_pixel = PIXEL_8x4;
1577
1578         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
1579         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
1580         LOAD_WPELS( m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 4*x4, 4*y4 );
1581
1582         x264_mb_predict_mv( h, 0, idx, 2, m->mvp );
1583         x264_me_search( h, m, &a->l0.me4x4[i8x8][0].mv, i_mvc );
1584
1585         x264_macroblock_cache_mv_ptr( h, x4, y4, 2, 1, 0, m->mv );
1586     }
1587     a->l0.i_cost8x4[i8x8] = a->l0.me8x4[i8x8][0].cost + a->l0.me8x4[i8x8][1].cost +
1588                             REF_COST( 0, i_ref ) +
1589                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x4];
1590     if( h->mb.b_chroma_me )
1591         a->l0.i_cost8x4[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_8x4 );
1592 }
1593
1594 static void x264_mb_analyse_inter_p4x8( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
1595 {
1596     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
1597     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1598     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1599     int i4x8;
1600
1601     /* XXX Needed for x264_mb_predict_mv */
1602     h->mb.i_partition = D_8x8;
1603
1604     for( i4x8 = 0; i4x8 < 2; i4x8++ )
1605     {
1606         const int idx = 4*i8x8 + i4x8;
1607         const int x4 = block_idx_x[idx];
1608         const int y4 = block_idx_y[idx];
1609         const int i_mvc = (i4x8 == 0);
1610
1611         x264_me_t *m = &a->l0.me4x8[i8x8][i4x8];
1612
1613         m->i_pixel = PIXEL_4x8;
1614
1615         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
1616         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
1617         LOAD_WPELS( m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 4*x4, 4*y4 );
1618
1619         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
1620         x264_me_search( h, m, &a->l0.me4x4[i8x8][0].mv, i_mvc );
1621
1622         x264_macroblock_cache_mv_ptr( h, x4, y4, 1, 2, 0, m->mv );
1623     }
1624     a->l0.i_cost4x8[i8x8] = a->l0.me4x8[i8x8][0].cost + a->l0.me4x8[i8x8][1].cost +
1625                             REF_COST( 0, i_ref ) +
1626                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x8];
1627     if( h->mb.b_chroma_me )
1628         a->l0.i_cost4x8[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_4x8 );
1629 }
1630
1631 static void x264_mb_analyse_inter_direct( x264_t *h, x264_mb_analysis_t *a )
1632 {
1633     /* Assumes that fdec still contains the results of
1634      * x264_mb_predict_mv_direct16x16 and x264_mb_mc */
1635
1636     uint8_t **p_fenc = h->mb.pic.p_fenc;
1637     uint8_t **p_fdec = h->mb.pic.p_fdec;
1638     int i;
1639
1640     a->i_cost16x16direct = a->i_lambda * i_mb_b_cost_table[B_DIRECT];
1641     for( i = 0; i < 4; i++ )
1642     {
1643         const int x = (i&1)*8;
1644         const int y = (i>>1)*8;
1645         a->i_cost16x16direct +=
1646         a->i_cost8x8direct[i] =
1647             h->pixf.mbcmp[PIXEL_8x8]( &p_fenc[0][x+y*FENC_STRIDE], FENC_STRIDE, &p_fdec[0][x+y*FDEC_STRIDE], FDEC_STRIDE );
1648
1649         /* mb type cost */
1650         a->i_cost8x8direct[i] += a->i_lambda * i_sub_mb_b_cost_table[D_DIRECT_8x8];
1651     }
1652 }
1653
1654 static void x264_mb_analyse_inter_b16x16( x264_t *h, x264_mb_analysis_t *a )
1655 {
1656     ALIGNED_ARRAY_16( uint8_t, pix0,[16*16] );
1657     ALIGNED_ARRAY_16( uint8_t, pix1,[16*16] );
1658     uint8_t *src0, *src1;
1659     int stride0 = 16, stride1 = 16;
1660
1661     x264_me_t m;
1662     int i_ref, i_mvc;
1663     ALIGNED_4( int16_t mvc[9][2] );
1664     int i_halfpel_thresh = INT_MAX;
1665     int *p_halfpel_thresh = h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh : NULL;
1666
1667     /* 16x16 Search on all ref frame */
1668     m.i_pixel = PIXEL_16x16;
1669     m.weight = weight_none;
1670
1671     LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 0 );
1672
1673     /* ME for List 0 */
1674     a->l0.me16x16.cost = INT_MAX;
1675     for( i_ref = 0; i_ref < h->mb.pic.i_fref[0]; i_ref++ )
1676     {
1677         const int i_ref_cost = REF_COST( 0, i_ref );
1678         m.i_ref_cost = i_ref_cost;
1679         /* search with ref */
1680         LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 0 );
1681         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
1682         x264_mb_predict_mv_ref16x16( h, 0, i_ref, mvc, &i_mvc );
1683         x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );
1684
1685         /* add ref cost */
1686         m.cost += i_ref_cost;
1687
1688         if( m.cost < a->l0.me16x16.cost )
1689         {
1690             a->l0.i_ref = i_ref;
1691             h->mc.memcpy_aligned( &a->l0.me16x16, &m, sizeof(x264_me_t) );
1692         }
1693
1694         /* save mv for predicting neighbors */
1695         CP32( h->mb.mvr[0][i_ref][h->mb.i_mb_xy], m.mv );
1696     }
1697     a->l0.me16x16.i_ref = a->l0.i_ref;
1698
1699     /* ME for list 1 */
1700     i_halfpel_thresh = INT_MAX;
1701     p_halfpel_thresh = h->mb.pic.i_fref[1]>1 ? &i_halfpel_thresh : NULL;
1702     a->l1.me16x16.cost = INT_MAX;
1703     for( i_ref = 0; i_ref < h->mb.pic.i_fref[1]; i_ref++ )
1704     {
1705         const int i_ref_cost = REF_COST( 0, i_ref );
1706         m.i_ref_cost = i_ref_cost;
1707         /* search with ref */
1708         LOAD_HPELS( &m, h->mb.pic.p_fref[1][i_ref], 1, i_ref, 0, 0 );
1709         x264_mb_predict_mv_16x16( h, 1, i_ref, m.mvp );
1710         x264_mb_predict_mv_ref16x16( h, 1, i_ref, mvc, &i_mvc );
1711         x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );
1712
1713         /* add ref cost */
1714         m.cost += i_ref_cost;
1715
1716         if( m.cost < a->l1.me16x16.cost )
1717         {
1718             a->l1.i_ref = i_ref;
1719             h->mc.memcpy_aligned( &a->l1.me16x16, &m, sizeof(x264_me_t) );
1720         }
1721
1722         /* save mv for predicting neighbors */
1723         CP32( h->mb.mvr[1][i_ref][h->mb.i_mb_xy], m.mv );
1724     }
1725     a->l1.me16x16.i_ref = a->l1.i_ref;
1726
1727     /* get cost of BI mode */
1728     int ref_costs = REF_COST( 0, a->l0.i_ref ) + REF_COST( 1, a->l1.i_ref );
1729     h->mc.memcpy_aligned( &a->l0.bi16x16, &a->l0.me16x16, sizeof(x264_me_t) );
1730     h->mc.memcpy_aligned( &a->l1.bi16x16, &a->l1.me16x16, sizeof(x264_me_t) );
1731     src0 = h->mc.get_ref( pix0, &stride0,
1732                           h->mb.pic.p_fref[0][a->l0.i_ref], h->mb.pic.i_stride[0],
1733                           a->l0.bi16x16.mv[0], a->l0.bi16x16.mv[1], 16, 16, weight_none );
1734     src1 = h->mc.get_ref( pix1, &stride1,
1735                           h->mb.pic.p_fref[1][a->l1.i_ref], h->mb.pic.i_stride[0],
1736                           a->l1.bi16x16.mv[0], a->l1.bi16x16.mv[1], 16, 16, weight_none );
1737
1738     h->mc.avg[PIXEL_16x16]( pix0, 16, src0, stride0, src1, stride1, h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
1739
1740     a->i_cost16x16bi = h->pixf.mbcmp[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE, pix0, 16 )
1741                      + ref_costs
1742                      + a->l0.bi16x16.cost_mv
1743                      + a->l1.bi16x16.cost_mv;
1744
1745
1746     /* Always try the 0,0,0,0 vector; helps avoid errant motion vectors in fades */
1747     if( M32( a->l0.bi16x16.mv ) | M32( a->l1.bi16x16.mv ) )
1748     {
1749         int l0_mv_cost = a->l0.bi16x16.p_cost_mv[-a->l0.bi16x16.mvp[0]]
1750                        + a->l0.bi16x16.p_cost_mv[-a->l0.bi16x16.mvp[1]];
1751         int l1_mv_cost = a->l1.bi16x16.p_cost_mv[-a->l1.bi16x16.mvp[0]]
1752                        + a->l1.bi16x16.p_cost_mv[-a->l1.bi16x16.mvp[1]];
1753         h->mc.avg[PIXEL_16x16]( pix0, 16, h->mb.pic.p_fref[0][a->l0.i_ref][0], h->mb.pic.i_stride[0],
1754                                 h->mb.pic.p_fref[1][a->l1.i_ref][0], h->mb.pic.i_stride[0],
1755                                 h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
1756         int cost00 = h->pixf.mbcmp[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE, pix0, 16 )
1757                    + ref_costs + l0_mv_cost + l1_mv_cost;
1758         if( cost00 < a->i_cost16x16bi )
1759         {
1760             M32( a->l0.bi16x16.mv ) = 0;
1761             M32( a->l1.bi16x16.mv ) = 0;
1762             a->l0.bi16x16.cost_mv = l0_mv_cost;
1763             a->l1.bi16x16.cost_mv = l1_mv_cost;
1764             a->i_cost16x16bi = cost00;
1765         }
1766     }
1767
1768     /* mb type cost */
1769     a->i_cost16x16bi   += a->i_lambda * i_mb_b_cost_table[B_BI_BI];
1770     a->l0.me16x16.cost += a->i_lambda * i_mb_b_cost_table[B_L0_L0];
1771     a->l1.me16x16.cost += a->i_lambda * i_mb_b_cost_table[B_L1_L1];
1772 }
1773
1774 static inline void x264_mb_cache_mv_p8x8( x264_t *h, x264_mb_analysis_t *a, int i )
1775 {
1776     const int x = 2*(i%2);
1777     const int y = 2*(i/2);
1778
1779     switch( h->mb.i_sub_partition[i] )
1780     {
1781         case D_L0_8x8:
1782             x264_macroblock_cache_mv_ptr( h, x, y, 2, 2, 0, a->l0.me8x8[i].mv );
1783             break;
1784         case D_L0_8x4:
1785             x264_macroblock_cache_mv_ptr( h, x, y+0, 2, 1, 0, a->l0.me8x4[i][0].mv );
1786             x264_macroblock_cache_mv_ptr( h, x, y+1, 2, 1, 0, a->l0.me8x4[i][1].mv );
1787             break;
1788         case D_L0_4x8:
1789             x264_macroblock_cache_mv_ptr( h, x+0, y, 1, 2, 0, a->l0.me4x8[i][0].mv );
1790             x264_macroblock_cache_mv_ptr( h, x+1, y, 1, 2, 0, a->l0.me4x8[i][1].mv );
1791             break;
1792         case D_L0_4x4:
1793             x264_macroblock_cache_mv_ptr( h, x+0, y+0, 1, 1, 0, a->l0.me4x4[i][0].mv );
1794             x264_macroblock_cache_mv_ptr( h, x+1, y+0, 1, 1, 0, a->l0.me4x4[i][1].mv );
1795             x264_macroblock_cache_mv_ptr( h, x+0, y+1, 1, 1, 0, a->l0.me4x4[i][2].mv );
1796             x264_macroblock_cache_mv_ptr( h, x+1, y+1, 1, 1, 0, a->l0.me4x4[i][3].mv );
1797             break;
1798         default:
1799             x264_log( h, X264_LOG_ERROR, "internal error\n" );
1800             break;
1801     }
1802 }
1803
1804 static void x264_mb_load_mv_direct8x8( x264_t *h, int idx )
1805 {
1806     const int x = 2*(idx&1);
1807     const int y = 2*(idx>>1);
1808     x264_macroblock_cache_ref( h, x, y, 2, 2, 0, h->mb.cache.direct_ref[0][idx] );
1809     x264_macroblock_cache_ref( h, x, y, 2, 2, 1, h->mb.cache.direct_ref[1][idx] );
1810     x264_macroblock_cache_mv_ptr( h, x, y, 2, 2, 0, h->mb.cache.direct_mv[0][idx] );
1811     x264_macroblock_cache_mv_ptr( h, x, y, 2, 2, 1, h->mb.cache.direct_mv[1][idx] );
1812 }
1813
1814 #define CACHE_MV_BI(x,y,dx,dy,me0,me1,part) \
1815     if( x264_mb_partition_listX_table[0][part] ) \
1816     { \
1817         x264_macroblock_cache_ref( h, x,y,dx,dy, 0, a->l0.i_ref ); \
1818         x264_macroblock_cache_mv_ptr( h, x,y,dx,dy, 0, me0.mv ); \
1819     } \
1820     else \
1821     { \
1822         x264_macroblock_cache_ref( h, x,y,dx,dy, 0, -1 ); \
1823         x264_macroblock_cache_mv(  h, x,y,dx,dy, 0, 0 ); \
1824         if( b_mvd ) \
1825             x264_macroblock_cache_mvd( h, x,y,dx,dy, 0, 0 ); \
1826     } \
1827     if( x264_mb_partition_listX_table[1][part] ) \
1828     { \
1829         x264_macroblock_cache_ref( h, x,y,dx,dy, 1, a->l1.i_ref ); \
1830         x264_macroblock_cache_mv_ptr( h, x,y,dx,dy, 1, me1.mv ); \
1831     } \
1832     else \
1833     { \
1834         x264_macroblock_cache_ref( h, x,y,dx,dy, 1, -1 ); \
1835         x264_macroblock_cache_mv(  h, x,y,dx,dy, 1, 0 ); \
1836         if( b_mvd ) \
1837             x264_macroblock_cache_mvd( h, x,y,dx,dy, 1, 0 ); \
1838     }
1839
1840 static inline void x264_mb_cache_mv_b8x8( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
1841 {
1842     int x = (i%2)*2;
1843     int y = (i/2)*2;
1844     if( h->mb.i_sub_partition[i] == D_DIRECT_8x8 )
1845     {
1846         x264_mb_load_mv_direct8x8( h, i );
1847         if( b_mvd )
1848         {
1849             x264_macroblock_cache_mvd(  h, x, y, 2, 2, 0, 0 );
1850             x264_macroblock_cache_mvd(  h, x, y, 2, 2, 1, 0 );
1851             x264_macroblock_cache_skip( h, x, y, 2, 2, 1 );
1852         }
1853     }
1854     else
1855     {
1856         CACHE_MV_BI( x, y, 2, 2, a->l0.me8x8[i], a->l1.me8x8[i], h->mb.i_sub_partition[i] );
1857     }
1858 }
1859 static inline void x264_mb_cache_mv_b16x8( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
1860 {
1861     CACHE_MV_BI( 0, 2*i, 4, 2, a->l0.me16x8[i], a->l1.me16x8[i], a->i_mb_partition16x8[i] );
1862 }
1863 static inline void x264_mb_cache_mv_b8x16( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
1864 {
1865     CACHE_MV_BI( 2*i, 0, 2, 4, a->l0.me8x16[i], a->l1.me8x16[i], a->i_mb_partition8x16[i] );
1866 }
1867 #undef CACHE_MV_BI
1868
1869 static void x264_mb_analyse_inter_b8x8( x264_t *h, x264_mb_analysis_t *a )
1870 {
1871     uint8_t **p_fref[2] =
1872         { h->mb.pic.p_fref[0][a->l0.i_ref],
1873           h->mb.pic.p_fref[1][a->l1.i_ref] };
1874     ALIGNED_ARRAY_8( uint8_t, pix,[2],[8*8] );
1875     int i, l;
1876
1877     /* XXX Needed for x264_mb_predict_mv */
1878     h->mb.i_partition = D_8x8;
1879
1880     a->i_cost8x8bi = 0;
1881
1882     for( i = 0; i < 4; i++ )
1883     {
1884         const int x8 = i%2;
1885         const int y8 = i/2;
1886         int i_part_cost;
1887         int i_part_cost_bi = 0;
1888         int stride[2] = {8,8};
1889         uint8_t *src[2];
1890
1891         for( l = 0; l < 2; l++ )
1892         {
1893             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
1894             const int i_ref_cost = REF_COST( l, lX->i_ref );
1895             x264_me_t *m = &lX->me8x8[i];
1896
1897             m->i_pixel = PIXEL_8x8;
1898             m->i_ref_cost = i_ref_cost;
1899
1900             LOAD_FENC( m, h->mb.pic.p_fenc, 8*x8, 8*y8 );
1901             LOAD_HPELS( m, p_fref[l], l, lX->i_ref, 8*x8, 8*y8 );
1902
1903             x264_macroblock_cache_ref( h, x8*2, y8*2, 2, 2, l, lX->i_ref );
1904             x264_mb_predict_mv( h, l, 4*i, 2, m->mvp );
1905             x264_me_search( h, m, &lX->me16x16.mv, 1 );
1906             m->cost += i_ref_cost;
1907
1908             x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, l, m->mv );
1909
1910             /* BI mode */
1911             src[l] = h->mc.get_ref( pix[l], &stride[l], m->p_fref, m->i_stride[0],
1912                                     m->mv[0], m->mv[1], 8, 8, weight_none );
1913             i_part_cost_bi += m->cost_mv + i_ref_cost;
1914         }
1915         h->mc.avg[PIXEL_8x8]( pix[0], 8, src[0], stride[0], src[1], stride[1], h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
1916         i_part_cost_bi += h->pixf.mbcmp[PIXEL_8x8]( a->l0.me8x8[i].p_fenc[0], FENC_STRIDE, pix[0], 8 )
1917                         + a->i_lambda * i_sub_mb_b_cost_table[D_BI_8x8];
1918         a->l0.me8x8[i].cost += a->i_lambda * i_sub_mb_b_cost_table[D_L0_8x8];
1919         a->l1.me8x8[i].cost += a->i_lambda * i_sub_mb_b_cost_table[D_L1_8x8];
1920
1921         i_part_cost = a->l0.me8x8[i].cost;
1922         h->mb.i_sub_partition[i] = D_L0_8x8;
1923         COPY2_IF_LT( i_part_cost, a->l1.me8x8[i].cost, h->mb.i_sub_partition[i], D_L1_8x8 );
1924         COPY2_IF_LT( i_part_cost, i_part_cost_bi, h->mb.i_sub_partition[i], D_BI_8x8 );
1925         COPY2_IF_LT( i_part_cost, a->i_cost8x8direct[i], h->mb.i_sub_partition[i], D_DIRECT_8x8 );
1926         a->i_cost8x8bi += i_part_cost;
1927
1928         /* XXX Needed for x264_mb_predict_mv */
1929         x264_mb_cache_mv_b8x8( h, a, i, 0 );
1930     }
1931
1932     /* mb type cost */
1933     a->i_cost8x8bi += a->i_lambda * i_mb_b_cost_table[B_8x8];
1934 }
1935
1936 static void x264_mb_analyse_inter_b16x8( x264_t *h, x264_mb_analysis_t *a )
1937 {
1938     uint8_t **p_fref[2] =
1939         { h->mb.pic.p_fref[0][a->l0.i_ref],
1940           h->mb.pic.p_fref[1][a->l1.i_ref] };
1941     ALIGNED_ARRAY_16( uint8_t, pix,[2],[16*8] );
1942     ALIGNED_4( int16_t mvc[2][2] );
1943     int i, l;
1944
1945     h->mb.i_partition = D_16x8;
1946     a->i_cost16x8bi = 0;
1947
1948     for( i = 0; i < 2; i++ )
1949     {
1950         int i_part_cost;
1951         int i_part_cost_bi = 0;
1952         int stride[2] = {16,16};
1953         uint8_t *src[2];
1954
1955         /* TODO: check only the list(s) that were used in b8x8? */
1956         for( l = 0; l < 2; l++ )
1957         {
1958             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
1959             const int i_ref_cost = REF_COST( l, lX->i_ref );
1960             x264_me_t *m = &lX->me16x8[i];
1961
1962             m->i_pixel = PIXEL_16x8;
1963             m->i_ref_cost = i_ref_cost;
1964
1965             LOAD_FENC( m, h->mb.pic.p_fenc, 0, 8*i );
1966             LOAD_HPELS( m, p_fref[l], l, lX->i_ref, 0, 8*i );
1967
1968             CP32( mvc[0], lX->me8x8[2*i].mv );
1969             CP32( mvc[1], lX->me8x8[2*i+1].mv );
1970
1971             x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, l, lX->i_ref );
1972             x264_mb_predict_mv( h, l, 8*i, 4, m->mvp );
1973             x264_me_search( h, m, mvc, 2 );
1974             m->cost += i_ref_cost;
1975
1976             /* BI mode */
1977             src[l] = h->mc.get_ref( pix[l], &stride[l], m->p_fref, m->i_stride[0],
1978                                     m->mv[0], m->mv[1], 16, 8, weight_none );
1979             i_part_cost_bi += m->cost_mv + i_ref_cost;
1980         }
1981         h->mc.avg[PIXEL_16x8]( pix[0], 16, src[0], stride[0], src[1], stride[1], h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
1982         i_part_cost_bi += h->pixf.mbcmp[PIXEL_16x8]( a->l0.me16x8[i].p_fenc[0], FENC_STRIDE, pix[0], 16 );
1983
1984         i_part_cost = a->l0.me16x8[i].cost;
1985         a->i_mb_partition16x8[i] = D_L0_8x8; /* not actually 8x8, only the L0 matters */
1986         if( a->l1.me16x8[i].cost < i_part_cost )
1987         {
1988             i_part_cost = a->l1.me16x8[i].cost;
1989             a->i_mb_partition16x8[i] = D_L1_8x8;
1990         }
1991         if( i_part_cost_bi + a->i_lambda * 1 < i_part_cost )
1992         {
1993             i_part_cost = i_part_cost_bi;
1994             a->i_mb_partition16x8[i] = D_BI_8x8;
1995         }
1996         a->i_cost16x8bi += i_part_cost;
1997
1998         x264_mb_cache_mv_b16x8( h, a, i, 0 );
1999     }
2000
2001     /* mb type cost */
2002     a->i_mb_type16x8 = B_L0_L0
2003         + (a->i_mb_partition16x8[0]>>2) * 3
2004         + (a->i_mb_partition16x8[1]>>2);
2005     a->i_cost16x8bi += a->i_lambda * i_mb_b16x8_cost_table[a->i_mb_type16x8];
2006 }
2007
2008 static void x264_mb_analyse_inter_b8x16( x264_t *h, x264_mb_analysis_t *a )
2009 {
2010     uint8_t **p_fref[2] =
2011         { h->mb.pic.p_fref[0][a->l0.i_ref],
2012           h->mb.pic.p_fref[1][a->l1.i_ref] };
2013     ALIGNED_ARRAY_8( uint8_t, pix,[2],[8*16] );
2014     ALIGNED_4( int16_t mvc[2][2] );
2015     int i, l;
2016
2017     h->mb.i_partition = D_8x16;
2018     a->i_cost8x16bi = 0;
2019
2020     for( i = 0; i < 2; i++ )
2021     {
2022         int i_part_cost;
2023         int i_part_cost_bi = 0;
2024         int stride[2] = {8,8};
2025         uint8_t *src[2];
2026
2027         for( l = 0; l < 2; l++ )
2028         {
2029             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
2030             const int i_ref_cost = REF_COST( l, lX->i_ref );
2031             x264_me_t *m = &lX->me8x16[i];
2032
2033             m->i_pixel = PIXEL_8x16;
2034             m->i_ref_cost = i_ref_cost;
2035
2036             LOAD_FENC( m, h->mb.pic.p_fenc, 8*i, 0 );
2037             LOAD_HPELS( m, p_fref[l], l, lX->i_ref, 8*i, 0 );
2038
2039             CP32( mvc[0], lX->me8x8[i].mv );
2040             CP32( mvc[1], lX->me8x8[i+2].mv );
2041
2042             x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, l, lX->i_ref );
2043             x264_mb_predict_mv( h, l, 4*i, 2, m->mvp );
2044             x264_me_search( h, m, mvc, 2 );
2045             m->cost += i_ref_cost;
2046
2047             /* BI mode */
2048             src[l] = h->mc.get_ref( pix[l], &stride[l], m->p_fref,  m->i_stride[0],
2049                                     m->mv[0], m->mv[1], 8, 16, weight_none );
2050             i_part_cost_bi += m->cost_mv + i_ref_cost;
2051         }
2052
2053         h->mc.avg[PIXEL_8x16]( pix[0], 8, src[0], stride[0], src[1], stride[1], h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
2054         i_part_cost_bi += h->pixf.mbcmp[PIXEL_8x16]( a->l0.me8x16[i].p_fenc[0], FENC_STRIDE, pix[0], 8 );
2055
2056         i_part_cost = a->l0.me8x16[i].cost;
2057         a->i_mb_partition8x16[i] = D_L0_8x8;
2058         if( a->l1.me8x16[i].cost < i_part_cost )
2059         {
2060             i_part_cost = a->l1.me8x16[i].cost;
2061             a->i_mb_partition8x16[i] = D_L1_8x8;
2062         }
2063         if( i_part_cost_bi + a->i_lambda * 1 < i_part_cost )
2064         {
2065             i_part_cost = i_part_cost_bi;
2066             a->i_mb_partition8x16[i] = D_BI_8x8;
2067         }
2068         a->i_cost8x16bi += i_part_cost;
2069
2070         x264_mb_cache_mv_b8x16( h, a, i, 0 );
2071     }
2072
2073     /* mb type cost */
2074     a->i_mb_type8x16 = B_L0_L0
2075         + (a->i_mb_partition8x16[0]>>2) * 3
2076         + (a->i_mb_partition8x16[1]>>2);
2077     a->i_cost8x16bi += a->i_lambda * i_mb_b16x8_cost_table[a->i_mb_type8x16];
2078 }
2079
2080 static void x264_mb_analyse_p_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd )
2081 {
2082     int thresh = i_satd * 5/4;
2083
2084     h->mb.i_type = P_L0;
2085     if( a->l0.i_rd16x16 == COST_MAX && a->l0.me16x16.cost <= i_satd * 3/2 )
2086     {
2087         h->mb.i_partition = D_16x16;
2088         x264_analyse_update_cache( h, a );
2089         a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
2090     }
2091
2092     if( a->l0.i_cost16x8 <= thresh )
2093     {
2094         h->mb.i_partition = D_16x8;
2095         x264_analyse_update_cache( h, a );
2096         a->l0.i_cost16x8 = x264_rd_cost_mb( h, a->i_lambda2 );
2097     }
2098     else
2099         a->l0.i_cost16x8 = COST_MAX;
2100
2101     if( a->l0.i_cost8x16 <= thresh )
2102     {
2103         h->mb.i_partition = D_8x16;
2104         x264_analyse_update_cache( h, a );
2105         a->l0.i_cost8x16 = x264_rd_cost_mb( h, a->i_lambda2 );
2106     }
2107     else
2108         a->l0.i_cost8x16 = COST_MAX;
2109
2110     if( a->l0.i_cost8x8 <= thresh )
2111     {
2112         h->mb.i_type = P_8x8;
2113         h->mb.i_partition = D_8x8;
2114         if( h->param.analyse.inter & X264_ANALYSE_PSUB8x8 )
2115         {
2116             int i;
2117             x264_macroblock_cache_ref( h, 0, 0, 2, 2, 0, a->l0.me8x8[0].i_ref );
2118             x264_macroblock_cache_ref( h, 2, 0, 2, 2, 0, a->l0.me8x8[1].i_ref );
2119             x264_macroblock_cache_ref( h, 0, 2, 2, 2, 0, a->l0.me8x8[2].i_ref );
2120             x264_macroblock_cache_ref( h, 2, 2, 2, 2, 0, a->l0.me8x8[3].i_ref );
2121             /* FIXME: In the 8x8 blocks where RDO isn't run, the NNZ values used for context selection
2122              * for future blocks are those left over from previous RDO calls. */
2123             for( i = 0; i < 4; i++ )
2124             {
2125                 int costs[4] = {a->l0.i_cost4x4[i], a->l0.i_cost8x4[i], a->l0.i_cost4x8[i], a->l0.me8x8[i].cost};
2126                 int thresh = X264_MIN4( costs[0], costs[1], costs[2], costs[3] ) * 5 / 4;
2127                 int subtype, btype = D_L0_8x8;
2128                 uint64_t bcost = COST_MAX64;
2129                 for( subtype = D_L0_4x4; subtype <= D_L0_8x8; subtype++ )
2130                 {
2131                     uint64_t cost;
2132                     if( costs[subtype] > thresh || (subtype == D_L0_8x8 && bcost == COST_MAX64) )
2133                         continue;
2134                     h->mb.i_sub_partition[i] = subtype;
2135                     x264_mb_cache_mv_p8x8( h, a, i );
2136                     cost = x264_rd_cost_part( h, a->i_lambda2, i<<2, PIXEL_8x8 );
2137                     COPY2_IF_LT( bcost, cost, btype, subtype );
2138                 }
2139                 if( h->mb.i_sub_partition[i] != btype )
2140                 {
2141                     h->mb.i_sub_partition[i] = btype;
2142                     x264_mb_cache_mv_p8x8( h, a, i );
2143                 }
2144             }
2145         }
2146         else
2147             x264_analyse_update_cache( h, a );
2148         a->l0.i_cost8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
2149     }
2150     else
2151         a->l0.i_cost8x8 = COST_MAX;
2152 }
2153
2154 static void x264_mb_analyse_b_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd_inter )
2155 {
2156     int thresh = i_satd_inter * (17 + (!!h->mb.i_psy_rd))/16;
2157
2158     if( a->b_direct_available && a->i_rd16x16direct == COST_MAX )
2159     {
2160         h->mb.i_type = B_DIRECT;
2161         /* Assumes direct/skip MC is still in fdec */
2162         /* Requires b-rdo to be done before intra analysis */
2163         h->mb.b_skip_mc = 1;
2164         x264_analyse_update_cache( h, a );
2165         a->i_rd16x16direct = x264_rd_cost_mb( h, a->i_lambda2 );
2166         h->mb.b_skip_mc = 0;
2167     }
2168
2169     //FIXME not all the update_cache calls are needed
2170     h->mb.i_partition = D_16x16;
2171     /* L0 */
2172     if( a->l0.me16x16.cost <= thresh && a->l0.i_rd16x16 == COST_MAX )
2173     {
2174         h->mb.i_type = B_L0_L0;
2175         x264_analyse_update_cache( h, a );
2176         a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
2177     }
2178
2179     /* L1 */
2180     if( a->l1.me16x16.cost <= thresh && a->l1.i_rd16x16 == COST_MAX )
2181     {
2182         h->mb.i_type = B_L1_L1;
2183         x264_analyse_update_cache( h, a );
2184         a->l1.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
2185     }
2186
2187     /* BI */
2188     if( a->i_cost16x16bi <= thresh && a->i_rd16x16bi == COST_MAX )
2189     {
2190         h->mb.i_type = B_BI_BI;
2191         x264_analyse_update_cache( h, a );
2192         a->i_rd16x16bi = x264_rd_cost_mb( h, a->i_lambda2 );
2193     }
2194
2195     /* 8x8 */
2196     if( a->i_cost8x8bi <= thresh && a->i_rd8x8bi == COST_MAX )
2197     {
2198         h->mb.i_type = B_8x8;
2199         h->mb.i_partition = D_8x8;
2200         x264_analyse_update_cache( h, a );
2201         a->i_rd8x8bi = x264_rd_cost_mb( h, a->i_lambda2 );
2202         x264_macroblock_cache_skip( h, 0, 0, 4, 4, 0 );
2203     }
2204
2205     /* 16x8 */
2206     if( a->i_cost16x8bi <= thresh && a->i_rd16x8bi == COST_MAX )
2207     {
2208         h->mb.i_type = a->i_mb_type16x8;
2209         h->mb.i_partition = D_16x8;
2210         x264_analyse_update_cache( h, a );
2211         a->i_rd16x8bi = x264_rd_cost_mb( h, a->i_lambda2 );
2212     }
2213
2214     /* 8x16 */
2215     if( a->i_cost8x16bi <= thresh && a->i_rd8x16bi == COST_MAX )
2216     {
2217         h->mb.i_type = a->i_mb_type8x16;
2218         h->mb.i_partition = D_8x16;
2219         x264_analyse_update_cache( h, a );
2220         a->i_rd8x16bi = x264_rd_cost_mb( h, a->i_lambda2 );
2221     }
2222 }
2223
2224 static void x264_refine_bidir( x264_t *h, x264_mb_analysis_t *a )
2225 {
2226     const int i_biweight = h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref];
2227     int i;
2228
2229     if( IS_INTRA(h->mb.i_type) )
2230         return;
2231
2232     switch( h->mb.i_partition )
2233     {
2234         case D_16x16:
2235             if( h->mb.i_type == B_BI_BI )
2236                 x264_me_refine_bidir_satd( h, &a->l0.bi16x16, &a->l1.bi16x16, i_biweight );
2237             break;
2238         case D_16x8:
2239             for( i=0; i<2; i++ )
2240                 if( a->i_mb_partition16x8[i] == D_BI_8x8 )
2241                     x264_me_refine_bidir_satd( h, &a->l0.me16x8[i], &a->l1.me16x8[i], i_biweight );
2242             break;
2243         case D_8x16:
2244             for( i=0; i<2; i++ )
2245                 if( a->i_mb_partition8x16[i] == D_BI_8x8 )
2246                     x264_me_refine_bidir_satd( h, &a->l0.me8x16[i], &a->l1.me8x16[i], i_biweight );
2247             break;
2248         case D_8x8:
2249             for( i=0; i<4; i++ )
2250                 if( h->mb.i_sub_partition[i] == D_BI_8x8 )
2251                     x264_me_refine_bidir_satd( h, &a->l0.me8x8[i], &a->l1.me8x8[i], i_biweight );
2252             break;
2253     }
2254 }
2255
2256 static inline void x264_mb_analyse_transform( x264_t *h )
2257 {
2258     if( x264_mb_transform_8x8_allowed( h ) && h->param.analyse.b_transform_8x8 && !h->mb.b_lossless )
2259     {
2260         int i_cost4, i_cost8;
2261         /* Only luma MC is really needed, but the full MC is re-used in macroblock_encode. */
2262         x264_mb_mc( h );
2263
2264         i_cost8 = h->pixf.sa8d[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE,
2265                                              h->mb.pic.p_fdec[0], FDEC_STRIDE );
2266         i_cost4 = h->pixf.satd[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE,
2267                                              h->mb.pic.p_fdec[0], FDEC_STRIDE );
2268
2269         h->mb.b_transform_8x8 = i_cost8 < i_cost4;
2270         h->mb.b_skip_mc = 1;
2271     }
2272 }
2273
2274 static inline void x264_mb_analyse_transform_rd( x264_t *h, x264_mb_analysis_t *a, int *i_satd, int *i_rd )
2275 {
2276     if( x264_mb_transform_8x8_allowed( h ) && h->param.analyse.b_transform_8x8 )
2277     {
2278         int i_rd8;
2279         x264_analyse_update_cache( h, a );
2280         h->mb.b_transform_8x8 ^= 1;
2281         /* FIXME only luma is needed, but the score for comparison already includes chroma */
2282         i_rd8 = x264_rd_cost_mb( h, a->i_lambda2 );
2283
2284         if( *i_rd >= i_rd8 )
2285         {
2286             if( *i_rd > 0 )
2287                 *i_satd = (int64_t)(*i_satd) * i_rd8 / *i_rd;
2288             *i_rd = i_rd8;
2289         }
2290         else
2291             h->mb.b_transform_8x8 ^= 1;
2292     }
2293 }
2294
2295 /* Rate-distortion optimal QP selection.
2296  * FIXME: More than half of the benefit of this function seems to be
2297  * in the way it improves the coding of chroma DC (by decimating or
2298  * finding a better way to code a single DC coefficient.)
2299  * There must be a more efficient way to get that portion of the benefit
2300  * without doing full QP-RD, but RD-decimation doesn't seem to do the
2301  * trick. */
2302 static inline void x264_mb_analyse_qp_rd( x264_t *h, x264_mb_analysis_t *a )
2303 {
2304     int bcost, cost, direction, failures, prevcost, origcost;
2305     int orig_qp = h->mb.i_qp, bqp = h->mb.i_qp;
2306     int last_qp_tried = 0;
2307     origcost = bcost = x264_rd_cost_mb( h, a->i_lambda2 );
2308
2309     /* If CBP is already zero, don't raise the quantizer any higher. */
2310     for( direction = h->mb.cbp[h->mb.i_mb_xy] ? 1 : -1; direction >= -1; direction-=2 )
2311     {
2312         /* Without psy-RD, require monotonicity when moving quant away from previous
2313          * macroblock's quant; allow 1 failure when moving quant towards previous quant.
2314          * With psy-RD, allow 1 failure when moving quant away from previous quant,
2315          * allow 2 failures when moving quant towards previous quant.
2316          * Psy-RD generally seems to result in more chaotic RD score-vs-quantizer curves. */
2317         int threshold = (!!h->mb.i_psy_rd);
2318         /* Raise the threshold for failures if we're moving towards the last QP. */
2319         if( ( h->mb.i_last_qp < orig_qp && direction == -1 ) ||
2320             ( h->mb.i_last_qp > orig_qp && direction ==  1 ) )
2321             threshold++;
2322         h->mb.i_qp = orig_qp;
2323         failures = 0;
2324         prevcost = origcost;
2325         h->mb.i_qp += direction;
2326         while( h->mb.i_qp >= h->param.rc.i_qp_min && h->mb.i_qp <= h->param.rc.i_qp_max )
2327         {
2328             if( h->mb.i_last_qp == h->mb.i_qp )
2329                 last_qp_tried = 1;
2330             h->mb.i_chroma_qp = h->chroma_qp_table[h->mb.i_qp];
2331             cost = x264_rd_cost_mb( h, a->i_lambda2 );
2332             COPY2_IF_LT( bcost, cost, bqp, h->mb.i_qp );
2333
2334             /* We can't assume that the costs are monotonic over QPs.
2335              * Tie case-as-failure seems to give better results. */
2336             if( cost < prevcost )
2337                 failures = 0;
2338             else
2339                 failures++;
2340             prevcost = cost;
2341
2342             if( failures > threshold )
2343                 break;
2344             if( direction == 1 && !h->mb.cbp[h->mb.i_mb_xy] )
2345                 break;
2346             h->mb.i_qp += direction;
2347         }
2348     }
2349
2350     /* Always try the last block's QP. */
2351     if( !last_qp_tried )
2352     {
2353         h->mb.i_qp = h->mb.i_last_qp;
2354         h->mb.i_chroma_qp = h->chroma_qp_table[h->mb.i_qp];
2355         cost = x264_rd_cost_mb( h, a->i_lambda2 );
2356         COPY2_IF_LT( bcost, cost, bqp, h->mb.i_qp );
2357     }
2358
2359     h->mb.i_qp = bqp;
2360     h->mb.i_chroma_qp = h->chroma_qp_table[h->mb.i_qp];
2361
2362     /* Check transform again; decision from before may no longer be optimal. */
2363     if( h->mb.i_qp != orig_qp && h->param.analyse.b_transform_8x8 &&
2364         x264_mb_transform_8x8_allowed( h ) )
2365     {
2366         h->mb.b_transform_8x8 ^= 1;
2367         cost = x264_rd_cost_mb( h, a->i_lambda2 );
2368         if( cost > bcost )
2369             h->mb.b_transform_8x8 ^= 1;
2370     }
2371 }
2372
2373 /*****************************************************************************
2374  * x264_macroblock_analyse:
2375  *****************************************************************************/
2376 void x264_macroblock_analyse( x264_t *h )
2377 {
2378     x264_mb_analysis_t analysis;
2379     int i_cost = COST_MAX;
2380     int i;
2381
2382     h->mb.i_qp = x264_ratecontrol_qp( h );
2383     if( h->param.rc.i_aq_mode )
2384     {
2385         x264_adaptive_quant( h );
2386         /* If the QP of this MB is within 1 of the previous MB, code the same QP as the previous MB,
2387          * to lower the bit cost of the qp_delta.  Don't do this if QPRD is enabled. */
2388         if( h->param.analyse.i_subpel_refine < 10 && abs(h->mb.i_qp - h->mb.i_last_qp) == 1 )
2389             h->mb.i_qp = h->mb.i_last_qp;
2390     }
2391
2392     x264_mb_analyse_init( h, &analysis, h->mb.i_qp );
2393
2394     /*--------------------------- Do the analysis ---------------------------*/
2395     if( h->sh.i_type == SLICE_TYPE_I )
2396     {
2397 intra_analysis:
2398         if( analysis.i_mbrd )
2399             x264_mb_cache_fenc_satd( h );
2400         x264_mb_analyse_intra( h, &analysis, COST_MAX );
2401         if( analysis.i_mbrd )
2402             x264_intra_rd( h, &analysis, COST_MAX );
2403
2404         i_cost = analysis.i_satd_i16x16;
2405         h->mb.i_type = I_16x16;
2406         COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, h->mb.i_type, I_4x4 );
2407         COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, h->mb.i_type, I_8x8 );
2408         if( analysis.i_satd_pcm < i_cost )
2409             h->mb.i_type = I_PCM;
2410
2411         else if( analysis.i_mbrd >= 2 )
2412             x264_intra_rd_refine( h, &analysis );
2413     }
2414     else if( h->sh.i_type == SLICE_TYPE_P )
2415     {
2416         int b_skip = 0;
2417
2418         h->mc.prefetch_ref( h->mb.pic.p_fref[0][0][h->mb.i_mb_x&3], h->mb.pic.i_stride[0], 0 );
2419
2420         analysis.b_try_pskip = 0;
2421         if( analysis.b_force_intra )
2422         {
2423             if( !h->param.analyse.b_psy )
2424             {
2425                 x264_mb_analyse_init_qp( h, &analysis, X264_MAX( h->mb.i_qp - h->mb.ip_offset, h->param.rc.i_qp_min ) );
2426                 goto intra_analysis;
2427             }
2428         }
2429         else
2430         {
2431             /* Fast P_SKIP detection */
2432             if( h->param.analyse.b_fast_pskip )
2433             {
2434                 if( h->i_thread_frames > 1 && h->mb.cache.pskip_mv[1] > h->mb.mv_max_spel[1] )
2435                     // FIXME don't need to check this if the reference frame is done
2436                     {}
2437                 else if( h->param.analyse.i_subpel_refine >= 3 )
2438                     analysis.b_try_pskip = 1;
2439                 else if( h->mb.i_mb_type_left == P_SKIP ||
2440                          h->mb.i_mb_type_top == P_SKIP ||
2441                          h->mb.i_mb_type_topleft == P_SKIP ||
2442                          h->mb.i_mb_type_topright == P_SKIP )
2443                     b_skip = x264_macroblock_probe_pskip( h );
2444             }
2445         }
2446
2447         h->mc.prefetch_ref( h->mb.pic.p_fref[0][0][h->mb.i_mb_x&3], h->mb.pic.i_stride[0], 1 );
2448
2449         if( b_skip )
2450         {
2451             h->mb.i_type = P_SKIP;
2452             h->mb.i_partition = D_16x16;
2453             assert( h->mb.cache.pskip_mv[1] <= h->mb.mv_max_spel[1] || h->i_thread_frames == 1 );
2454         }
2455         else
2456         {
2457             const unsigned int flags = h->param.analyse.inter;
2458             int i_type;
2459             int i_partition;
2460             int i_thresh16x8;
2461             int i_satd_inter, i_satd_intra;
2462
2463             x264_mb_analyse_load_costs( h, &analysis );
2464
2465             x264_mb_analyse_inter_p16x16( h, &analysis );
2466
2467             if( h->mb.i_type == P_SKIP )
2468                 return;
2469
2470             if( flags & X264_ANALYSE_PSUB16x16 )
2471             {
2472                 if( h->param.analyse.b_mixed_references )
2473                     x264_mb_analyse_inter_p8x8_mixed_ref( h, &analysis );
2474                 else
2475                     x264_mb_analyse_inter_p8x8( h, &analysis );
2476             }
2477
2478             /* Select best inter mode */
2479             i_type = P_L0;
2480             i_partition = D_16x16;
2481             i_cost = analysis.l0.me16x16.cost;
2482
2483             if( ( flags & X264_ANALYSE_PSUB16x16 ) &&
2484                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost )
2485             {
2486                 i_type = P_8x8;
2487                 i_partition = D_8x8;
2488                 i_cost = analysis.l0.i_cost8x8;
2489
2490                 /* Do sub 8x8 */
2491                 if( flags & X264_ANALYSE_PSUB8x8 )
2492                 {
2493                     for( i = 0; i < 4; i++ )
2494                     {
2495                         x264_mb_analyse_inter_p4x4( h, &analysis, i );
2496                         if( analysis.l0.i_cost4x4[i] < analysis.l0.me8x8[i].cost )
2497                         {
2498                             int i_cost8x8 = analysis.l0.i_cost4x4[i];
2499                             h->mb.i_sub_partition[i] = D_L0_4x4;
2500
2501                             x264_mb_analyse_inter_p8x4( h, &analysis, i );
2502                             COPY2_IF_LT( i_cost8x8, analysis.l0.i_cost8x4[i],
2503                                          h->mb.i_sub_partition[i], D_L0_8x4 );
2504
2505                             x264_mb_analyse_inter_p4x8( h, &analysis, i );
2506                             COPY2_IF_LT( i_cost8x8, analysis.l0.i_cost4x8[i],
2507                                          h->mb.i_sub_partition[i], D_L0_4x8 );
2508
2509                             i_cost += i_cost8x8 - analysis.l0.me8x8[i].cost;
2510                         }
2511                         x264_mb_cache_mv_p8x8( h, &analysis, i );
2512                     }
2513                     analysis.l0.i_cost8x8 = i_cost;
2514                 }
2515             }
2516
2517             /* Now do 16x8/8x16 */
2518             i_thresh16x8 = analysis.l0.me8x8[1].cost_mv + analysis.l0.me8x8[2].cost_mv;
2519             if( ( flags & X264_ANALYSE_PSUB16x16 ) &&
2520                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost + i_thresh16x8 )
2521             {
2522                 x264_mb_analyse_inter_p16x8( h, &analysis );
2523                 COPY3_IF_LT( i_cost, analysis.l0.i_cost16x8, i_type, P_L0, i_partition, D_16x8 );
2524
2525                 x264_mb_analyse_inter_p8x16( h, &analysis );
2526                 COPY3_IF_LT( i_cost, analysis.l0.i_cost8x16, i_type, P_L0, i_partition, D_8x16 );
2527             }
2528
2529             h->mb.i_partition = i_partition;
2530
2531             /* refine qpel */
2532             //FIXME mb_type costs?
2533             if( analysis.i_mbrd || !h->mb.i_subpel_refine )
2534             {
2535                 /* refine later */
2536             }
2537             else if( i_partition == D_16x16 )
2538             {
2539                 x264_me_refine_qpel( h, &analysis.l0.me16x16 );
2540                 i_cost = analysis.l0.me16x16.cost;
2541             }
2542             else if( i_partition == D_16x8 )
2543             {
2544                 x264_me_refine_qpel( h, &analysis.l0.me16x8[0] );
2545                 x264_me_refine_qpel( h, &analysis.l0.me16x8[1] );
2546                 i_cost = analysis.l0.me16x8[0].cost + analysis.l0.me16x8[1].cost;
2547             }
2548             else if( i_partition == D_8x16 )
2549             {
2550                 x264_me_refine_qpel( h, &analysis.l0.me8x16[0] );
2551                 x264_me_refine_qpel( h, &analysis.l0.me8x16[1] );
2552                 i_cost = analysis.l0.me8x16[0].cost + analysis.l0.me8x16[1].cost;
2553             }
2554             else if( i_partition == D_8x8 )
2555             {
2556                 int i8x8;
2557                 i_cost = 0;
2558                 for( i8x8 = 0; i8x8 < 4; i8x8++ )
2559                 {
2560                     switch( h->mb.i_sub_partition[i8x8] )
2561                     {
2562                         case D_L0_8x8:
2563                             x264_me_refine_qpel( h, &analysis.l0.me8x8[i8x8] );
2564                             i_cost += analysis.l0.me8x8[i8x8].cost;
2565                             break;
2566                         case D_L0_8x4:
2567                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][0] );
2568                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][1] );
2569                             i_cost += analysis.l0.me8x4[i8x8][0].cost +
2570                                       analysis.l0.me8x4[i8x8][1].cost;
2571                             break;
2572                         case D_L0_4x8:
2573                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][0] );
2574                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][1] );
2575                             i_cost += analysis.l0.me4x8[i8x8][0].cost +
2576                                       analysis.l0.me4x8[i8x8][1].cost;
2577                             break;
2578
2579                         case D_L0_4x4:
2580                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][0] );
2581                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][1] );
2582                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][2] );
2583                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][3] );
2584                             i_cost += analysis.l0.me4x4[i8x8][0].cost +
2585                                       analysis.l0.me4x4[i8x8][1].cost +
2586                                       analysis.l0.me4x4[i8x8][2].cost +
2587                                       analysis.l0.me4x4[i8x8][3].cost;
2588                             break;
2589                         default:
2590                             x264_log( h, X264_LOG_ERROR, "internal error (!8x8 && !4x4)\n" );
2591                             break;
2592                     }
2593                 }
2594             }
2595
2596             if( h->mb.b_chroma_me )
2597             {
2598                 x264_mb_analyse_intra_chroma( h, &analysis );
2599                 x264_mb_analyse_intra( h, &analysis, i_cost - analysis.i_satd_i8x8chroma );
2600                 analysis.i_satd_i16x16 += analysis.i_satd_i8x8chroma;
2601                 analysis.i_satd_i8x8 += analysis.i_satd_i8x8chroma;
2602                 analysis.i_satd_i4x4 += analysis.i_satd_i8x8chroma;
2603             }
2604             else
2605                 x264_mb_analyse_intra( h, &analysis, i_cost );
2606
2607             i_satd_inter = i_cost;
2608             i_satd_intra = X264_MIN3( analysis.i_satd_i16x16,
2609                                       analysis.i_satd_i8x8,
2610                                       analysis.i_satd_i4x4 );
2611
2612             if( analysis.i_mbrd )
2613             {
2614                 x264_mb_analyse_p_rd( h, &analysis, X264_MIN(i_satd_inter, i_satd_intra) );
2615                 i_type = P_L0;
2616                 i_partition = D_16x16;
2617                 i_cost = analysis.l0.i_rd16x16;
2618                 COPY2_IF_LT( i_cost, analysis.l0.i_cost16x8, i_partition, D_16x8 );
2619                 COPY2_IF_LT( i_cost, analysis.l0.i_cost8x16, i_partition, D_8x16 );
2620                 COPY3_IF_LT( i_cost, analysis.l0.i_cost8x8, i_partition, D_8x8, i_type, P_8x8 );
2621                 h->mb.i_type = i_type;
2622                 h->mb.i_partition = i_partition;
2623                 if( i_cost < COST_MAX )
2624                     x264_mb_analyse_transform_rd( h, &analysis, &i_satd_inter, &i_cost );
2625                 x264_intra_rd( h, &analysis, i_satd_inter * 5/4 );
2626             }
2627
2628             COPY2_IF_LT( i_cost, analysis.i_satd_i16x16, i_type, I_16x16 );
2629             COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, i_type, I_8x8 );
2630             COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, i_type, I_4x4 );
2631             COPY2_IF_LT( i_cost, analysis.i_satd_pcm, i_type, I_PCM );
2632
2633             h->mb.i_type = i_type;
2634
2635             if( analysis.b_force_intra && !IS_INTRA(i_type) )
2636             {
2637                 /* Intra masking: copy fdec to fenc and re-encode the block as intra in order to make it appear as if
2638                  * it was an inter block. */
2639                 x264_analyse_update_cache( h, &analysis );
2640                 x264_macroblock_encode( h );
2641                 h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE, h->mb.pic.p_fdec[0], FDEC_STRIDE, 16 );
2642                 h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fenc[1], FENC_STRIDE, h->mb.pic.p_fdec[1], FDEC_STRIDE, 8 );
2643                 h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fenc[2], FENC_STRIDE, h->mb.pic.p_fdec[2], FDEC_STRIDE, 8 );
2644                 x264_mb_analyse_init_qp( h, &analysis, X264_MAX( h->mb.i_qp - h->mb.ip_offset, h->param.rc.i_qp_min ) );
2645                 goto intra_analysis;
2646             }
2647
2648             if( analysis.i_mbrd >= 2 && h->mb.i_type != I_PCM )
2649             {
2650                 if( IS_INTRA( h->mb.i_type ) )
2651                 {
2652                     x264_intra_rd_refine( h, &analysis );
2653                 }
2654                 else if( i_partition == D_16x16 )
2655                 {
2656                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.i_ref );
2657                     analysis.l0.me16x16.cost = i_cost;
2658                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x16, analysis.i_lambda2, 0, 0 );
2659                 }
2660                 else if( i_partition == D_16x8 )
2661                 {
2662                     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
2663                     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
2664                     x264_macroblock_cache_ref( h, 0, 0, 4, 2, 0, analysis.l0.me16x8[0].i_ref );
2665                     x264_macroblock_cache_ref( h, 0, 2, 4, 2, 0, analysis.l0.me16x8[1].i_ref );
2666                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[0], analysis.i_lambda2, 0, 0 );
2667                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[1], analysis.i_lambda2, 8, 0 );
2668                 }
2669                 else if( i_partition == D_8x16 )
2670                 {
2671                     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
2672                     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
2673                     x264_macroblock_cache_ref( h, 0, 0, 2, 4, 0, analysis.l0.me8x16[0].i_ref );
2674                     x264_macroblock_cache_ref( h, 2, 0, 2, 4, 0, analysis.l0.me8x16[1].i_ref );
2675                     x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[0], analysis.i_lambda2, 0, 0 );
2676                     x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[1], analysis.i_lambda2, 4, 0 );
2677                 }
2678                 else if( i_partition == D_8x8 )
2679                 {
2680                     int i8x8;
2681                     x264_analyse_update_cache( h, &analysis );
2682                     for( i8x8 = 0; i8x8 < 4; i8x8++ )
2683                     {
2684                         if( h->mb.i_sub_partition[i8x8] == D_L0_8x8 )
2685                         {
2686                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x8[i8x8], analysis.i_lambda2, i8x8*4, 0 );
2687                         }
2688                         else if( h->mb.i_sub_partition[i8x8] == D_L0_8x4 )
2689                         {
2690                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x4[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
2691                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x4[i8x8][1], analysis.i_lambda2, i8x8*4+2, 0 );
2692                         }
2693                         else if( h->mb.i_sub_partition[i8x8] == D_L0_4x8 )
2694                         {
2695                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x8[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
2696                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x8[i8x8][1], analysis.i_lambda2, i8x8*4+1, 0 );
2697                         }
2698                         else if( h->mb.i_sub_partition[i8x8] == D_L0_4x4 )
2699                         {
2700                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
2701                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][1], analysis.i_lambda2, i8x8*4+1, 0 );
2702                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][2], analysis.i_lambda2, i8x8*4+2, 0 );
2703                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][3], analysis.i_lambda2, i8x8*4+3, 0 );
2704                         }
2705                     }
2706                 }
2707             }
2708         }
2709     }
2710     else if( h->sh.i_type == SLICE_TYPE_B )
2711     {
2712         int i_bskip_cost = COST_MAX;
2713         int b_skip = 0;
2714
2715         if( analysis.i_mbrd )
2716             x264_mb_cache_fenc_satd( h );
2717
2718         h->mb.i_type = B_SKIP;
2719         if( h->mb.b_direct_auto_write )
2720         {
2721             /* direct=auto heuristic: prefer whichever mode allows more Skip macroblocks */
2722             for( i = 0; i < 2; i++ )
2723             {
2724                 int b_changed = 1;
2725                 h->sh.b_direct_spatial_mv_pred ^= 1;
2726                 analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h, i && analysis.b_direct_available ? &b_changed : NULL );
2727                 if( analysis.b_direct_available )
2728                 {
2729                     if( b_changed )
2730                     {
2731                         x264_mb_mc( h );
2732                         b_skip = x264_macroblock_probe_bskip( h );
2733                     }
2734                     h->stat.frame.i_direct_score[ h->sh.b_direct_spatial_mv_pred ] += b_skip;
2735                 }
2736                 else
2737                     b_skip = 0;
2738             }
2739         }
2740         else
2741             analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h, NULL );
2742
2743         if( analysis.b_direct_available )
2744         {
2745             if( !h->mb.b_direct_auto_write )
2746                 x264_mb_mc( h );
2747             if( analysis.i_mbrd )
2748             {
2749                 i_bskip_cost = ssd_mb( h );
2750                 /* 6 = minimum cavlc cost of a non-skipped MB */
2751                 b_skip = h->mb.b_skip_mc = i_bskip_cost <= ((6 * analysis.i_lambda2 + 128) >> 8);
2752             }
2753             else if( !h->mb.b_direct_auto_write )
2754             {
2755                 /* Conditioning the probe on neighboring block types
2756                  * doesn't seem to help speed or quality. */
2757                 b_skip = x264_macroblock_probe_bskip( h );
2758             }
2759         }
2760
2761         if( !b_skip )
2762         {
2763             const unsigned int flags = h->param.analyse.inter;
2764             int i_type;
2765             int i_partition;
2766             int i_satd_inter;
2767             h->mb.b_skip_mc = 0;
2768
2769             x264_mb_analyse_load_costs( h, &analysis );
2770
2771             /* select best inter mode */
2772             /* direct must be first */
2773             if( analysis.b_direct_available )
2774                 x264_mb_analyse_inter_direct( h, &analysis );
2775
2776             x264_mb_analyse_inter_b16x16( h, &analysis );
2777
2778             i_type = B_L0_L0;
2779             i_partition = D_16x16;
2780             i_cost = analysis.l0.me16x16.cost;
2781             COPY2_IF_LT( i_cost, analysis.l1.me16x16.cost, i_type, B_L1_L1 );
2782             COPY2_IF_LT( i_cost, analysis.i_cost16x16bi, i_type, B_BI_BI );
2783             COPY2_IF_LT( i_cost, analysis.i_cost16x16direct, i_type, B_DIRECT );
2784
2785             if( analysis.i_mbrd && analysis.i_cost16x16direct <= i_cost * 33/32 )
2786             {
2787                 x264_mb_analyse_b_rd( h, &analysis, i_cost );
2788                 if( i_bskip_cost < analysis.i_rd16x16direct &&
2789                     i_bskip_cost < analysis.i_rd16x16bi &&
2790                     i_bskip_cost < analysis.l0.i_rd16x16 &&
2791                     i_bskip_cost < analysis.l1.i_rd16x16 )
2792                 {
2793                     h->mb.i_type = B_SKIP;
2794                     x264_analyse_update_cache( h, &analysis );
2795                     return;
2796                 }
2797             }
2798
2799             if( flags & X264_ANALYSE_BSUB16x16 )
2800             {
2801                 x264_mb_analyse_inter_b8x8( h, &analysis );
2802                 if( analysis.i_cost8x8bi < i_cost )
2803                 {
2804                     i_type = B_8x8;
2805                     i_partition = D_8x8;
2806                     i_cost = analysis.i_cost8x8bi;
2807
2808                     if( h->mb.i_sub_partition[0] == h->mb.i_sub_partition[1] ||
2809                         h->mb.i_sub_partition[2] == h->mb.i_sub_partition[3] )
2810                     {
2811                         x264_mb_analyse_inter_b16x8( h, &analysis );
2812                         COPY3_IF_LT( i_cost, analysis.i_cost16x8bi,
2813                                      i_type, analysis.i_mb_type16x8,
2814                                      i_partition, D_16x8 );
2815                     }
2816                     if( h->mb.i_sub_partition[0] == h->mb.i_sub_partition[2] ||
2817                         h->mb.i_sub_partition[1] == h->mb.i_sub_partition[3] )
2818                     {
2819                         x264_mb_analyse_inter_b8x16( h, &analysis );
2820                         COPY3_IF_LT( i_cost, analysis.i_cost8x16bi,
2821                                      i_type, analysis.i_mb_type8x16,
2822                                      i_partition, D_8x16 );
2823                     }
2824                 }
2825             }
2826
2827             if( analysis.i_mbrd || !h->mb.i_subpel_refine )
2828             {
2829                 /* refine later */
2830             }
2831             /* refine qpel */
2832             else if( i_partition == D_16x16 )
2833             {
2834                 analysis.l0.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
2835                 analysis.l1.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
2836                 if( i_type == B_L0_L0 )
2837                 {
2838                     x264_me_refine_qpel( h, &analysis.l0.me16x16 );
2839                     i_cost = analysis.l0.me16x16.cost
2840                            + analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
2841                 }
2842                 else if( i_type == B_L1_L1 )
2843                 {
2844                     x264_me_refine_qpel( h, &analysis.l1.me16x16 );
2845                     i_cost = analysis.l1.me16x16.cost
2846                            + analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
2847                 }
2848                 else if( i_type == B_BI_BI )
2849                 {
2850                     x264_me_refine_qpel( h, &analysis.l0.bi16x16 );
2851                     x264_me_refine_qpel( h, &analysis.l1.bi16x16 );
2852                 }
2853             }
2854             else if( i_partition == D_16x8 )
2855             {
2856                 for( i=0; i<2; i++ )
2857                 {
2858                     if( analysis.i_mb_partition16x8[i] != D_L1_8x8 )
2859                         x264_me_refine_qpel( h, &analysis.l0.me16x8[i] );
2860                     if( analysis.i_mb_partition16x8[i] != D_L0_8x8 )
2861                         x264_me_refine_qpel( h, &analysis.l1.me16x8[i] );
2862                 }
2863             }
2864             else if( i_partition == D_8x16 )
2865             {
2866                 for( i=0; i<2; i++ )
2867                 {
2868                     if( analysis.i_mb_partition8x16[i] != D_L1_8x8 )
2869                         x264_me_refine_qpel( h, &analysis.l0.me8x16[i] );
2870                     if( analysis.i_mb_partition8x16[i] != D_L0_8x8 )
2871                         x264_me_refine_qpel( h, &analysis.l1.me8x16[i] );
2872                 }
2873             }
2874             else if( i_partition == D_8x8 )
2875             {
2876                 for( i=0; i<4; i++ )
2877                 {
2878                     x264_me_t *m;
2879                     int i_part_cost_old;
2880                     int i_type_cost;
2881                     int i_part_type = h->mb.i_sub_partition[i];
2882                     int b_bidir = (i_part_type == D_BI_8x8);
2883
2884                     if( i_part_type == D_DIRECT_8x8 )
2885                         continue;
2886                     if( x264_mb_partition_listX_table[0][i_part_type] )
2887                     {
2888                         m = &analysis.l0.me8x8[i];
2889                         i_part_cost_old = m->cost;
2890                         i_type_cost = analysis.i_lambda * i_sub_mb_b_cost_table[D_L0_8x8];
2891                         m->cost -= i_type_cost;
2892                         x264_me_refine_qpel( h, m );
2893                         if( !b_bidir )
2894                             analysis.i_cost8x8bi += m->cost + i_type_cost - i_part_cost_old;
2895                     }
2896                     if( x264_mb_partition_listX_table[1][i_part_type] )
2897                     {
2898                         m = &analysis.l1.me8x8[i];
2899                         i_part_cost_old = m->cost;
2900                         i_type_cost = analysis.i_lambda * i_sub_mb_b_cost_table[D_L1_8x8];
2901                         m->cost -= i_type_cost;
2902                         x264_me_refine_qpel( h, m );
2903                         if( !b_bidir )
2904                             analysis.i_cost8x8bi += m->cost + i_type_cost - i_part_cost_old;
2905                     }
2906                     /* TODO: update mvp? */
2907                 }
2908             }
2909
2910             i_satd_inter = i_cost;
2911
2912             if( analysis.i_mbrd )
2913             {
2914                 x264_mb_analyse_b_rd( h, &analysis, i_satd_inter );
2915                 i_type = B_SKIP;
2916                 i_cost = i_bskip_cost;
2917                 i_partition = D_16x16;
2918                 COPY2_IF_LT( i_cost, analysis.l0.i_rd16x16, i_type, B_L0_L0 );
2919                 COPY2_IF_LT( i_cost, analysis.l1.i_rd16x16, i_type, B_L1_L1 );
2920                 COPY2_IF_LT( i_cost, analysis.i_rd16x16bi, i_type, B_BI_BI );
2921                 COPY2_IF_LT( i_cost, analysis.i_rd16x16direct, i_type, B_DIRECT );
2922                 COPY3_IF_LT( i_cost, analysis.i_rd16x8bi, i_type, analysis.i_mb_type16x8, i_partition, D_16x8 );
2923                 COPY3_IF_LT( i_cost, analysis.i_rd8x16bi, i_type, analysis.i_mb_type8x16, i_partition, D_8x16 );
2924                 COPY3_IF_LT( i_cost, analysis.i_rd8x8bi, i_type, B_8x8, i_partition, D_8x8 );
2925
2926                 h->mb.i_type = i_type;
2927                 h->mb.i_partition = i_partition;
2928             }
2929
2930             x264_mb_analyse_intra( h, &analysis, i_satd_inter );
2931
2932             if( analysis.i_mbrd )
2933             {
2934                 x264_mb_analyse_transform_rd( h, &analysis, &i_satd_inter, &i_cost );
2935                 x264_intra_rd( h, &analysis, i_satd_inter * 17/16 );
2936             }
2937
2938             COPY2_IF_LT( i_cost, analysis.i_satd_i16x16, i_type, I_16x16 );
2939             COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, i_type, I_8x8 );
2940             COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, i_type, I_4x4 );
2941             COPY2_IF_LT( i_cost, analysis.i_satd_pcm, i_type, I_PCM );
2942
2943             h->mb.i_type = i_type;
2944             h->mb.i_partition = i_partition;
2945
2946             if( analysis.i_mbrd >= 2 && IS_INTRA( i_type ) && i_type != I_PCM )
2947                 x264_intra_rd_refine( h, &analysis );
2948             if( h->mb.i_subpel_refine >= 5 )
2949                 x264_refine_bidir( h, &analysis );
2950
2951             if( analysis.i_mbrd >= 2 && i_type > B_DIRECT && i_type < B_SKIP )
2952             {
2953                 const int i_biweight = h->mb.bipred_weight[analysis.l0.i_ref][analysis.l1.i_ref];
2954                 x264_analyse_update_cache( h, &analysis );
2955
2956                 if( i_partition == D_16x16 )
2957                 {
2958                     if( i_type == B_L0_L0 )
2959                     {
2960                         analysis.l0.me16x16.cost = i_cost;
2961                         x264_me_refine_qpel_rd( h, &analysis.l0.me16x16, analysis.i_lambda2, 0, 0 );
2962                     }
2963                     else if( i_type == B_L1_L1 )
2964                     {
2965                         analysis.l1.me16x16.cost = i_cost;
2966                         x264_me_refine_qpel_rd( h, &analysis.l1.me16x16, analysis.i_lambda2, 0, 1 );
2967                     }
2968                     else if( i_type == B_BI_BI )
2969                         x264_me_refine_bidir_rd( h, &analysis.l0.bi16x16, &analysis.l1.bi16x16, i_biweight, 0, analysis.i_lambda2 );
2970                 }
2971                 else if( i_partition == D_16x8 )
2972                 {
2973                     for( i = 0; i < 2; i++ )
2974                     {
2975                         h->mb.i_sub_partition[i*2] = h->mb.i_sub_partition[i*2+1] = analysis.i_mb_partition16x8[i];
2976                         if( analysis.i_mb_partition16x8[i] == D_L0_8x8 )
2977                             x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[i], analysis.i_lambda2, i*8, 0 );
2978                         else if( analysis.i_mb_partition16x8[i] == D_L1_8x8 )
2979                             x264_me_refine_qpel_rd( h, &analysis.l1.me16x8[i], analysis.i_lambda2, i*8, 1 );
2980                         else if( analysis.i_mb_partition16x8[i] == D_BI_8x8 )
2981                             x264_me_refine_bidir_rd( h, &analysis.l0.me16x8[i], &analysis.l1.me16x8[i], i_biweight, i*2, analysis.i_lambda2 );
2982                     }
2983                 }
2984                 else if( i_partition == D_8x16 )
2985                 {
2986                     for( i = 0; i < 2; i++ )
2987                     {
2988                         h->mb.i_sub_partition[i] = h->mb.i_sub_partition[i+2] = analysis.i_mb_partition8x16[i];
2989                         if( analysis.i_mb_partition8x16[i] == D_L0_8x8 )
2990                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[i], analysis.i_lambda2, i*4, 0 );
2991                         else if( analysis.i_mb_partition8x16[i] == D_L1_8x8 )
2992                             x264_me_refine_qpel_rd( h, &analysis.l1.me8x16[i], analysis.i_lambda2, i*4, 1 );
2993                         else if( analysis.i_mb_partition8x16[i] == D_BI_8x8 )
2994                             x264_me_refine_bidir_rd( h, &analysis.l0.me8x16[i], &analysis.l1.me8x16[i], i_biweight, i, analysis.i_lambda2 );
2995                     }
2996                 }
2997                 else if( i_partition == D_8x8 )
2998                 {
2999                     for( i = 0; i < 4; i++ )
3000                     {
3001                         if( h->mb.i_sub_partition[i] == D_L0_8x8 )
3002                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x8[i], analysis.i_lambda2, i*4, 0 );
3003                         else if( h->mb.i_sub_partition[i] == D_L1_8x8 )
3004                             x264_me_refine_qpel_rd( h, &analysis.l1.me8x8[i], analysis.i_lambda2, i*4, 1 );
3005                         else if( h->mb.i_sub_partition[i] == D_BI_8x8 )
3006                             x264_me_refine_bidir_rd( h, &analysis.l0.me8x8[i], &analysis.l1.me8x8[i], i_biweight, i, analysis.i_lambda2 );
3007                     }
3008                 }
3009             }
3010         }
3011     }
3012
3013     x264_analyse_update_cache( h, &analysis );
3014
3015     /* In rare cases we can end up qpel-RDing our way back to a larger partition size
3016      * without realizing it.  Check for this and account for it if necessary. */
3017     if( analysis.i_mbrd >= 2 )
3018     {
3019         /* Don't bother with bipred or 8x8-and-below, the odds are incredibly low. */
3020         static const uint8_t check_mv_lists[X264_MBTYPE_MAX] = {[P_L0]=1, [B_L0_L0]=1, [B_L1_L1]=2};
3021         int list = check_mv_lists[h->mb.i_type] - 1;
3022         if( list >= 0 && h->mb.i_partition != D_16x16 &&
3023             M32( &h->mb.cache.mv[list][x264_scan8[0]] ) == M32( &h->mb.cache.mv[list][x264_scan8[12]] ) &&
3024             h->mb.cache.ref[list][x264_scan8[0]] == h->mb.cache.ref[list][x264_scan8[12]] )
3025                 h->mb.i_partition = D_16x16;
3026     }
3027
3028     if( !analysis.i_mbrd )
3029         x264_mb_analyse_transform( h );
3030
3031     if( analysis.i_mbrd == 3 && !IS_SKIP(h->mb.i_type) )
3032         x264_mb_analyse_qp_rd( h, &analysis );
3033
3034     h->mb.b_trellis = h->param.analyse.i_trellis;
3035     h->mb.b_noise_reduction = !!h->param.analyse.i_noise_reduction;
3036     if( !IS_SKIP(h->mb.i_type) && h->mb.i_psy_trellis && h->param.analyse.i_trellis == 1 )
3037         x264_psy_trellis_init( h, 0 );
3038     if( h->mb.b_trellis == 1 || h->mb.b_noise_reduction )
3039         h->mb.i_skip_intra = 0;
3040 }
3041
3042 /*-------------------- Update MB from the analysis ----------------------*/
3043 static void x264_analyse_update_cache( x264_t *h, x264_mb_analysis_t *a  )
3044 {
3045     int i;
3046
3047     switch( h->mb.i_type )
3048     {
3049         case I_4x4:
3050             for( i = 0; i < 16; i++ )
3051                 h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] = a->i_predict4x4[i];
3052
3053             x264_mb_analyse_intra_chroma( h, a );
3054             break;
3055         case I_8x8:
3056             for( i = 0; i < 4; i++ )
3057                 x264_macroblock_cache_intra8x8_pred( h, 2*(i&1), 2*(i>>1), a->i_predict8x8[i] );
3058
3059             x264_mb_analyse_intra_chroma( h, a );
3060             break;
3061         case I_16x16:
3062             h->mb.i_intra16x16_pred_mode = a->i_predict16x16;
3063             x264_mb_analyse_intra_chroma( h, a );
3064             break;
3065
3066         case I_PCM:
3067             break;
3068
3069         case P_L0:
3070             switch( h->mb.i_partition )
3071             {
3072                 case D_16x16:
3073                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.me16x16.i_ref );
3074                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
3075                     break;
3076
3077                 case D_16x8:
3078                     x264_macroblock_cache_ref( h, 0, 0, 4, 2, 0, a->l0.me16x8[0].i_ref );
3079                     x264_macroblock_cache_ref( h, 0, 2, 4, 2, 0, a->l0.me16x8[1].i_ref );
3080                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 2, 0, a->l0.me16x8[0].mv );
3081                     x264_macroblock_cache_mv_ptr( h, 0, 2, 4, 2, 0, a->l0.me16x8[1].mv );
3082                     break;
3083
3084                 case D_8x16:
3085                     x264_macroblock_cache_ref( h, 0, 0, 2, 4, 0, a->l0.me8x16[0].i_ref );
3086                     x264_macroblock_cache_ref( h, 2, 0, 2, 4, 0, a->l0.me8x16[1].i_ref );
3087                     x264_macroblock_cache_mv_ptr( h, 0, 0, 2, 4, 0, a->l0.me8x16[0].mv );
3088                     x264_macroblock_cache_mv_ptr( h, 2, 0, 2, 4, 0, a->l0.me8x16[1].mv );
3089                     break;
3090
3091                 default:
3092                     x264_log( h, X264_LOG_ERROR, "internal error P_L0 and partition=%d\n", h->mb.i_partition );
3093                     break;
3094             }
3095             break;
3096
3097         case P_8x8:
3098             x264_macroblock_cache_ref( h, 0, 0, 2, 2, 0, a->l0.me8x8[0].i_ref );
3099             x264_macroblock_cache_ref( h, 2, 0, 2, 2, 0, a->l0.me8x8[1].i_ref );
3100             x264_macroblock_cache_ref( h, 0, 2, 2, 2, 0, a->l0.me8x8[2].i_ref );
3101             x264_macroblock_cache_ref( h, 2, 2, 2, 2, 0, a->l0.me8x8[3].i_ref );
3102             for( i = 0; i < 4; i++ )
3103                 x264_mb_cache_mv_p8x8( h, a, i );
3104             break;
3105
3106         case P_SKIP:
3107         {
3108             h->mb.i_partition = D_16x16;
3109             x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, 0 );
3110             x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, h->mb.cache.pskip_mv );
3111             break;
3112         }
3113
3114         case B_SKIP:
3115         case B_DIRECT:
3116             x264_mb_load_mv_direct8x8( h, 0 );
3117             x264_mb_load_mv_direct8x8( h, 1 );
3118             x264_mb_load_mv_direct8x8( h, 2 );
3119             x264_mb_load_mv_direct8x8( h, 3 );
3120             break;
3121
3122         case B_8x8:
3123             /* optimize: cache might not need to be rewritten */
3124             for( i = 0; i < 4; i++ )
3125                 x264_mb_cache_mv_b8x8( h, a, i, 1 );
3126             break;
3127
3128         default: /* the rest of the B types */
3129             switch( h->mb.i_partition )
3130             {
3131             case D_16x16:
3132                 switch( h->mb.i_type )
3133                 {
3134                 case B_L0_L0:
3135                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
3136                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
3137
3138                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, -1 );
3139                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 1, 0 );
3140                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 1, 0 );
3141                     break;
3142                 case B_L1_L1:
3143                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, -1 );
3144                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, 0 );
3145                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 0, 0 );
3146
3147                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.i_ref );
3148                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 1, a->l1.me16x16.mv );
3149                     break;
3150                 case B_BI_BI:
3151                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
3152                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.bi16x16.mv );
3153
3154                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.i_ref );
3155                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 1, a->l1.bi16x16.mv );
3156                     break;
3157                 }
3158                 break;
3159             case D_16x8:
3160                 x264_mb_cache_mv_b16x8( h, a, 0, 1 );
3161                 x264_mb_cache_mv_b16x8( h, a, 1, 1 );
3162                 break;
3163             case D_8x16:
3164                 x264_mb_cache_mv_b8x16( h, a, 0, 1 );
3165                 x264_mb_cache_mv_b8x16( h, a, 1, 1 );
3166                 break;
3167             default:
3168                 x264_log( h, X264_LOG_ERROR, "internal error (invalid MB type)\n" );
3169                 break;
3170             }
3171     }
3172
3173 #ifndef NDEBUG
3174     if( h->i_thread_frames > 1 && !IS_INTRA(h->mb.i_type) )
3175     {
3176         int l;
3177         for( l=0; l <= (h->sh.i_type == SLICE_TYPE_B); l++ )
3178         {
3179             int completed;
3180             int ref = h->mb.cache.ref[l][x264_scan8[0]];
3181             if( ref < 0 )
3182                 continue;
3183             completed = (l ? h->fref1 : h->fref0)[ ref >> h->mb.b_interlaced ]->orig->i_lines_completed;
3184             if( (h->mb.cache.mv[l][x264_scan8[15]][1] >> (2 - h->mb.b_interlaced)) + h->mb.i_mb_y*16 > completed )
3185             {
3186                 x264_log( h, X264_LOG_WARNING, "internal error (MV out of thread range)\n");
3187                 fprintf(stderr, "mb type: %d \n", h->mb.i_type);
3188                 fprintf(stderr, "mv: l%dr%d (%d,%d) \n", l, ref,
3189                                 h->mb.cache.mv[l][x264_scan8[15]][0],
3190                                 h->mb.cache.mv[l][x264_scan8[15]][1] );
3191                 fprintf(stderr, "limit: %d \n", h->mb.mv_max_spel[1]);
3192                 fprintf(stderr, "mb_xy: %d,%d \n", h->mb.i_mb_x, h->mb.i_mb_y);
3193                 fprintf(stderr, "completed: %d \n", completed );
3194                 x264_log( h, X264_LOG_WARNING, "recovering by using intra mode\n");
3195                 x264_mb_analyse_intra( h, a, COST_MAX );
3196                 h->mb.i_type = I_16x16;
3197                 h->mb.i_intra16x16_pred_mode = a->i_predict16x16;
3198                 x264_mb_analyse_intra_chroma( h, a );
3199             }
3200         }
3201     }
3202 #endif
3203 }
3204
3205 #include "slicetype.c"
3206