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