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