Deduplicate asm constants, automate name prefixing
[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             uint8_t *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                         uint8_t *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 uint8_t 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     int b_merged_satd = !!h->pixf.intra_mbcmp_x3_8x8c && !h->mb.b_lossless;
577
578     if( a->i_satd_i8x8chroma < COST_MAX )
579         return;
580
581     const int8_t *predict_mode = predict_8x8chroma_mode_available( h->mb.i_neighbour_intra );
582
583     /* 8x8 prediction selection for chroma */
584     if( predict_mode[3] >= 0 && b_merged_satd )
585     {
586         int satdu[4], satdv[4];
587         h->pixf.intra_mbcmp_x3_8x8c( h->mb.pic.p_fenc[1], h->mb.pic.p_fdec[1], satdu );
588         h->pixf.intra_mbcmp_x3_8x8c( h->mb.pic.p_fenc[2], h->mb.pic.p_fdec[2], satdv );
589         h->predict_8x8c[I_PRED_CHROMA_P]( h->mb.pic.p_fdec[1] );
590         h->predict_8x8c[I_PRED_CHROMA_P]( h->mb.pic.p_fdec[2] );
591         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 );
592         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 );
593
594         for( ; *predict_mode >= 0; predict_mode++ )
595         {
596             int i_mode = *predict_mode;
597             int i_satd = satdu[i_mode] + satdv[i_mode] + a->i_lambda * bs_size_ue( i_mode );
598
599             a->i_satd_i8x8chroma_dir[i_mode] = i_satd;
600             COPY2_IF_LT( a->i_satd_i8x8chroma, i_satd, a->i_predict8x8chroma, i_mode );
601         }
602     }
603     else
604     {
605         for( ; *predict_mode >= 0; predict_mode++ )
606         {
607             int i_satd;
608             int i_mode = *predict_mode;
609
610             /* we do the prediction */
611             if( h->mb.b_lossless )
612                 x264_predict_lossless_8x8_chroma( h, i_mode );
613             else
614             {
615                 h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1] );
616                 h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2] );
617             }
618
619             /* we calculate the cost */
620             i_satd = h->pixf.mbcmp[PIXEL_8x8]( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc[1], FENC_STRIDE ) +
621                      h->pixf.mbcmp[PIXEL_8x8]( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc[2], FENC_STRIDE ) +
622                      a->i_lambda * bs_size_ue( x264_mb_pred_mode8x8c_fix[i_mode] );
623
624             a->i_satd_i8x8chroma_dir[i_mode] = i_satd;
625             COPY2_IF_LT( a->i_satd_i8x8chroma, i_satd, a->i_predict8x8chroma, i_mode );
626         }
627     }
628
629     h->mb.i_chroma_pred_mode = a->i_predict8x8chroma;
630 }
631
632 static void x264_mb_analyse_intra( x264_t *h, x264_mb_analysis_t *a, int i_satd_inter )
633 {
634     const unsigned int flags = h->sh.i_type == SLICE_TYPE_I ? h->param.analyse.intra : h->param.analyse.inter;
635     uint8_t  *p_src = h->mb.pic.p_fenc[0];
636     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
637
638     int idx;
639     int b_merged_satd = !!h->pixf.intra_mbcmp_x3_16x16 && !h->mb.b_lossless;
640
641     /*---------------- Try all mode and calculate their score ---------------*/
642
643     /* 16x16 prediction selection */
644     const int8_t *predict_mode = predict_16x16_mode_available( h->mb.i_neighbour_intra );
645
646     if( b_merged_satd && predict_mode[3] >= 0 )
647     {
648         h->pixf.intra_mbcmp_x3_16x16( p_src, p_dst, a->i_satd_i16x16_dir );
649         h->predict_16x16[I_PRED_16x16_P]( p_dst );
650         a->i_satd_i16x16_dir[I_PRED_16x16_P] =
651             h->pixf.mbcmp[PIXEL_16x16]( p_dst, FDEC_STRIDE, p_src, FENC_STRIDE );
652         for( int i = 0; i < 4; i++ )
653         {
654             int cost = a->i_satd_i16x16_dir[i] += a->i_lambda * bs_size_ue(i);
655             COPY2_IF_LT( a->i_satd_i16x16, cost, a->i_predict16x16, i );
656         }
657     }
658     else
659     {
660         for( ; *predict_mode >= 0; predict_mode++ )
661         {
662             int i_satd;
663             int i_mode = *predict_mode;
664
665             if( h->mb.b_lossless )
666                 x264_predict_lossless_16x16( h, i_mode );
667             else
668                 h->predict_16x16[i_mode]( p_dst );
669
670             i_satd = h->pixf.mbcmp[PIXEL_16x16]( p_dst, FDEC_STRIDE, p_src, FENC_STRIDE ) +
671                     a->i_lambda * bs_size_ue( x264_mb_pred_mode16x16_fix[i_mode] );
672             COPY2_IF_LT( a->i_satd_i16x16, i_satd, a->i_predict16x16, i_mode );
673             a->i_satd_i16x16_dir[i_mode] = i_satd;
674         }
675     }
676
677     if( h->sh.i_type == SLICE_TYPE_B )
678         /* cavlc mb type prefix */
679         a->i_satd_i16x16 += a->i_lambda * i_mb_b_cost_table[I_16x16];
680
681     /* Not heavily tuned */
682     const uint8_t i16x16_thresh[11] = { 2, 2, 2, 3, 3, 4, 4, 4, 4, 4, 4 };
683     if( a->b_fast_intra && a->i_satd_i16x16 > (i16x16_thresh[h->mb.i_subpel_refine]*i_satd_inter)>>1 )
684         return;
685
686     /* 8x8 prediction selection */
687     if( flags & X264_ANALYSE_I8x8 )
688     {
689         ALIGNED_ARRAY_16( uint8_t, edge,[33] );
690         x264_pixel_cmp_t sa8d = (h->pixf.mbcmp[0] == h->pixf.satd[0]) ? h->pixf.sa8d[PIXEL_8x8] : h->pixf.mbcmp[PIXEL_8x8];
691         int i_satd_thresh = a->i_mbrd ? COST_MAX : X264_MIN( i_satd_inter, a->i_satd_i16x16 );
692
693         // FIXME some bias like in i4x4?
694         int i_cost = a->i_lambda * 4; /* base predmode costs */
695         h->mb.i_cbp_luma = 0;
696         b_merged_satd = h->pixf.intra_mbcmp_x3_8x8 && !h->mb.b_lossless;
697
698         if( h->sh.i_type == SLICE_TYPE_B )
699             i_cost += a->i_lambda * i_mb_b_cost_table[I_8x8];
700
701         for( idx = 0;; idx++ )
702         {
703             int x = idx&1;
704             int y = idx>>1;
705             uint8_t *p_src_by = p_src + 8*x + 8*y*FENC_STRIDE;
706             uint8_t *p_dst_by = p_dst + 8*x + 8*y*FDEC_STRIDE;
707             int i_best = COST_MAX;
708             int i_pred_mode = x264_mb_predict_intra4x4_mode( h, 4*idx );
709
710             predict_mode = predict_4x4_mode_available( h->mb.i_neighbour8[idx] );
711             h->predict_8x8_filter( p_dst_by, edge, h->mb.i_neighbour8[idx], ALL_NEIGHBORS );
712
713             if( b_merged_satd && predict_mode[8] >= 0 )
714             {
715                 int satd[9];
716                 h->pixf.intra_mbcmp_x3_8x8( p_src_by, edge, satd );
717                 satd[i_pred_mode] -= 3 * a->i_lambda;
718                 for( int i = 2; i >= 0; i-- )
719                 {
720                     int cost = a->i_satd_i8x8_dir[i][idx] = satd[i];
721                     COPY2_IF_LT( i_best, cost, a->i_predict8x8[idx], i );
722                 }
723                 predict_mode += 3;
724             }
725
726             for( ; *predict_mode >= 0 && (i_best >= 0 || a->i_mbrd >= 2); predict_mode++ )
727             {
728                 int i_satd;
729                 int i_mode = *predict_mode;
730
731                 if( h->mb.b_lossless )
732                     x264_predict_lossless_8x8( h, p_dst_by, idx, i_mode, edge );
733                 else
734                     h->predict_8x8[i_mode]( p_dst_by, edge );
735
736                 i_satd = sa8d( p_dst_by, FDEC_STRIDE, p_src_by, FENC_STRIDE );
737                 if( i_pred_mode == x264_mb_pred_mode4x4_fix(i_mode) )
738                     i_satd -= 3 * a->i_lambda;
739
740                 COPY2_IF_LT( i_best, i_satd, a->i_predict8x8[idx], i_mode );
741                 a->i_satd_i8x8_dir[i_mode][idx] = i_satd + 4 * a->i_lambda;
742             }
743             i_cost += i_best + 3 * a->i_lambda;
744
745             if( idx == 3 || i_cost > i_satd_thresh )
746                 break;
747
748             /* we need to encode this block now (for next ones) */
749             h->predict_8x8[a->i_predict8x8[idx]]( p_dst_by, edge );
750             x264_mb_encode_i8x8( h, idx, a->i_qp );
751
752             x264_macroblock_cache_intra8x8_pred( h, 2*x, 2*y, a->i_predict8x8[idx] );
753         }
754
755         if( idx == 3 )
756         {
757             a->i_satd_i8x8 = i_cost;
758             if( h->mb.i_skip_intra )
759             {
760                 h->mc.copy[PIXEL_16x16]( h->mb.pic.i8x8_fdec_buf, 16, p_dst, FDEC_STRIDE, 16 );
761                 h->mb.pic.i8x8_nnz_buf[0] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 0]] );
762                 h->mb.pic.i8x8_nnz_buf[1] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 2]] );
763                 h->mb.pic.i8x8_nnz_buf[2] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 8]] );
764                 h->mb.pic.i8x8_nnz_buf[3] = M32( &h->mb.cache.non_zero_count[x264_scan8[10]] );
765                 h->mb.pic.i8x8_cbp = h->mb.i_cbp_luma;
766                 if( h->mb.i_skip_intra == 2 )
767                     h->mc.memcpy_aligned( h->mb.pic.i8x8_dct_buf, h->dct.luma8x8, sizeof(h->mb.pic.i8x8_dct_buf) );
768             }
769         }
770         else
771         {
772             static const uint16_t cost_div_fix8[3] = {1024,512,341};
773             a->i_satd_i8x8 = COST_MAX;
774             i_cost = (i_cost * cost_div_fix8[idx]) >> 8;
775         }
776         /* Not heavily tuned */
777         const uint8_t i8x8_thresh[11] = { 4, 4, 4, 5, 5, 5, 6, 6, 6, 6, 6 };
778         if( X264_MIN(i_cost, a->i_satd_i16x16) > (i_satd_inter*i8x8_thresh[h->mb.i_subpel_refine])>>2 )
779             return;
780     }
781
782     /* 4x4 prediction selection */
783     if( flags & X264_ANALYSE_I4x4 )
784     {
785         int i_cost = a->i_lambda * (24+16); /* 24from JVT (SATD0), 16 from base predmode costs */
786         int i_satd_thresh = X264_MIN3( i_satd_inter, a->i_satd_i16x16, a->i_satd_i8x8 );
787         h->mb.i_cbp_luma = 0;
788         b_merged_satd = h->pixf.intra_mbcmp_x3_4x4 && !h->mb.b_lossless;
789         if( a->i_mbrd )
790             i_satd_thresh = i_satd_thresh * (10-a->b_fast_intra)/8;
791
792         if( h->sh.i_type == SLICE_TYPE_B )
793             i_cost += a->i_lambda * i_mb_b_cost_table[I_4x4];
794
795         for( idx = 0;; idx++ )
796         {
797             uint8_t *p_src_by = p_src + block_idx_xy_fenc[idx];
798             uint8_t *p_dst_by = p_dst + block_idx_xy_fdec[idx];
799             int i_best = COST_MAX;
800             int i_pred_mode = x264_mb_predict_intra4x4_mode( h, idx );
801
802             predict_mode = predict_4x4_mode_available( h->mb.i_neighbour4[idx] );
803
804             if( (h->mb.i_neighbour4[idx] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
805                 /* emulate missing topright samples */
806                 M32( &p_dst_by[4 - FDEC_STRIDE] ) = p_dst_by[3 - FDEC_STRIDE] * 0x01010101U;
807
808             if( b_merged_satd && predict_mode[5] >= 0 )
809             {
810                 int satd[9];
811                 h->pixf.intra_mbcmp_x3_4x4( p_src_by, p_dst_by, satd );
812                 satd[i_pred_mode] -= 3 * a->i_lambda;
813                 for( int i = 2; i >= 0; i-- )
814                     COPY2_IF_LT( i_best, satd[i], a->i_predict4x4[idx], i );
815                 predict_mode += 3;
816             }
817
818             if( i_best > 0 )
819             {
820                 for( ; *predict_mode >= 0; predict_mode++ )
821                 {
822                     int i_satd;
823                     int i_mode = *predict_mode;
824
825                     if( h->mb.b_lossless )
826                         x264_predict_lossless_4x4( h, p_dst_by, idx, i_mode );
827                     else
828                         h->predict_4x4[i_mode]( p_dst_by );
829
830                     i_satd = h->pixf.mbcmp[PIXEL_4x4]( p_dst_by, FDEC_STRIDE, p_src_by, FENC_STRIDE );
831                     if( i_pred_mode == x264_mb_pred_mode4x4_fix(i_mode) )
832                     {
833                         i_satd -= a->i_lambda * 3;
834                         if( i_satd <= 0 )
835                         {
836                             i_best = i_satd;
837                             a->i_predict4x4[idx] = i_mode;
838                             break;
839                         }
840                     }
841
842                     COPY2_IF_LT( i_best, i_satd, a->i_predict4x4[idx], i_mode );
843                 }
844             }
845             i_cost += i_best + 3 * a->i_lambda;
846
847             if( i_cost > i_satd_thresh || idx == 15 )
848                 break;
849
850             /* we need to encode this block now (for next ones) */
851             h->predict_4x4[a->i_predict4x4[idx]]( p_dst_by );
852             x264_mb_encode_i4x4( h, idx, a->i_qp );
853
854             h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] = a->i_predict4x4[idx];
855         }
856         if( idx == 15 )
857         {
858             a->i_satd_i4x4 = i_cost;
859             if( h->mb.i_skip_intra )
860             {
861                 h->mc.copy[PIXEL_16x16]( h->mb.pic.i4x4_fdec_buf, 16, p_dst, FDEC_STRIDE, 16 );
862                 h->mb.pic.i4x4_nnz_buf[0] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 0]] );
863                 h->mb.pic.i4x4_nnz_buf[1] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 2]] );
864                 h->mb.pic.i4x4_nnz_buf[2] = M32( &h->mb.cache.non_zero_count[x264_scan8[ 8]] );
865                 h->mb.pic.i4x4_nnz_buf[3] = M32( &h->mb.cache.non_zero_count[x264_scan8[10]] );
866                 h->mb.pic.i4x4_cbp = h->mb.i_cbp_luma;
867                 if( h->mb.i_skip_intra == 2 )
868                     h->mc.memcpy_aligned( h->mb.pic.i4x4_dct_buf, h->dct.luma4x4, sizeof(h->mb.pic.i4x4_dct_buf) );
869             }
870         }
871         else
872             a->i_satd_i4x4 = COST_MAX;
873     }
874 }
875
876 static void x264_intra_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd_thresh )
877 {
878     if( a->i_satd_i16x16 <= i_satd_thresh )
879     {
880         h->mb.i_type = I_16x16;
881         x264_analyse_update_cache( h, a );
882         a->i_satd_i16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
883     }
884     else
885         a->i_satd_i16x16 = COST_MAX;
886
887     if( a->i_satd_i4x4 <= i_satd_thresh && a->i_satd_i4x4 < COST_MAX )
888     {
889         h->mb.i_type = I_4x4;
890         x264_analyse_update_cache( h, a );
891         a->i_satd_i4x4 = x264_rd_cost_mb( h, a->i_lambda2 );
892     }
893     else
894         a->i_satd_i4x4 = COST_MAX;
895
896     if( a->i_satd_i8x8 <= i_satd_thresh && a->i_satd_i8x8 < COST_MAX )
897     {
898         h->mb.i_type = I_8x8;
899         x264_analyse_update_cache( h, a );
900         a->i_satd_i8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
901         a->i_cbp_i8x8_luma = h->mb.i_cbp_luma;
902     }
903     else
904         a->i_satd_i8x8 = COST_MAX;
905 }
906
907 static void x264_intra_rd_refine( x264_t *h, x264_mb_analysis_t *a )
908 {
909     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
910
911     int x, y;
912     uint64_t i_satd, i_best;
913     h->mb.i_skip_intra = 0;
914
915     if( h->mb.i_type == I_16x16 )
916     {
917         int old_pred_mode = a->i_predict16x16;
918         const int8_t *predict_mode = predict_16x16_mode_available( h->mb.i_neighbour_intra );
919         int i_thresh = a->i_satd_i16x16_dir[old_pred_mode] * 9/8;
920         i_best = a->i_satd_i16x16;
921         for( ; *predict_mode >= 0; predict_mode++ )
922         {
923             int i_mode = *predict_mode;
924             if( i_mode == old_pred_mode || a->i_satd_i16x16_dir[i_mode] > i_thresh )
925                 continue;
926             h->mb.i_intra16x16_pred_mode = i_mode;
927             i_satd = x264_rd_cost_mb( h, a->i_lambda2 );
928             COPY2_IF_LT( i_best, i_satd, a->i_predict16x16, i_mode );
929         }
930     }
931
932     /* RD selection for chroma prediction */
933     const int8_t *predict_mode = predict_8x8chroma_mode_available( h->mb.i_neighbour_intra );
934     if( predict_mode[1] >= 0 )
935     {
936         int8_t predict_mode_sorted[4];
937         int i_max;
938         int i_thresh = a->i_satd_i8x8chroma * 5/4;
939
940         for( i_max = 0; *predict_mode >= 0; predict_mode++ )
941         {
942             int i_mode = *predict_mode;
943             if( a->i_satd_i8x8chroma_dir[i_mode] < i_thresh && i_mode != a->i_predict8x8chroma )
944                 predict_mode_sorted[i_max++] = i_mode;
945         }
946
947         if( i_max > 0 )
948         {
949             int i_cbp_chroma_best = h->mb.i_cbp_chroma;
950             int i_chroma_lambda = x264_lambda2_tab[h->mb.i_chroma_qp];
951             /* the previous thing encoded was x264_intra_rd(), so the pixels and
952              * coefs for the current chroma mode are still around, so we only
953              * have to recount the bits. */
954             i_best = x264_rd_cost_i8x8_chroma( h, i_chroma_lambda, a->i_predict8x8chroma, 0 );
955             for( int i = 0; i < i_max; i++ )
956             {
957                 int i_mode = predict_mode_sorted[i];
958                 if( h->mb.b_lossless )
959                     x264_predict_lossless_8x8_chroma( h, i_mode );
960                 else
961                 {
962                     h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1] );
963                     h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2] );
964                 }
965                 /* if we've already found a mode that needs no residual, then
966                  * probably any mode with a residual will be worse.
967                  * so avoid dct on the remaining modes to improve speed. */
968                 i_satd = x264_rd_cost_i8x8_chroma( h, i_chroma_lambda, i_mode, h->mb.i_cbp_chroma != 0x00 );
969                 COPY3_IF_LT( i_best, i_satd, a->i_predict8x8chroma, i_mode, i_cbp_chroma_best, h->mb.i_cbp_chroma );
970             }
971             h->mb.i_chroma_pred_mode = a->i_predict8x8chroma;
972             h->mb.i_cbp_chroma = i_cbp_chroma_best;
973         }
974     }
975
976     if( h->mb.i_type == I_4x4 )
977     {
978         uint32_t pels[4] = {0}; // doesn't need initting, just shuts up a gcc warning
979         int i_nnz = 0;
980         for( int idx = 0; idx < 16; idx++ )
981         {
982             uint8_t *p_dst_by = p_dst + block_idx_xy_fdec[idx];
983             i_best = COST_MAX64;
984
985             predict_mode = predict_4x4_mode_available( h->mb.i_neighbour4[idx] );
986
987             if( (h->mb.i_neighbour4[idx] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
988                 /* emulate missing topright samples */
989                 M32( &p_dst_by[4 - FDEC_STRIDE] ) = p_dst_by[3 - FDEC_STRIDE] * 0x01010101U;
990
991             for( ; *predict_mode >= 0; predict_mode++ )
992             {
993                 int i_mode = *predict_mode;
994                 if( h->mb.b_lossless )
995                     x264_predict_lossless_4x4( h, p_dst_by, idx, i_mode );
996                 else
997                     h->predict_4x4[i_mode]( p_dst_by );
998                 i_satd = x264_rd_cost_i4x4( h, a->i_lambda2, idx, i_mode );
999
1000                 if( i_best > i_satd )
1001                 {
1002                     a->i_predict4x4[idx] = i_mode;
1003                     i_best = i_satd;
1004                     pels[0] = M32( p_dst_by+0*FDEC_STRIDE );
1005                     pels[1] = M32( p_dst_by+1*FDEC_STRIDE );
1006                     pels[2] = M32( p_dst_by+2*FDEC_STRIDE );
1007                     pels[3] = M32( p_dst_by+3*FDEC_STRIDE );
1008                     i_nnz = h->mb.cache.non_zero_count[x264_scan8[idx]];
1009                 }
1010             }
1011
1012             M32( p_dst_by+0*FDEC_STRIDE ) = pels[0];
1013             M32( p_dst_by+1*FDEC_STRIDE ) = pels[1];
1014             M32( p_dst_by+2*FDEC_STRIDE ) = pels[2];
1015             M32( p_dst_by+3*FDEC_STRIDE ) = pels[3];
1016             h->mb.cache.non_zero_count[x264_scan8[idx]] = i_nnz;
1017
1018             h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] = a->i_predict4x4[idx];
1019         }
1020     }
1021     else if( h->mb.i_type == I_8x8 )
1022     {
1023         ALIGNED_ARRAY_16( uint8_t, edge,[33] );
1024         for( int idx = 0; idx < 4; idx++ )
1025         {
1026             uint64_t pels_h = 0;
1027             uint8_t pels_v[7];
1028             uint16_t i_nnz[2] = {0}; //shut up gcc
1029             uint8_t *p_dst_by;
1030             int cbp_luma_new = 0;
1031             int i_thresh = a->i_satd_i8x8_dir[a->i_predict8x8[idx]][idx] * 11/8;
1032
1033             i_best = COST_MAX64;
1034             x = idx&1;
1035             y = idx>>1;
1036
1037             p_dst_by = p_dst + 8*x + 8*y*FDEC_STRIDE;
1038             predict_mode = predict_4x4_mode_available( h->mb.i_neighbour8[idx] );
1039             h->predict_8x8_filter( p_dst_by, edge, h->mb.i_neighbour8[idx], ALL_NEIGHBORS );
1040
1041             for( ; *predict_mode >= 0; predict_mode++ )
1042             {
1043                 int i_mode = *predict_mode;
1044                 if( a->i_satd_i8x8_dir[i_mode][idx] > i_thresh )
1045                     continue;
1046
1047                 if( h->mb.b_lossless )
1048                     x264_predict_lossless_8x8( h, p_dst_by, idx, i_mode, edge );
1049                 else
1050                     h->predict_8x8[i_mode]( p_dst_by, edge );
1051                 h->mb.i_cbp_luma = a->i_cbp_i8x8_luma;
1052                 i_satd = x264_rd_cost_i8x8( h, a->i_lambda2, idx, i_mode );
1053
1054                 if( i_best > i_satd )
1055                 {
1056                     a->i_predict8x8[idx] = i_mode;
1057                     cbp_luma_new = h->mb.i_cbp_luma;
1058                     i_best = i_satd;
1059
1060                     pels_h = M64( p_dst_by+7*FDEC_STRIDE );
1061                     if( !(idx&1) )
1062                         for( int j = 0; j < 7; j++ )
1063                             pels_v[j] = p_dst_by[7+j*FDEC_STRIDE];
1064                     i_nnz[0] = M16( &h->mb.cache.non_zero_count[x264_scan8[4*idx+0]] );
1065                     i_nnz[1] = M16( &h->mb.cache.non_zero_count[x264_scan8[4*idx+2]] );
1066                 }
1067             }
1068             a->i_cbp_i8x8_luma = cbp_luma_new;
1069             M64( p_dst_by+7*FDEC_STRIDE ) = pels_h;
1070             if( !(idx&1) )
1071                 for( int j = 0; j < 7; j++ )
1072                     p_dst_by[7+j*FDEC_STRIDE] = pels_v[j];
1073             M16( &h->mb.cache.non_zero_count[x264_scan8[4*idx+0]] ) = i_nnz[0];
1074             M16( &h->mb.cache.non_zero_count[x264_scan8[4*idx+2]] ) = i_nnz[1];
1075
1076             x264_macroblock_cache_intra8x8_pred( h, 2*x, 2*y, a->i_predict8x8[idx] );
1077         }
1078     }
1079 }
1080
1081 #define LOAD_FENC( m, src, xoff, yoff) \
1082     (m)->p_cost_mv = a->p_cost_mv; \
1083     (m)->i_stride[0] = h->mb.pic.i_stride[0]; \
1084     (m)->i_stride[1] = h->mb.pic.i_stride[1]; \
1085     (m)->p_fenc[0] = &(src)[0][(xoff)+(yoff)*FENC_STRIDE]; \
1086     (m)->p_fenc[1] = &(src)[1][((xoff)>>1)+((yoff)>>1)*FENC_STRIDE]; \
1087     (m)->p_fenc[2] = &(src)[2][((xoff)>>1)+((yoff)>>1)*FENC_STRIDE];
1088
1089 #define LOAD_HPELS(m, src, list, ref, xoff, yoff) \
1090     (m)->p_fref_w = (m)->p_fref[0] = &(src)[0][(xoff)+(yoff)*(m)->i_stride[0]]; \
1091     (m)->p_fref[1] = &(src)[1][(xoff)+(yoff)*(m)->i_stride[0]]; \
1092     (m)->p_fref[2] = &(src)[2][(xoff)+(yoff)*(m)->i_stride[0]]; \
1093     (m)->p_fref[3] = &(src)[3][(xoff)+(yoff)*(m)->i_stride[0]]; \
1094     (m)->p_fref[4] = &(src)[4][((xoff)>>1)+((yoff)>>1)*(m)->i_stride[1]]; \
1095     (m)->p_fref[5] = &(src)[5][((xoff)>>1)+((yoff)>>1)*(m)->i_stride[1]]; \
1096     (m)->integral = &h->mb.pic.p_integral[list][ref][(xoff)+(yoff)*(m)->i_stride[0]]; \
1097     (m)->weight = weight_none; \
1098     (m)->i_ref = ref;
1099
1100 #define LOAD_WPELS(m, src, list, ref, xoff, yoff) \
1101     (m)->p_fref_w = &(src)[(xoff)+(yoff)*(m)->i_stride[0]]; \
1102     (m)->weight = h->sh.weight[i_ref];
1103
1104 #define REF_COST(list, ref) \
1105     (a->p_cost_ref[list][ref])
1106
1107 static void x264_mb_analyse_inter_p16x16( x264_t *h, x264_mb_analysis_t *a )
1108 {
1109     x264_me_t m;
1110     int i_mvc;
1111     ALIGNED_4( int16_t mvc[8][2] );
1112     int i_halfpel_thresh = INT_MAX;
1113     int *p_halfpel_thresh = h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh : NULL;
1114
1115     /* 16x16 Search on all ref frame */
1116     m.i_pixel = PIXEL_16x16;
1117     LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 0 );
1118
1119     a->l0.me16x16.cost = INT_MAX;
1120     for( int i_ref = 0; i_ref < h->mb.pic.i_fref[0]; i_ref++ )
1121     {
1122         m.i_ref_cost = REF_COST( 0, i_ref );
1123         i_halfpel_thresh -= m.i_ref_cost;
1124
1125         /* search with ref */
1126         LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 0 );
1127         LOAD_WPELS( &m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 0, 0 );
1128
1129         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
1130
1131         if( h->mb.ref_blind_dupe == i_ref )
1132         {
1133             CP32( m.mv, a->l0.mvc[0][0] );
1134             x264_me_refine_qpel_refdupe( h, &m, p_halfpel_thresh );
1135         }
1136         else
1137         {
1138             x264_mb_predict_mv_ref16x16( h, 0, i_ref, mvc, &i_mvc );
1139             x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );
1140         }
1141
1142         /* save mv for predicting neighbors */
1143         CP32( h->mb.mvr[0][i_ref][h->mb.i_mb_xy], m.mv );
1144         CP32( a->l0.mvc[i_ref][0], m.mv );
1145
1146         /* early termination
1147          * SSD threshold would probably be better than SATD */
1148         if( i_ref == 0
1149             && a->b_try_skip
1150             && m.cost-m.cost_mv < 300*a->i_lambda
1151             &&  abs(m.mv[0]-h->mb.cache.pskip_mv[0])
1152               + abs(m.mv[1]-h->mb.cache.pskip_mv[1]) <= 1
1153             && x264_macroblock_probe_pskip( h ) )
1154         {
1155             h->mb.i_type = P_SKIP;
1156             x264_analyse_update_cache( h, a );
1157             assert( h->mb.cache.pskip_mv[1] <= h->mb.mv_max_spel[1] || h->i_thread_frames == 1 );
1158             return;
1159         }
1160
1161         m.cost += m.i_ref_cost;
1162         i_halfpel_thresh += m.i_ref_cost;
1163
1164         if( m.cost < a->l0.me16x16.cost )
1165             h->mc.memcpy_aligned( &a->l0.me16x16, &m, sizeof(x264_me_t) );
1166     }
1167
1168     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.me16x16.i_ref );
1169     assert( a->l0.me16x16.mv[1] <= h->mb.mv_max_spel[1] || h->i_thread_frames == 1 );
1170
1171     h->mb.i_type = P_L0;
1172     if( a->i_mbrd )
1173     {
1174         x264_mb_init_fenc_cache( h, a->i_mbrd >= 2 || h->param.analyse.inter & X264_ANALYSE_PSUB8x8 );
1175         if( a->l0.me16x16.i_ref == 0 && M32( a->l0.me16x16.mv ) == M32( h->mb.cache.pskip_mv ) && !a->b_force_intra )
1176         {
1177             h->mb.i_partition = D_16x16;
1178             x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
1179             a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
1180             if( !(h->mb.i_cbp_luma|h->mb.i_cbp_chroma) )
1181                 h->mb.i_type = P_SKIP;
1182         }
1183     }
1184 }
1185
1186 static void x264_mb_analyse_inter_p8x8_mixed_ref( x264_t *h, x264_mb_analysis_t *a )
1187 {
1188     x264_me_t m;
1189     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1190     int i_maxref = h->mb.pic.i_fref[0]-1;
1191
1192     h->mb.i_partition = D_8x8;
1193
1194     #define CHECK_NEIGHBOUR(i)\
1195     {\
1196         int ref = h->mb.cache.ref[0][X264_SCAN8_0+i];\
1197         if( ref > i_maxref && ref != h->mb.ref_blind_dupe )\
1198             i_maxref = ref;\
1199     }
1200
1201     /* early termination: if 16x16 chose ref 0, then evalute no refs older
1202      * than those used by the neighbors */
1203     if( i_maxref > 0 && (a->l0.me16x16.i_ref == 0 || a->l0.me16x16.i_ref == h->mb.ref_blind_dupe) &&
1204         h->mb.i_mb_type_top > 0 && h->mb.i_mb_type_left > 0 )
1205     {
1206         i_maxref = 0;
1207         CHECK_NEIGHBOUR(  -8 - 1 );
1208         CHECK_NEIGHBOUR(  -8 + 0 );
1209         CHECK_NEIGHBOUR(  -8 + 2 );
1210         CHECK_NEIGHBOUR(  -8 + 4 );
1211         CHECK_NEIGHBOUR(   0 - 1 );
1212         CHECK_NEIGHBOUR( 2*8 - 1 );
1213     }
1214     #undef CHECK_NEIGHBOUR
1215
1216     for( int i_ref = 0; i_ref <= i_maxref; i_ref++ )
1217         CP32( a->l0.mvc[i_ref][0], h->mb.mvr[0][i_ref][h->mb.i_mb_xy] );
1218
1219     for( int i = 0; i < 4; i++ )
1220     {
1221         x264_me_t *l0m = &a->l0.me8x8[i];
1222         const int x8 = i%2;
1223         const int y8 = i/2;
1224
1225         m.i_pixel = PIXEL_8x8;
1226
1227         LOAD_FENC( &m, p_fenc, 8*x8, 8*y8 );
1228         l0m->cost = INT_MAX;
1229         for( int i_ref = 0; i_ref <= i_maxref || i_ref == h->mb.ref_blind_dupe; )
1230         {
1231             m.i_ref_cost = REF_COST( 0, i_ref );
1232
1233             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*x8, 8*y8 );
1234             LOAD_WPELS( &m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 8*x8, 8*y8 );
1235
1236             x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, i_ref );
1237             x264_mb_predict_mv( h, 0, 4*i, 2, m.mvp );
1238             if( h->mb.ref_blind_dupe == i_ref )
1239             {
1240                 CP32( m.mv, a->l0.mvc[0][i+1] );
1241                 x264_me_refine_qpel_refdupe( h, &m, NULL );
1242             }
1243             else
1244                 x264_me_search( h, &m, a->l0.mvc[i_ref], i+1 );
1245
1246             m.cost += m.i_ref_cost;
1247
1248             CP32( a->l0.mvc[i_ref][i+1], m.mv );
1249
1250             if( m.cost < l0m->cost )
1251                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
1252             if( i_ref == i_maxref && i_maxref < h->mb.ref_blind_dupe )
1253                 i_ref = h->mb.ref_blind_dupe;
1254             else
1255                 i_ref++;
1256         }
1257         x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, 0, l0m->mv );
1258         x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, l0m->i_ref );
1259
1260         a->i_satd8x8[0][i] = l0m->cost - ( l0m->cost_mv + l0m->i_ref_cost );
1261
1262         /* If CABAC is on and we're not doing sub-8x8 analysis, the costs
1263            are effectively zero. */
1264         if( !h->param.b_cabac || (h->param.analyse.inter & X264_ANALYSE_PSUB8x8) )
1265             l0m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
1266     }
1267
1268     a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
1269                       a->l0.me8x8[2].cost + a->l0.me8x8[3].cost;
1270     /* P_8x8 ref0 has no ref cost */
1271     if( !h->param.b_cabac && !(a->l0.me8x8[0].i_ref | a->l0.me8x8[1].i_ref |
1272                                a->l0.me8x8[2].i_ref | a->l0.me8x8[3].i_ref) )
1273         a->l0.i_cost8x8 -= REF_COST( 0, 0 ) * 4;
1274     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
1275     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
1276 }
1277
1278 static void x264_mb_analyse_inter_p8x8( x264_t *h, x264_mb_analysis_t *a )
1279 {
1280     /* Duplicate refs are rarely useful in p8x8 due to the high cost of the
1281      * reference frame flags.  Thus, if we're not doing mixedrefs, just
1282      * don't bother analysing the dupes. */
1283     const int i_ref = h->mb.ref_blind_dupe == a->l0.me16x16.i_ref ? 0 : a->l0.me16x16.i_ref;
1284     const int i_ref_cost = h->param.b_cabac || i_ref ? REF_COST( 0, i_ref ) : 0;
1285     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1286     int i_mvc;
1287     int16_t (*mvc)[2] = a->l0.mvc[i_ref];
1288
1289     /* XXX Needed for x264_mb_predict_mv */
1290     h->mb.i_partition = D_8x8;
1291
1292     i_mvc = 1;
1293     CP32( mvc[0], a->l0.me16x16.mv );
1294
1295     for( int i = 0; i < 4; i++ )
1296     {
1297         x264_me_t *m = &a->l0.me8x8[i];
1298         const int x8 = i%2;
1299         const int y8 = i/2;
1300
1301         m->i_pixel = PIXEL_8x8;
1302         m->i_ref_cost = i_ref_cost;
1303
1304         LOAD_FENC( m, p_fenc, 8*x8, 8*y8 );
1305         LOAD_HPELS( m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*x8, 8*y8 );
1306         LOAD_WPELS( m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 8*x8, 8*y8 );
1307
1308         x264_mb_predict_mv( h, 0, 4*i, 2, m->mvp );
1309         x264_me_search( h, m, mvc, i_mvc );
1310
1311         x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, 0, m->mv );
1312
1313         CP32( mvc[i_mvc], m->mv );
1314         i_mvc++;
1315
1316         a->i_satd8x8[0][i] = m->cost - m->cost_mv;
1317
1318         /* mb type cost */
1319         m->cost += i_ref_cost;
1320         if( !h->param.b_cabac || (h->param.analyse.inter & X264_ANALYSE_PSUB8x8) )
1321             m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
1322     }
1323
1324     a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
1325                       a->l0.me8x8[2].cost + a->l0.me8x8[3].cost;
1326     /* theoretically this should include 4*ref_cost,
1327      * but 3 seems a better approximation of cabac. */
1328     if( h->param.b_cabac )
1329         a->l0.i_cost8x8 -= i_ref_cost;
1330     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
1331     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
1332 }
1333
1334 static void x264_mb_analyse_inter_p16x8( x264_t *h, x264_mb_analysis_t *a, int i_best_satd )
1335 {
1336     x264_me_t m;
1337     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1338     ALIGNED_4( int16_t mvc[3][2] );
1339
1340     /* XXX Needed for x264_mb_predict_mv */
1341     h->mb.i_partition = D_16x8;
1342
1343     for( int i = 0; i < 2; i++ )
1344     {
1345         x264_me_t *l0m = &a->l0.me16x8[i];
1346         const int minref = X264_MIN( a->l0.me8x8[2*i].i_ref, a->l0.me8x8[2*i+1].i_ref );
1347         const int maxref = X264_MAX( a->l0.me8x8[2*i].i_ref, a->l0.me8x8[2*i+1].i_ref );
1348         const int ref8[2] = { minref, maxref };
1349         const int i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;
1350
1351         m.i_pixel = PIXEL_16x8;
1352
1353         LOAD_FENC( &m, p_fenc, 0, 8*i );
1354         l0m->cost = INT_MAX;
1355         for( int j = 0; j < i_ref8s; j++ )
1356         {
1357             const int i_ref = ref8[j];
1358             m.i_ref_cost = REF_COST( 0, i_ref );
1359
1360             /* if we skipped the 16x16 predictor, we wouldn't have to copy anything... */
1361             CP32( mvc[0], a->l0.mvc[i_ref][0] );
1362             CP32( mvc[1], a->l0.mvc[i_ref][2*i+1] );
1363             CP32( mvc[2], a->l0.mvc[i_ref][2*i+2] );
1364
1365             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 8*i );
1366             LOAD_WPELS( &m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 0, 8*i );
1367
1368             x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, 0, i_ref );
1369             x264_mb_predict_mv( h, 0, 8*i, 4, m.mvp );
1370             /* We can only take this shortcut if the first search was performed on ref0. */
1371             if( h->mb.ref_blind_dupe == i_ref && !ref8[0] )
1372             {
1373                 /* We can just leave the MV from the previous ref search. */
1374                 x264_me_refine_qpel_refdupe( h, &m, NULL );
1375             }
1376             else
1377                 x264_me_search( h, &m, mvc, 3 );
1378
1379             m.cost += m.i_ref_cost;
1380
1381             if( m.cost < l0m->cost )
1382                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
1383         }
1384
1385         /* Early termination based on the current SATD score of partition[0]
1386            plus the estimated SATD score of partition[1] */
1387         if( !i && l0m->cost + a->i_cost_est16x8[1] > i_best_satd * (4 + !!a->i_mbrd) / 4 )
1388         {
1389             a->l0.i_cost16x8 = COST_MAX;
1390             return;
1391         }
1392
1393         x264_macroblock_cache_mv_ptr( h, 0, 2*i, 4, 2, 0, l0m->mv );
1394         x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, 0, l0m->i_ref );
1395     }
1396
1397     a->l0.i_cost16x8 = a->l0.me16x8[0].cost + a->l0.me16x8[1].cost;
1398 }
1399
1400 static void x264_mb_analyse_inter_p8x16( x264_t *h, x264_mb_analysis_t *a, int i_best_satd )
1401 {
1402     x264_me_t m;
1403     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1404     ALIGNED_4( int16_t mvc[3][2] );
1405
1406     /* XXX Needed for x264_mb_predict_mv */
1407     h->mb.i_partition = D_8x16;
1408
1409     for( int i = 0; i < 2; i++ )
1410     {
1411         x264_me_t *l0m = &a->l0.me8x16[i];
1412         const int minref = X264_MIN( a->l0.me8x8[i].i_ref, a->l0.me8x8[i+2].i_ref );
1413         const int maxref = X264_MAX( a->l0.me8x8[i].i_ref, a->l0.me8x8[i+2].i_ref );
1414         const int ref8[2] = { minref, maxref };
1415         const int i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;
1416
1417         m.i_pixel = PIXEL_8x16;
1418
1419         LOAD_FENC( &m, p_fenc, 8*i, 0 );
1420         l0m->cost = INT_MAX;
1421         for( int j = 0; j < i_ref8s; j++ )
1422         {
1423             const int i_ref = ref8[j];
1424             m.i_ref_cost = REF_COST( 0, i_ref );
1425
1426             CP32( mvc[0], a->l0.mvc[i_ref][0] );
1427             CP32( mvc[1], a->l0.mvc[i_ref][i+1] );
1428             CP32( mvc[2], a->l0.mvc[i_ref][i+3] );
1429
1430             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*i, 0 );
1431             LOAD_WPELS( &m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 8*i, 0 );
1432
1433             x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, 0, i_ref );
1434             x264_mb_predict_mv( h, 0, 4*i, 2, m.mvp );
1435             /* We can only take this shortcut if the first search was performed on ref0. */
1436             if( h->mb.ref_blind_dupe == i_ref && !ref8[0] )
1437             {
1438                 /* We can just leave the MV from the previous ref search. */
1439                 x264_me_refine_qpel_refdupe( h, &m, NULL );
1440             }
1441             else
1442                 x264_me_search( h, &m, mvc, 3 );
1443
1444             m.cost += m.i_ref_cost;
1445
1446             if( m.cost < l0m->cost )
1447                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
1448         }
1449
1450         /* Early termination based on the current SATD score of partition[0]
1451            plus the estimated SATD score of partition[1] */
1452         if( !i && l0m->cost + a->i_cost_est8x16[1] > i_best_satd * (4 + !!a->i_mbrd) / 4 )
1453         {
1454             a->l0.i_cost8x16 = COST_MAX;
1455             return;
1456         }
1457
1458         x264_macroblock_cache_mv_ptr( h, 2*i, 0, 2, 4, 0, l0m->mv );
1459         x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, 0, l0m->i_ref );
1460     }
1461
1462     a->l0.i_cost8x16 = a->l0.me8x16[0].cost + a->l0.me8x16[1].cost;
1463 }
1464
1465 static int x264_mb_analyse_inter_p4x4_chroma( x264_t *h, x264_mb_analysis_t *a, uint8_t **p_fref, int i8x8, int pixel )
1466 {
1467     ALIGNED_ARRAY_8( uint8_t, pix1,[16*8] );
1468     uint8_t *pix2 = pix1+8;
1469     const int i_stride = h->mb.pic.i_stride[1];
1470     const int or = 4*(i8x8&1) + 2*(i8x8&2)*i_stride;
1471     const int oe = 4*(i8x8&1) + 2*(i8x8&2)*FENC_STRIDE;
1472     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1473     const int mvy_offset = h->mb.b_interlaced & i_ref ? (h->mb.i_mb_y & 1)*4 - 2 : 0;
1474     x264_weight_t *weight = h->sh.weight[i_ref];
1475
1476 #define CHROMA4x4MC( width, height, me, x, y ) \
1477     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 ); \
1478     if( weight[1].weightfn ) \
1479         weight[1].weightfn[width>>2]( &pix1[x+y*16], 16, &pix1[x+y*16], 16, &weight[1], height ); \
1480     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 ); \
1481     if( weight[2].weightfn ) \
1482         weight[2].weightfn[width>>2]( &pix2[x+y*16], 16, &pix2[x+y*16], 16, &weight[2], height );
1483
1484
1485     if( pixel == PIXEL_4x4 )
1486     {
1487         x264_me_t *m = a->l0.me4x4[i8x8];
1488         CHROMA4x4MC( 2,2, m[0], 0,0 );
1489         CHROMA4x4MC( 2,2, m[1], 2,0 );
1490         CHROMA4x4MC( 2,2, m[2], 0,2 );
1491         CHROMA4x4MC( 2,2, m[3], 2,2 );
1492     }
1493     else if( pixel == PIXEL_8x4 )
1494     {
1495         x264_me_t *m = a->l0.me8x4[i8x8];
1496         CHROMA4x4MC( 4,2, m[0], 0,0 );
1497         CHROMA4x4MC( 4,2, m[1], 0,2 );
1498     }
1499     else
1500     {
1501         x264_me_t *m = a->l0.me4x8[i8x8];
1502         CHROMA4x4MC( 2,4, m[0], 0,0 );
1503         CHROMA4x4MC( 2,4, m[1], 2,0 );
1504     }
1505
1506     return h->pixf.mbcmp[PIXEL_4x4]( &h->mb.pic.p_fenc[1][oe], FENC_STRIDE, pix1, 16 )
1507          + h->pixf.mbcmp[PIXEL_4x4]( &h->mb.pic.p_fenc[2][oe], FENC_STRIDE, pix2, 16 );
1508 }
1509
1510 static void x264_mb_analyse_inter_p4x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
1511 {
1512     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
1513     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1514     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1515
1516     /* XXX Needed for x264_mb_predict_mv */
1517     h->mb.i_partition = D_8x8;
1518
1519     for( int i4x4 = 0; i4x4 < 4; i4x4++ )
1520     {
1521         const int idx = 4*i8x8 + i4x4;
1522         const int x4 = block_idx_x[idx];
1523         const int y4 = block_idx_y[idx];
1524         const int i_mvc = (i4x4 == 0);
1525
1526         x264_me_t *m = &a->l0.me4x4[i8x8][i4x4];
1527
1528         m->i_pixel = PIXEL_4x4;
1529
1530         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
1531         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
1532         LOAD_WPELS( m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 4*x4, 4*y4 );
1533
1534         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
1535         x264_me_search( h, m, &a->l0.me8x8[i8x8].mv, i_mvc );
1536
1537         x264_macroblock_cache_mv_ptr( h, x4, y4, 1, 1, 0, m->mv );
1538     }
1539     a->l0.i_cost4x4[i8x8] = a->l0.me4x4[i8x8][0].cost +
1540                             a->l0.me4x4[i8x8][1].cost +
1541                             a->l0.me4x4[i8x8][2].cost +
1542                             a->l0.me4x4[i8x8][3].cost +
1543                             REF_COST( 0, i_ref ) +
1544                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x4];
1545     if( h->mb.b_chroma_me )
1546         a->l0.i_cost4x4[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_4x4 );
1547 }
1548
1549 static void x264_mb_analyse_inter_p8x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
1550 {
1551     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
1552     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1553     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1554
1555     /* XXX Needed for x264_mb_predict_mv */
1556     h->mb.i_partition = D_8x8;
1557
1558     for( int i8x4 = 0; i8x4 < 2; i8x4++ )
1559     {
1560         const int idx = 4*i8x8 + 2*i8x4;
1561         const int x4 = block_idx_x[idx];
1562         const int y4 = block_idx_y[idx];
1563         const int i_mvc = (i8x4 == 0);
1564
1565         x264_me_t *m = &a->l0.me8x4[i8x8][i8x4];
1566
1567         m->i_pixel = PIXEL_8x4;
1568
1569         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
1570         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
1571         LOAD_WPELS( m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 4*x4, 4*y4 );
1572
1573         x264_mb_predict_mv( h, 0, idx, 2, m->mvp );
1574         x264_me_search( h, m, &a->l0.me4x4[i8x8][0].mv, i_mvc );
1575
1576         x264_macroblock_cache_mv_ptr( h, x4, y4, 2, 1, 0, m->mv );
1577     }
1578     a->l0.i_cost8x4[i8x8] = a->l0.me8x4[i8x8][0].cost + a->l0.me8x4[i8x8][1].cost +
1579                             REF_COST( 0, i_ref ) +
1580                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x4];
1581     if( h->mb.b_chroma_me )
1582         a->l0.i_cost8x4[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_8x4 );
1583 }
1584
1585 static void x264_mb_analyse_inter_p4x8( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
1586 {
1587     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
1588     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1589     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1590
1591     /* XXX Needed for x264_mb_predict_mv */
1592     h->mb.i_partition = D_8x8;
1593
1594     for( int i4x8 = 0; i4x8 < 2; i4x8++ )
1595     {
1596         const int idx = 4*i8x8 + i4x8;
1597         const int x4 = block_idx_x[idx];
1598         const int y4 = block_idx_y[idx];
1599         const int i_mvc = (i4x8 == 0);
1600
1601         x264_me_t *m = &a->l0.me4x8[i8x8][i4x8];
1602
1603         m->i_pixel = PIXEL_4x8;
1604
1605         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
1606         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
1607         LOAD_WPELS( m, h->mb.pic.p_fref_w[i_ref], 0, i_ref, 4*x4, 4*y4 );
1608
1609         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
1610         x264_me_search( h, m, &a->l0.me4x4[i8x8][0].mv, i_mvc );
1611
1612         x264_macroblock_cache_mv_ptr( h, x4, y4, 1, 2, 0, m->mv );
1613     }
1614     a->l0.i_cost4x8[i8x8] = a->l0.me4x8[i8x8][0].cost + a->l0.me4x8[i8x8][1].cost +
1615                             REF_COST( 0, i_ref ) +
1616                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x8];
1617     if( h->mb.b_chroma_me )
1618         a->l0.i_cost4x8[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_4x8 );
1619 }
1620
1621 static void x264_mb_analyse_inter_direct( x264_t *h, x264_mb_analysis_t *a )
1622 {
1623     /* Assumes that fdec still contains the results of
1624      * x264_mb_predict_mv_direct16x16 and x264_mb_mc */
1625
1626     uint8_t *p_fenc = h->mb.pic.p_fenc[0];
1627     uint8_t *p_fdec = h->mb.pic.p_fdec[0];
1628
1629     a->i_cost16x16direct = a->i_lambda * i_mb_b_cost_table[B_DIRECT];
1630     if( h->param.analyse.inter & X264_ANALYSE_BSUB16x16 )
1631         for( int i = 0; i < 4; i++ )
1632         {
1633             const int x = (i&1)*8;
1634             const int y = (i>>1)*8;
1635             a->i_cost16x16direct +=
1636             a->i_cost8x8direct[i] =
1637                 h->pixf.mbcmp[PIXEL_8x8]( &p_fenc[x+y*FENC_STRIDE], FENC_STRIDE, &p_fdec[x+y*FDEC_STRIDE], FDEC_STRIDE );
1638
1639             /* mb type cost */
1640             a->i_cost8x8direct[i] += a->i_lambda * i_sub_mb_b_cost_table[D_DIRECT_8x8];
1641         }
1642     else
1643         a->i_cost16x16direct += h->pixf.mbcmp[PIXEL_16x16]( p_fenc, FENC_STRIDE, p_fdec, FDEC_STRIDE );
1644 }
1645
1646 static void x264_mb_analyse_inter_b16x16( x264_t *h, x264_mb_analysis_t *a )
1647 {
1648     ALIGNED_ARRAY_16( uint8_t, pix0,[16*16] );
1649     ALIGNED_ARRAY_16( uint8_t, pix1,[16*16] );
1650     uint8_t *src0, *src1;
1651     int stride0 = 16, stride1 = 16;
1652     int i_ref, i_mvc;
1653     ALIGNED_4( int16_t mvc[9][2] );
1654     int try_skip = a->b_try_skip;
1655     int list1_skipped = 0;
1656     int i_halfpel_thresh[2] = {INT_MAX, INT_MAX};
1657     int *p_halfpel_thresh[2] = {h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh[0] : NULL,
1658                                 h->mb.pic.i_fref[1]>1 ? &i_halfpel_thresh[1] : NULL};
1659
1660     x264_me_t m;
1661     m.i_pixel = PIXEL_16x16;
1662
1663     LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 0 );
1664
1665     /* 16x16 Search on list 0 and list 1 */
1666     a->l0.me16x16.cost = INT_MAX;
1667     a->l1.me16x16.cost = INT_MAX;
1668     for( int l = 1; l >= 0; )
1669     {
1670         x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
1671
1672         /* This loop is extremely munged in order to facilitate the following order of operations,
1673          * necessary for an efficient fast skip.
1674          * 1.  Search list1 ref0.
1675          * 2.  Search list0 ref0.
1676          * 3.  Try skip.
1677          * 4.  Search the rest of list0.
1678          * 5.  Go back and finish list1.
1679          */
1680         for( i_ref = (list1_skipped && l == 1) ? 1 : 0; i_ref < h->mb.pic.i_fref[l]; i_ref++ )
1681         {
1682             if( try_skip && l == 1 && i_ref > 0 )
1683             {
1684                 list1_skipped = 1;
1685                 break;
1686             }
1687
1688             m.i_ref_cost = REF_COST( l, i_ref );
1689
1690             /* search with ref */
1691             LOAD_HPELS( &m, h->mb.pic.p_fref[l][i_ref], l, i_ref, 0, 0 );
1692             x264_mb_predict_mv_16x16( h, l, i_ref, m.mvp );
1693             x264_mb_predict_mv_ref16x16( h, l, i_ref, mvc, &i_mvc );
1694             x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh[l] );
1695
1696             /* add ref cost */
1697             m.cost += m.i_ref_cost;
1698
1699             if( m.cost < lX->me16x16.cost )
1700                 h->mc.memcpy_aligned( &lX->me16x16, &m, sizeof(x264_me_t) );
1701
1702             /* save mv for predicting neighbors */
1703             CP32( lX->mvc[i_ref][0], m.mv );
1704             CP32( h->mb.mvr[l][i_ref][h->mb.i_mb_xy], m.mv );
1705
1706             /* Fast skip detection. */
1707             if( i_ref == 0 && try_skip )
1708             {
1709                 if( abs(lX->me16x16.mv[0]-h->mb.cache.direct_mv[l][0][0]) +
1710                     abs(lX->me16x16.mv[1]-h->mb.cache.direct_mv[l][0][1]) > 1 )
1711                 {
1712                     try_skip = 0;
1713                 }
1714                 else if( !l )
1715                 {
1716                     /* We already tested skip */
1717                     h->mb.i_type = B_SKIP;
1718                     x264_analyse_update_cache( h, a );
1719                     return;
1720                 }
1721             }
1722         }
1723         if( list1_skipped && l == 1 && i_ref == h->mb.pic.i_fref[1] )
1724             break;
1725         if( list1_skipped && l == 0 )
1726             l = 1;
1727         else
1728             l--;
1729     }
1730
1731     /* get cost of BI mode */
1732     h->mc.memcpy_aligned( &a->l0.bi16x16, &a->l0.me16x16, sizeof(x264_me_t) );
1733     h->mc.memcpy_aligned( &a->l1.bi16x16, &a->l1.me16x16, sizeof(x264_me_t) );
1734     int ref_costs = REF_COST( 0, a->l0.bi16x16.i_ref ) + REF_COST( 1, a->l1.bi16x16.i_ref );
1735     src0 = h->mc.get_ref( pix0, &stride0,
1736                           h->mb.pic.p_fref[0][a->l0.bi16x16.i_ref], h->mb.pic.i_stride[0],
1737                           a->l0.bi16x16.mv[0], a->l0.bi16x16.mv[1], 16, 16, weight_none );
1738     src1 = h->mc.get_ref( pix1, &stride1,
1739                           h->mb.pic.p_fref[1][a->l1.bi16x16.i_ref], h->mb.pic.i_stride[0],
1740                           a->l1.bi16x16.mv[0], a->l1.bi16x16.mv[1], 16, 16, weight_none );
1741
1742     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] );
1743
1744     a->i_cost16x16bi = h->pixf.mbcmp[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE, pix0, 16 )
1745                      + ref_costs
1746                      + a->l0.bi16x16.cost_mv
1747                      + a->l1.bi16x16.cost_mv;
1748
1749     /* Always try the 0,0,0,0 vector; helps avoid errant motion vectors in fades */
1750     if( M32( a->l0.bi16x16.mv ) | M32( a->l1.bi16x16.mv ) )
1751     {
1752         int l0_mv_cost = a->l0.bi16x16.p_cost_mv[-a->l0.bi16x16.mvp[0]]
1753                        + a->l0.bi16x16.p_cost_mv[-a->l0.bi16x16.mvp[1]];
1754         int l1_mv_cost = a->l1.bi16x16.p_cost_mv[-a->l1.bi16x16.mvp[0]]
1755                        + a->l1.bi16x16.p_cost_mv[-a->l1.bi16x16.mvp[1]];
1756         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],
1757                                 h->mb.pic.p_fref[1][a->l1.bi16x16.i_ref][0], h->mb.pic.i_stride[0],
1758                                 h->mb.bipred_weight[a->l0.bi16x16.i_ref][a->l1.bi16x16.i_ref] );
1759         int cost00 = h->pixf.mbcmp[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE, pix0, 16 )
1760                    + ref_costs + l0_mv_cost + l1_mv_cost;
1761         if( cost00 < a->i_cost16x16bi )
1762         {
1763             M32( a->l0.bi16x16.mv ) = 0;
1764             M32( a->l1.bi16x16.mv ) = 0;
1765             a->l0.bi16x16.cost_mv = l0_mv_cost;
1766             a->l1.bi16x16.cost_mv = l1_mv_cost;
1767             a->i_cost16x16bi = cost00;
1768         }
1769     }
1770
1771     /* mb type cost */
1772     a->i_cost16x16bi   += a->i_lambda * i_mb_b_cost_table[B_BI_BI];
1773     a->l0.me16x16.cost += a->i_lambda * i_mb_b_cost_table[B_L0_L0];
1774     a->l1.me16x16.cost += a->i_lambda * i_mb_b_cost_table[B_L1_L1];
1775 }
1776
1777 static inline void x264_mb_cache_mv_p8x8( x264_t *h, x264_mb_analysis_t *a, int i )
1778 {
1779     const int x = 2*(i%2);
1780     const int y = 2*(i/2);
1781
1782     switch( h->mb.i_sub_partition[i] )
1783     {
1784         case D_L0_8x8:
1785             x264_macroblock_cache_mv_ptr( h, x, y, 2, 2, 0, a->l0.me8x8[i].mv );
1786             break;
1787         case D_L0_8x4:
1788             x264_macroblock_cache_mv_ptr( h, x, y+0, 2, 1, 0, a->l0.me8x4[i][0].mv );
1789             x264_macroblock_cache_mv_ptr( h, x, y+1, 2, 1, 0, a->l0.me8x4[i][1].mv );
1790             break;
1791         case D_L0_4x8:
1792             x264_macroblock_cache_mv_ptr( h, x+0, y, 1, 2, 0, a->l0.me4x8[i][0].mv );
1793             x264_macroblock_cache_mv_ptr( h, x+1, y, 1, 2, 0, a->l0.me4x8[i][1].mv );
1794             break;
1795         case D_L0_4x4:
1796             x264_macroblock_cache_mv_ptr( h, x+0, y+0, 1, 1, 0, a->l0.me4x4[i][0].mv );
1797             x264_macroblock_cache_mv_ptr( h, x+1, y+0, 1, 1, 0, a->l0.me4x4[i][1].mv );
1798             x264_macroblock_cache_mv_ptr( h, x+0, y+1, 1, 1, 0, a->l0.me4x4[i][2].mv );
1799             x264_macroblock_cache_mv_ptr( h, x+1, y+1, 1, 1, 0, a->l0.me4x4[i][3].mv );
1800             break;
1801         default:
1802             x264_log( h, X264_LOG_ERROR, "internal error\n" );
1803             break;
1804     }
1805 }
1806
1807 static void x264_mb_load_mv_direct8x8( x264_t *h, int idx )
1808 {
1809     const int x = 2*(idx&1);
1810     const int y = 2*(idx>>1);
1811     x264_macroblock_cache_ref( h, x, y, 2, 2, 0, h->mb.cache.direct_ref[0][idx] );
1812     x264_macroblock_cache_ref( h, x, y, 2, 2, 1, h->mb.cache.direct_ref[1][idx] );
1813     x264_macroblock_cache_mv_ptr( h, x, y, 2, 2, 0, h->mb.cache.direct_mv[0][idx] );
1814     x264_macroblock_cache_mv_ptr( h, x, y, 2, 2, 1, h->mb.cache.direct_mv[1][idx] );
1815 }
1816
1817 #define CACHE_MV_BI(x,y,dx,dy,me0,me1,part) \
1818     if( x264_mb_partition_listX_table[0][part] ) \
1819     { \
1820         x264_macroblock_cache_ref( h, x,y,dx,dy, 0, me0.i_ref ); \
1821         x264_macroblock_cache_mv_ptr( h, x,y,dx,dy, 0, me0.mv ); \
1822     } \
1823     else \
1824     { \
1825         x264_macroblock_cache_ref( h, x,y,dx,dy, 0, -1 ); \
1826         x264_macroblock_cache_mv(  h, x,y,dx,dy, 0, 0 ); \
1827         if( b_mvd ) \
1828             x264_macroblock_cache_mvd( h, x,y,dx,dy, 0, 0 ); \
1829     } \
1830     if( x264_mb_partition_listX_table[1][part] ) \
1831     { \
1832         x264_macroblock_cache_ref( h, x,y,dx,dy, 1, me1.i_ref ); \
1833         x264_macroblock_cache_mv_ptr( h, x,y,dx,dy, 1, me1.mv ); \
1834     } \
1835     else \
1836     { \
1837         x264_macroblock_cache_ref( h, x,y,dx,dy, 1, -1 ); \
1838         x264_macroblock_cache_mv(  h, x,y,dx,dy, 1, 0 ); \
1839         if( b_mvd ) \
1840             x264_macroblock_cache_mvd( h, x,y,dx,dy, 1, 0 ); \
1841     }
1842
1843 static inline void x264_mb_cache_mv_b8x8( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
1844 {
1845     int x = (i%2)*2;
1846     int y = (i/2)*2;
1847     if( h->mb.i_sub_partition[i] == D_DIRECT_8x8 )
1848     {
1849         x264_mb_load_mv_direct8x8( h, i );
1850         if( b_mvd )
1851         {
1852             x264_macroblock_cache_mvd(  h, x, y, 2, 2, 0, 0 );
1853             x264_macroblock_cache_mvd(  h, x, y, 2, 2, 1, 0 );
1854             x264_macroblock_cache_skip( h, x, y, 2, 2, 1 );
1855         }
1856     }
1857     else
1858     {
1859         CACHE_MV_BI( x, y, 2, 2, a->l0.me8x8[i], a->l1.me8x8[i], h->mb.i_sub_partition[i] );
1860     }
1861 }
1862 static inline void x264_mb_cache_mv_b16x8( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
1863 {
1864     CACHE_MV_BI( 0, 2*i, 4, 2, a->l0.me16x8[i], a->l1.me16x8[i], a->i_mb_partition16x8[i] );
1865 }
1866 static inline void x264_mb_cache_mv_b8x16( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
1867 {
1868     CACHE_MV_BI( 2*i, 0, 2, 4, a->l0.me8x16[i], a->l1.me8x16[i], a->i_mb_partition8x16[i] );
1869 }
1870 #undef CACHE_MV_BI
1871
1872 static void x264_mb_analyse_inter_b8x8_mixed_ref( x264_t *h, x264_mb_analysis_t *a )
1873 {
1874     ALIGNED_ARRAY_8( uint8_t, pix,[2],[8*8] );
1875     int i_maxref[2] = {h->mb.pic.i_fref[0]-1, h->mb.pic.i_fref[1]-1};
1876
1877     /* early termination: if 16x16 chose ref 0, then evalute no refs older
1878      * than those used by the neighbors */
1879     #define CHECK_NEIGHBOUR(i)\
1880     {\
1881         int ref = h->mb.cache.ref[l][X264_SCAN8_0+i];\
1882         if( ref > i_maxref[l] )\
1883             i_maxref[l] = ref;\
1884     }
1885
1886     for( int l = 0; l < 2; l++ )
1887     {
1888         x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
1889         if( i_maxref[l] > 0 && lX->me16x16.i_ref == 0 &&
1890             h->mb.i_mb_type_top > 0 && h->mb.i_mb_type_left > 0 )
1891         {
1892             i_maxref[l] = 0;
1893             CHECK_NEIGHBOUR(  -8 - 1 );
1894             CHECK_NEIGHBOUR(  -8 + 0 );
1895             CHECK_NEIGHBOUR(  -8 + 2 );
1896             CHECK_NEIGHBOUR(  -8 + 4 );
1897             CHECK_NEIGHBOUR(   0 - 1 );
1898             CHECK_NEIGHBOUR( 2*8 - 1 );
1899         }
1900     }
1901
1902     /* XXX Needed for x264_mb_predict_mv */
1903     h->mb.i_partition = D_8x8;
1904
1905     a->i_cost8x8bi = 0;
1906
1907     for( int i = 0; i < 4; i++ )
1908     {
1909         int x8 = i%2;
1910         int y8 = i/2;
1911         int i_part_cost;
1912         int i_part_cost_bi;
1913         int stride[2] = {8,8};
1914         uint8_t *src[2];
1915         x264_me_t m;
1916         m.i_pixel = PIXEL_8x8;
1917         LOAD_FENC( &m, h->mb.pic.p_fenc, 8*x8, 8*y8 );
1918
1919         for( int l = 0; l < 2; l++ )
1920         {
1921             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
1922
1923             lX->me8x8[i].cost = INT_MAX;
1924             for( int i_ref = 0; i_ref <= i_maxref[l]; i_ref++ )
1925             {
1926                 m.i_ref_cost = REF_COST( l, i_ref );;
1927
1928                 LOAD_HPELS( &m, h->mb.pic.p_fref[l][i_ref], l, i_ref, 8*x8, 8*y8 );
1929
1930                 x264_macroblock_cache_ref( h, x8*2, y8*2, 2, 2, l, i_ref );
1931                 x264_mb_predict_mv( h, l, 4*i, 2, m.mvp );
1932                 x264_me_search( h, &m, lX->mvc[i_ref], i+1 );
1933                 m.cost += m.i_ref_cost;
1934
1935                 if( m.cost < lX->me8x8[i].cost )
1936                 {
1937                     h->mc.memcpy_aligned( &lX->me8x8[i], &m, sizeof(x264_me_t) );
1938                     a->i_satd8x8[l][i] = m.cost - ( m.cost_mv + m.i_ref_cost );
1939                 }
1940
1941                 /* save mv for predicting other partitions within this MB */
1942                 CP32( lX->mvc[i_ref][i+1], m.mv );
1943             }
1944         }
1945
1946         /* BI mode */
1947         src[0] = h->mc.get_ref( pix[0], &stride[0], a->l0.me8x8[i].p_fref, a->l0.me8x8[i].i_stride[0],
1948                                 a->l0.me8x8[i].mv[0], a->l0.me8x8[i].mv[1], 8, 8, weight_none );
1949         src[1] = h->mc.get_ref( pix[1], &stride[1], a->l1.me8x8[i].p_fref, a->l1.me8x8[i].i_stride[0],
1950                                 a->l1.me8x8[i].mv[0], a->l1.me8x8[i].mv[1], 8, 8, weight_none );
1951         h->mc.avg[PIXEL_8x8]( pix[0], 8, src[0], stride[0], src[1], stride[1],
1952                                 h->mb.bipred_weight[a->l0.me8x8[i].i_ref][a->l1.me8x8[i].i_ref] );
1953
1954         a->i_satd8x8[2][i] = h->pixf.mbcmp[PIXEL_8x8]( a->l0.me8x8[i].p_fenc[0], FENC_STRIDE, pix[0], 8 );
1955         i_part_cost_bi = a->i_satd8x8[2][i] + a->l0.me8x8[i].cost_mv + a->l1.me8x8[i].cost_mv
1956                          + a->l0.me8x8[i].i_ref_cost + a->l1.me8x8[i].i_ref_cost
1957                          + a->i_lambda * i_sub_mb_b_cost_table[D_BI_8x8];
1958
1959         a->l0.me8x8[i].cost += a->i_lambda * i_sub_mb_b_cost_table[D_L0_8x8];
1960         a->l1.me8x8[i].cost += a->i_lambda * i_sub_mb_b_cost_table[D_L1_8x8];
1961
1962         i_part_cost = a->l0.me8x8[i].cost;
1963         h->mb.i_sub_partition[i] = D_L0_8x8;
1964         COPY2_IF_LT( i_part_cost, a->l1.me8x8[i].cost, h->mb.i_sub_partition[i], D_L1_8x8 );
1965         COPY2_IF_LT( i_part_cost, i_part_cost_bi, h->mb.i_sub_partition[i], D_BI_8x8 );
1966         COPY2_IF_LT( i_part_cost, a->i_cost8x8direct[i], h->mb.i_sub_partition[i], D_DIRECT_8x8 );
1967         a->i_cost8x8bi += i_part_cost;
1968
1969         /* XXX Needed for x264_mb_predict_mv */
1970         x264_mb_cache_mv_b8x8( h, a, i, 0 );
1971     }
1972
1973     /* mb type cost */
1974     a->i_cost8x8bi += a->i_lambda * i_mb_b_cost_table[B_8x8];
1975 }
1976
1977 static void x264_mb_analyse_inter_b8x8( x264_t *h, x264_mb_analysis_t *a )
1978 {
1979     uint8_t **p_fref[2] =
1980         { h->mb.pic.p_fref[0][a->l0.me16x16.i_ref],
1981           h->mb.pic.p_fref[1][a->l1.me16x16.i_ref] };
1982     ALIGNED_ARRAY_8( uint8_t, pix,[2],[8*8] );
1983
1984     /* XXX Needed for x264_mb_predict_mv */
1985     h->mb.i_partition = D_8x8;
1986
1987     a->i_cost8x8bi = 0;
1988
1989     for( int i = 0; i < 4; i++ )
1990     {
1991         const int x8 = i%2;
1992         const int y8 = i/2;
1993         int i_part_cost;
1994         int i_part_cost_bi = 0;
1995         int stride[2] = {8,8};
1996         uint8_t *src[2];
1997
1998         for( int l = 0; l < 2; l++ )
1999         {
2000             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
2001             x264_me_t *m = &lX->me8x8[i];
2002             m->i_pixel = PIXEL_8x8;
2003             LOAD_FENC( m, h->mb.pic.p_fenc, 8*x8, 8*y8 );
2004
2005             m->i_ref_cost = REF_COST( l, lX->me16x16.i_ref );
2006             m->i_ref = lX->me16x16.i_ref;
2007
2008             LOAD_HPELS( m, p_fref[l], l, lX->me16x16.i_ref, 8*x8, 8*y8 );
2009
2010             x264_macroblock_cache_ref( h, x8*2, y8*2, 2, 2, l, lX->me16x16.i_ref );
2011             x264_mb_predict_mv( h, l, 4*i, 2, m->mvp );
2012             x264_me_search( h, m, &lX->me16x16.mv, 1 );
2013             a->i_satd8x8[l][i] = m->cost - m->cost_mv;
2014             m->cost += m->i_ref_cost;
2015
2016             x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, l, m->mv );
2017
2018             /* save mv for predicting other partitions within this MB */
2019             CP32( lX->mvc[lX->me16x16.i_ref][i+1], m->mv );
2020
2021             /* BI mode */
2022             src[l] = h->mc.get_ref( pix[l], &stride[l], m->p_fref, m->i_stride[0],
2023                                     m->mv[0], m->mv[1], 8, 8, weight_none );
2024             i_part_cost_bi += m->cost_mv + m->i_ref_cost;
2025         }
2026         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] );
2027         a->i_satd8x8[2][i] = h->pixf.mbcmp[PIXEL_8x8]( a->l0.me8x8[i].p_fenc[0], FENC_STRIDE, pix[0], 8 );
2028         i_part_cost_bi += a->i_satd8x8[2][i] + a->i_lambda * i_sub_mb_b_cost_table[D_BI_8x8];
2029         a->l0.me8x8[i].cost += a->i_lambda * i_sub_mb_b_cost_table[D_L0_8x8];
2030         a->l1.me8x8[i].cost += a->i_lambda * i_sub_mb_b_cost_table[D_L1_8x8];
2031
2032         i_part_cost = a->l0.me8x8[i].cost;
2033         h->mb.i_sub_partition[i] = D_L0_8x8;
2034         COPY2_IF_LT( i_part_cost, a->l1.me8x8[i].cost, h->mb.i_sub_partition[i], D_L1_8x8 );
2035         COPY2_IF_LT( i_part_cost, i_part_cost_bi, h->mb.i_sub_partition[i], D_BI_8x8 );
2036         COPY2_IF_LT( i_part_cost, a->i_cost8x8direct[i], h->mb.i_sub_partition[i], D_DIRECT_8x8 );
2037         a->i_cost8x8bi += i_part_cost;
2038
2039         /* XXX Needed for x264_mb_predict_mv */
2040         x264_mb_cache_mv_b8x8( h, a, i, 0 );
2041     }
2042
2043     /* mb type cost */
2044     a->i_cost8x8bi += a->i_lambda * i_mb_b_cost_table[B_8x8];
2045 }
2046
2047 static void x264_mb_analyse_inter_b16x8( x264_t *h, x264_mb_analysis_t *a, int i_best_satd )
2048 {
2049     ALIGNED_ARRAY_16( uint8_t, pix,[2],[16*8] );
2050     ALIGNED_4( int16_t mvc[3][2] );
2051
2052     h->mb.i_partition = D_16x8;
2053     a->i_cost16x8bi = 0;
2054
2055     for( int i = 0; i < 2; i++ )
2056     {
2057         int i_part_cost;
2058         int i_part_cost_bi = 0;
2059         int stride[2] = {16,16};
2060         uint8_t *src[2];
2061         x264_me_t m;
2062         m.i_pixel = PIXEL_16x8;
2063         LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 8*i );
2064
2065         for( int l = 0; l < 2; l++ )
2066         {
2067             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
2068             int ref8[2] = { lX->me8x8[2*i].i_ref, lX->me8x8[2*i+1].i_ref };
2069             int i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;
2070             lX->me16x8[i].cost = INT_MAX;
2071             for( int j = 0; j < i_ref8s; j++ )
2072             {
2073                 int i_ref = ref8[j];
2074                 m.i_ref_cost = REF_COST( l, i_ref );;
2075
2076                 LOAD_HPELS( &m, h->mb.pic.p_fref[l][i_ref], l, i_ref, 0, 8*i );
2077
2078                 CP32( mvc[0], lX->mvc[i_ref][0] );
2079                 CP32( mvc[1], lX->mvc[i_ref][2*i+1] );
2080                 CP32( mvc[2], lX->mvc[i_ref][2*i+2] );
2081
2082                 x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, l, i_ref );
2083                 x264_mb_predict_mv( h, l, 8*i, 4, m.mvp );
2084                 x264_me_search( h, &m, mvc, 3 );
2085                 m.cost += m.i_ref_cost;
2086
2087                 if( m.cost < lX->me16x8[i].cost )
2088                     h->mc.memcpy_aligned( &lX->me16x8[i], &m, sizeof(x264_me_t) );
2089             }
2090         }
2091
2092         /* BI mode */
2093         src[0] = h->mc.get_ref( pix[0], &stride[0], a->l0.me16x8[i].p_fref, a->l0.me16x8[i].i_stride[0],
2094                                 a->l0.me16x8[i].mv[0], a->l0.me16x8[i].mv[1], 16, 8, weight_none );
2095         src[1] = h->mc.get_ref( pix[1], &stride[1], a->l1.me16x8[i].p_fref, a->l1.me16x8[i].i_stride[0],
2096                                 a->l1.me16x8[i].mv[0], a->l1.me16x8[i].mv[1], 16, 8, weight_none );
2097         h->mc.avg[PIXEL_16x8]( pix[0], 16, src[0], stride[0], src[1], stride[1],
2098                                 h->mb.bipred_weight[a->l0.me16x8[i].i_ref][a->l1.me16x8[i].i_ref] );
2099
2100         i_part_cost_bi = h->pixf.mbcmp[PIXEL_16x8]( a->l0.me16x8[i].p_fenc[0], FENC_STRIDE, pix[0], 16 )
2101                         + a->l0.me16x8[i].cost_mv + a->l1.me16x8[i].cost_mv + a->l0.me16x8[i].i_ref_cost
2102                         + a->l1.me16x8[i].i_ref_cost;
2103
2104         i_part_cost = a->l0.me16x8[i].cost;
2105         a->i_mb_partition16x8[i] = D_L0_8x8; /* not actually 8x8, only the L0 matters */
2106
2107         if( a->l1.me16x8[i].cost < i_part_cost )
2108         {
2109             i_part_cost = a->l1.me16x8[i].cost;
2110             a->i_mb_partition16x8[i] = D_L1_8x8;
2111         }
2112         if( i_part_cost_bi + a->i_lambda * 1 < i_part_cost )
2113         {
2114             i_part_cost = i_part_cost_bi;
2115             a->i_mb_partition16x8[i] = D_BI_8x8;
2116         }
2117         a->i_cost16x8bi += i_part_cost;
2118
2119         /* Early termination based on the current SATD score of partition[0]
2120            plus the estimated SATD score of partition[1] */
2121         if( !i && i_part_cost + a->i_cost_est16x8[1] > i_best_satd
2122             * (16 + (!!a->i_mbrd + !!h->mb.i_psy_rd))/16 )
2123         {
2124             a->i_cost16x8bi = COST_MAX;
2125             return;
2126         }
2127
2128         x264_mb_cache_mv_b16x8( h, a, i, 0 );
2129     }
2130
2131     /* mb type cost */
2132     a->i_mb_type16x8 = B_L0_L0
2133         + (a->i_mb_partition16x8[0]>>2) * 3
2134         + (a->i_mb_partition16x8[1]>>2);
2135     a->i_cost16x8bi += a->i_lambda * i_mb_b16x8_cost_table[a->i_mb_type16x8];
2136 }
2137
2138 static void x264_mb_analyse_inter_b8x16( x264_t *h, x264_mb_analysis_t *a, int i_best_satd )
2139 {
2140     ALIGNED_ARRAY_8( uint8_t, pix,[2],[8*16] );
2141     ALIGNED_4( int16_t mvc[3][2] );
2142
2143     h->mb.i_partition = D_8x16;
2144     a->i_cost8x16bi = 0;
2145
2146     for( int i = 0; i < 2; i++ )
2147     {
2148         int i_part_cost;
2149         int i_part_cost_bi = 0;
2150         int stride[2] = {8,8};
2151         uint8_t *src[2];
2152         x264_me_t m;
2153         m.i_pixel = PIXEL_8x16;
2154         LOAD_FENC( &m, h->mb.pic.p_fenc, 8*i, 0 );
2155
2156         for( int l = 0; l < 2; l++ )
2157         {
2158             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
2159             int ref8[2] = { lX->me8x8[i].i_ref, lX->me8x8[i+2].i_ref };
2160             int i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;
2161             lX->me8x16[i].cost = INT_MAX;
2162             for( int j = 0; j < i_ref8s; j++ )
2163             {
2164                 int i_ref = ref8[j];
2165                 m.i_ref_cost = REF_COST( l, i_ref );
2166
2167                 LOAD_HPELS( &m, h->mb.pic.p_fref[l][i_ref], l, i_ref, 8*i, 0 );
2168
2169                 CP32( mvc[0], lX->mvc[i_ref][0] );
2170                 CP32( mvc[1], lX->mvc[i_ref][i+1] );
2171                 CP32( mvc[2], lX->mvc[i_ref][i+3] );
2172
2173                 x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, l, i_ref );
2174                 x264_mb_predict_mv( h, l, 4*i, 2, m.mvp );
2175                 x264_me_search( h, &m, mvc, 3 );
2176                 m.cost += m.i_ref_cost;
2177
2178                 if( m.cost < lX->me8x16[i].cost )
2179                     h->mc.memcpy_aligned( &lX->me8x16[i], &m, sizeof(x264_me_t) );
2180             }
2181         }
2182
2183         /* BI mode */
2184         src[0] = h->mc.get_ref( pix[0], &stride[0], a->l0.me8x16[i].p_fref, a->l0.me8x16[i].i_stride[0],
2185                                 a->l0.me8x16[i].mv[0], a->l0.me8x16[i].mv[1], 8, 16, weight_none );
2186         src[1] = h->mc.get_ref( pix[1], &stride[1], a->l1.me8x16[i].p_fref, a->l1.me8x16[i].i_stride[0],
2187                                 a->l1.me8x16[i].mv[0], a->l1.me8x16[i].mv[1], 8, 16, weight_none );
2188         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] );
2189
2190         i_part_cost_bi = h->pixf.mbcmp[PIXEL_8x16]( a->l0.me8x16[i].p_fenc[0], FENC_STRIDE, pix[0], 8 )
2191                         + a->l0.me8x16[i].cost_mv + a->l1.me8x16[i].cost_mv + a->l0.me8x16[i].i_ref_cost
2192                         + a->l1.me8x16[i].i_ref_cost;
2193
2194         i_part_cost = a->l0.me8x16[i].cost;
2195         a->i_mb_partition8x16[i] = D_L0_8x8;
2196
2197         if( a->l1.me8x16[i].cost < i_part_cost )
2198         {
2199             i_part_cost = a->l1.me8x16[i].cost;
2200             a->i_mb_partition8x16[i] = D_L1_8x8;
2201         }
2202         if( i_part_cost_bi + a->i_lambda * 1 < i_part_cost )
2203         {
2204             i_part_cost = i_part_cost_bi;
2205             a->i_mb_partition8x16[i] = D_BI_8x8;
2206         }
2207         a->i_cost8x16bi += i_part_cost;
2208
2209         /* Early termination based on the current SATD score of partition[0]
2210            plus the estimated SATD score of partition[1] */
2211         if( !i && i_part_cost + a->i_cost_est8x16[1] > i_best_satd
2212             * (16 + (!!a->i_mbrd + !!h->mb.i_psy_rd))/16 )
2213         {
2214             a->i_cost8x16bi = COST_MAX;
2215             return;
2216         }
2217
2218         x264_mb_cache_mv_b8x16( h, a, i, 0 );
2219     }
2220
2221     /* mb type cost */
2222     a->i_mb_type8x16 = B_L0_L0
2223         + (a->i_mb_partition8x16[0]>>2) * 3
2224         + (a->i_mb_partition8x16[1]>>2);
2225     a->i_cost8x16bi += a->i_lambda * i_mb_b16x8_cost_table[a->i_mb_type8x16];
2226 }
2227
2228 static void x264_mb_analyse_p_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd )
2229 {
2230     int thresh = i_satd * 5/4;
2231
2232     h->mb.i_type = P_L0;
2233     if( a->l0.i_rd16x16 == COST_MAX && a->l0.me16x16.cost <= i_satd * 3/2 )
2234     {
2235         h->mb.i_partition = D_16x16;
2236         x264_analyse_update_cache( h, a );
2237         a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
2238     }
2239
2240     if( a->l0.i_cost16x8 <= thresh )
2241     {
2242         h->mb.i_partition = D_16x8;
2243         x264_analyse_update_cache( h, a );
2244         a->l0.i_cost16x8 = x264_rd_cost_mb( h, a->i_lambda2 );
2245     }
2246     else
2247         a->l0.i_cost16x8 = COST_MAX;
2248
2249     if( a->l0.i_cost8x16 <= thresh )
2250     {
2251         h->mb.i_partition = D_8x16;
2252         x264_analyse_update_cache( h, a );
2253         a->l0.i_cost8x16 = x264_rd_cost_mb( h, a->i_lambda2 );
2254     }
2255     else
2256         a->l0.i_cost8x16 = COST_MAX;
2257
2258     if( a->l0.i_cost8x8 <= thresh )
2259     {
2260         h->mb.i_type = P_8x8;
2261         h->mb.i_partition = D_8x8;
2262         if( h->param.analyse.inter & X264_ANALYSE_PSUB8x8 )
2263         {
2264             x264_macroblock_cache_ref( h, 0, 0, 2, 2, 0, a->l0.me8x8[0].i_ref );
2265             x264_macroblock_cache_ref( h, 2, 0, 2, 2, 0, a->l0.me8x8[1].i_ref );
2266             x264_macroblock_cache_ref( h, 0, 2, 2, 2, 0, a->l0.me8x8[2].i_ref );
2267             x264_macroblock_cache_ref( h, 2, 2, 2, 2, 0, a->l0.me8x8[3].i_ref );
2268             /* FIXME: In the 8x8 blocks where RDO isn't run, the NNZ values used for context selection
2269              * for future blocks are those left over from previous RDO calls. */
2270             for( int i = 0; i < 4; i++ )
2271             {
2272                 int costs[4] = {a->l0.i_cost4x4[i], a->l0.i_cost8x4[i], a->l0.i_cost4x8[i], a->l0.me8x8[i].cost};
2273                 int sub8x8_thresh = X264_MIN4( costs[0], costs[1], costs[2], costs[3] ) * 5 / 4;
2274                 int subtype, btype = D_L0_8x8;
2275                 uint64_t bcost = COST_MAX64;
2276                 for( subtype = D_L0_4x4; subtype <= D_L0_8x8; subtype++ )
2277                 {
2278                     uint64_t cost;
2279                     if( costs[subtype] > sub8x8_thresh || (subtype == D_L0_8x8 && bcost == COST_MAX64) )
2280                         continue;
2281                     h->mb.i_sub_partition[i] = subtype;
2282                     x264_mb_cache_mv_p8x8( h, a, i );
2283                     cost = x264_rd_cost_part( h, a->i_lambda2, i<<2, PIXEL_8x8 );
2284                     COPY2_IF_LT( bcost, cost, btype, subtype );
2285                 }
2286                 if( h->mb.i_sub_partition[i] != btype )
2287                 {
2288                     h->mb.i_sub_partition[i] = btype;
2289                     x264_mb_cache_mv_p8x8( h, a, i );
2290                 }
2291             }
2292         }
2293         else
2294             x264_analyse_update_cache( h, a );
2295         a->l0.i_cost8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
2296     }
2297     else
2298         a->l0.i_cost8x8 = COST_MAX;
2299 }
2300
2301 static void x264_mb_analyse_b_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd_inter )
2302 {
2303     int thresh = i_satd_inter * (17 + (!!h->mb.i_psy_rd))/16;
2304
2305     if( a->b_direct_available && a->i_rd16x16direct == COST_MAX )
2306     {
2307         h->mb.i_type = B_DIRECT;
2308         /* Assumes direct/skip MC is still in fdec */
2309         /* Requires b-rdo to be done before intra analysis */
2310         h->mb.b_skip_mc = 1;
2311         x264_analyse_update_cache( h, a );
2312         a->i_rd16x16direct = x264_rd_cost_mb( h, a->i_lambda2 );
2313         h->mb.b_skip_mc = 0;
2314     }
2315
2316     //FIXME not all the update_cache calls are needed
2317     h->mb.i_partition = D_16x16;
2318     /* L0 */
2319     if( a->l0.me16x16.cost <= thresh && a->l0.i_rd16x16 == COST_MAX )
2320     {
2321         h->mb.i_type = B_L0_L0;
2322         x264_analyse_update_cache( h, a );
2323         a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
2324     }
2325
2326     /* L1 */
2327     if( a->l1.me16x16.cost <= thresh && a->l1.i_rd16x16 == COST_MAX )
2328     {
2329         h->mb.i_type = B_L1_L1;
2330         x264_analyse_update_cache( h, a );
2331         a->l1.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
2332     }
2333
2334     /* BI */
2335     if( a->i_cost16x16bi <= thresh && a->i_rd16x16bi == COST_MAX )
2336     {
2337         h->mb.i_type = B_BI_BI;
2338         x264_analyse_update_cache( h, a );
2339         a->i_rd16x16bi = x264_rd_cost_mb( h, a->i_lambda2 );
2340     }
2341
2342     /* 8x8 */
2343     if( a->i_cost8x8bi <= thresh && a->i_rd8x8bi == COST_MAX )
2344     {
2345         h->mb.i_type = B_8x8;
2346         h->mb.i_partition = D_8x8;
2347         x264_analyse_update_cache( h, a );
2348         a->i_rd8x8bi = x264_rd_cost_mb( h, a->i_lambda2 );
2349         x264_macroblock_cache_skip( h, 0, 0, 4, 4, 0 );
2350     }
2351
2352     /* 16x8 */
2353     if( a->i_cost16x8bi <= thresh && a->i_rd16x8bi == COST_MAX )
2354     {
2355         h->mb.i_type = a->i_mb_type16x8;
2356         h->mb.i_partition = D_16x8;
2357         x264_analyse_update_cache( h, a );
2358         a->i_rd16x8bi = x264_rd_cost_mb( h, a->i_lambda2 );
2359     }
2360
2361     /* 8x16 */
2362     if( a->i_cost8x16bi <= thresh && a->i_rd8x16bi == COST_MAX )
2363     {
2364         h->mb.i_type = a->i_mb_type8x16;
2365         h->mb.i_partition = D_8x16;
2366         x264_analyse_update_cache( h, a );
2367         a->i_rd8x16bi = x264_rd_cost_mb( h, a->i_lambda2 );
2368     }
2369 }
2370
2371 static void x264_refine_bidir( x264_t *h, x264_mb_analysis_t *a )
2372 {
2373     int i_biweight;
2374
2375     if( IS_INTRA(h->mb.i_type) )
2376         return;
2377
2378     switch( h->mb.i_partition )
2379     {
2380         case D_16x16:
2381             if( h->mb.i_type == B_BI_BI )
2382             {
2383                 i_biweight = h->mb.bipred_weight[a->l0.bi16x16.i_ref][a->l1.bi16x16.i_ref];
2384                 x264_me_refine_bidir_satd( h, &a->l0.bi16x16, &a->l1.bi16x16, i_biweight );
2385             }
2386             break;
2387         case D_16x8:
2388             for( int i = 0; i < 2; i++ )
2389                 if( a->i_mb_partition16x8[i] == D_BI_8x8 )
2390                 {
2391                     i_biweight = h->mb.bipred_weight[a->l0.me16x8[i].i_ref][a->l1.me16x8[i].i_ref];
2392                     x264_me_refine_bidir_satd( h, &a->l0.me16x8[i], &a->l1.me16x8[i], i_biweight );
2393                 }
2394             break;
2395         case D_8x16:
2396             for( int i = 0; i < 2; i++ )
2397                 if( a->i_mb_partition8x16[i] == D_BI_8x8 )
2398                 {
2399                     i_biweight = h->mb.bipred_weight[a->l0.me8x16[i].i_ref][a->l1.me8x16[i].i_ref];
2400                     x264_me_refine_bidir_satd( h, &a->l0.me8x16[i], &a->l1.me8x16[i], i_biweight );
2401                 }
2402             break;
2403         case D_8x8:
2404             for( int i = 0; i < 4; i++ )
2405                 if( h->mb.i_sub_partition[i] == D_BI_8x8 )
2406                 {
2407                     i_biweight = h->mb.bipred_weight[a->l0.me8x8[i].i_ref][a->l1.me8x8[i].i_ref];
2408                     x264_me_refine_bidir_satd( h, &a->l0.me8x8[i], &a->l1.me8x8[i], i_biweight );
2409                 }
2410             break;
2411     }
2412 }
2413
2414 static inline void x264_mb_analyse_transform( x264_t *h )
2415 {
2416     if( x264_mb_transform_8x8_allowed( h ) && h->param.analyse.b_transform_8x8 && !h->mb.b_lossless )
2417     {
2418         /* Only luma MC is really needed, but the full MC is re-used in macroblock_encode. */
2419         x264_mb_mc( h );
2420
2421         int i_cost8 = h->pixf.sa8d[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE,
2422                                              h->mb.pic.p_fdec[0], FDEC_STRIDE );
2423         int i_cost4 = h->pixf.satd[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE,
2424                                              h->mb.pic.p_fdec[0], FDEC_STRIDE );
2425
2426         h->mb.b_transform_8x8 = i_cost8 < i_cost4;
2427         h->mb.b_skip_mc = 1;
2428     }
2429 }
2430
2431 static inline void x264_mb_analyse_transform_rd( x264_t *h, x264_mb_analysis_t *a, int *i_satd, int *i_rd )
2432 {
2433     if( x264_mb_transform_8x8_allowed( h ) && h->param.analyse.b_transform_8x8 )
2434     {
2435         x264_analyse_update_cache( h, a );
2436         h->mb.b_transform_8x8 ^= 1;
2437         /* FIXME only luma is needed, but the score for comparison already includes chroma */
2438         int i_rd8 = x264_rd_cost_mb( h, a->i_lambda2 );
2439
2440         if( *i_rd >= i_rd8 )
2441         {
2442             if( *i_rd > 0 )
2443                 *i_satd = (int64_t)(*i_satd) * i_rd8 / *i_rd;
2444             *i_rd = i_rd8;
2445         }
2446         else
2447             h->mb.b_transform_8x8 ^= 1;
2448     }
2449 }
2450
2451 /* Rate-distortion optimal QP selection.
2452  * FIXME: More than half of the benefit of this function seems to be
2453  * in the way it improves the coding of chroma DC (by decimating or
2454  * finding a better way to code a single DC coefficient.)
2455  * There must be a more efficient way to get that portion of the benefit
2456  * without doing full QP-RD, but RD-decimation doesn't seem to do the
2457  * trick. */
2458 static inline void x264_mb_analyse_qp_rd( x264_t *h, x264_mb_analysis_t *a )
2459 {
2460     int bcost, cost, failures, prevcost, origcost;
2461     int orig_qp = h->mb.i_qp, bqp = h->mb.i_qp;
2462     int last_qp_tried = 0;
2463     origcost = bcost = x264_rd_cost_mb( h, a->i_lambda2 );
2464     int origcbp = h->mb.cbp[h->mb.i_mb_xy];
2465
2466     /* If CBP is already zero, don't raise the quantizer any higher. */
2467     for( int direction = origcbp ? 1 : -1; direction >= -1; direction-=2 )
2468     {
2469         /* Without psy-RD, require monotonicity when moving quant away from previous
2470          * macroblock's quant; allow 1 failure when moving quant towards previous quant.
2471          * With psy-RD, allow 1 failure when moving quant away from previous quant,
2472          * allow 2 failures when moving quant towards previous quant.
2473          * Psy-RD generally seems to result in more chaotic RD score-vs-quantizer curves. */
2474         int threshold = (!!h->mb.i_psy_rd);
2475         /* Raise the threshold for failures if we're moving towards the last QP. */
2476         if( ( h->mb.i_last_qp < orig_qp && direction == -1 ) ||
2477             ( h->mb.i_last_qp > orig_qp && direction ==  1 ) )
2478             threshold++;
2479         h->mb.i_qp = orig_qp;
2480         failures = 0;
2481         prevcost = origcost;
2482
2483         /* If the current QP results in an empty CBP, it's highly likely that lower QPs
2484          * (up to a point) will too.  So, jump down to where the threshold will kick in
2485          * and check the QP there.  If the CBP is still empty, skip the main loop.
2486          * If it isn't empty, we would have ended up having to check this QP anyways,
2487          * so as long as we store it for later lookup, we lose nothing. */
2488         int already_checked_qp = -1;
2489         int already_checked_cost = COST_MAX;
2490         if( direction == -1 )
2491         {
2492             if( !origcbp )
2493             {
2494                 h->mb.i_qp = X264_MAX( h->mb.i_qp - threshold - 1, h->param.rc.i_qp_min );
2495                 h->mb.i_chroma_qp = h->chroma_qp_table[h->mb.i_qp];
2496                 already_checked_cost = x264_rd_cost_mb( h, a->i_lambda2 );
2497                 if( !h->mb.cbp[h->mb.i_mb_xy] )
2498                 {
2499                     /* If our empty-CBP block is lower QP than the last QP,
2500                      * the last QP almost surely doesn't have a CBP either. */
2501                     if( h->mb.i_last_qp > h->mb.i_qp )
2502                         last_qp_tried = 1;
2503                     break;
2504                 }
2505                 already_checked_qp = h->mb.i_qp;
2506                 h->mb.i_qp = orig_qp;
2507             }
2508         }
2509
2510         h->mb.i_qp += direction;
2511         while( h->mb.i_qp >= h->param.rc.i_qp_min && h->mb.i_qp <= h->param.rc.i_qp_max )
2512         {
2513             if( h->mb.i_last_qp == h->mb.i_qp )
2514                 last_qp_tried = 1;
2515             if( h->mb.i_qp == already_checked_qp )
2516                 cost = already_checked_cost;
2517             else
2518             {
2519                 h->mb.i_chroma_qp = h->chroma_qp_table[h->mb.i_qp];
2520                 cost = x264_rd_cost_mb( h, a->i_lambda2 );
2521                 COPY2_IF_LT( bcost, cost, bqp, h->mb.i_qp );
2522             }
2523
2524             /* We can't assume that the costs are monotonic over QPs.
2525              * Tie case-as-failure seems to give better results. */
2526             if( cost < prevcost )
2527                 failures = 0;
2528             else
2529                 failures++;
2530             prevcost = cost;
2531
2532             if( failures > threshold )
2533                 break;
2534             if( direction == 1 && !h->mb.cbp[h->mb.i_mb_xy] )
2535                 break;
2536             h->mb.i_qp += direction;
2537         }
2538     }
2539
2540     /* Always try the last block's QP. */
2541     if( !last_qp_tried )
2542     {
2543         h->mb.i_qp = h->mb.i_last_qp;
2544         h->mb.i_chroma_qp = h->chroma_qp_table[h->mb.i_qp];
2545         cost = x264_rd_cost_mb( h, a->i_lambda2 );
2546         COPY2_IF_LT( bcost, cost, bqp, h->mb.i_qp );
2547     }
2548
2549     h->mb.i_qp = bqp;
2550     h->mb.i_chroma_qp = h->chroma_qp_table[h->mb.i_qp];
2551
2552     /* Check transform again; decision from before may no longer be optimal. */
2553     if( h->mb.i_qp != orig_qp && h->param.analyse.b_transform_8x8 &&
2554         x264_mb_transform_8x8_allowed( h ) )
2555     {
2556         h->mb.b_transform_8x8 ^= 1;
2557         cost = x264_rd_cost_mb( h, a->i_lambda2 );
2558         if( cost > bcost )
2559             h->mb.b_transform_8x8 ^= 1;
2560     }
2561 }
2562
2563 /*****************************************************************************
2564  * x264_macroblock_analyse:
2565  *****************************************************************************/
2566 void x264_macroblock_analyse( x264_t *h )
2567 {
2568     x264_mb_analysis_t analysis;
2569     int i_cost = COST_MAX;
2570
2571     h->mb.i_qp = x264_ratecontrol_qp( h );
2572     if( h->param.rc.i_aq_mode )
2573     {
2574         x264_adaptive_quant( h );
2575         /* If the QP of this MB is within 1 of the previous MB, code the same QP as the previous MB,
2576          * to lower the bit cost of the qp_delta.  Don't do this if QPRD is enabled. */
2577         if( h->param.analyse.i_subpel_refine < 10 && abs(h->mb.i_qp - h->mb.i_last_qp) == 1 )
2578             h->mb.i_qp = h->mb.i_last_qp;
2579     }
2580
2581     x264_mb_analyse_init( h, &analysis, h->mb.i_qp );
2582
2583     /*--------------------------- Do the analysis ---------------------------*/
2584     if( h->sh.i_type == SLICE_TYPE_I )
2585     {
2586 intra_analysis:
2587         if( analysis.i_mbrd )
2588             x264_mb_init_fenc_cache( h, analysis.i_mbrd >= 2 );
2589         x264_mb_analyse_intra( h, &analysis, COST_MAX );
2590         if( analysis.i_mbrd )
2591             x264_intra_rd( h, &analysis, COST_MAX );
2592
2593         i_cost = analysis.i_satd_i16x16;
2594         h->mb.i_type = I_16x16;
2595         COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, h->mb.i_type, I_4x4 );
2596         COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, h->mb.i_type, I_8x8 );
2597         if( analysis.i_satd_pcm < i_cost )
2598             h->mb.i_type = I_PCM;
2599
2600         else if( analysis.i_mbrd >= 2 )
2601             x264_intra_rd_refine( h, &analysis );
2602     }
2603     else if( h->sh.i_type == SLICE_TYPE_P )
2604     {
2605         int b_skip = 0;
2606
2607         h->mc.prefetch_ref( h->mb.pic.p_fref[0][0][h->mb.i_mb_x&3], h->mb.pic.i_stride[0], 0 );
2608
2609         analysis.b_try_skip = 0;
2610         if( analysis.b_force_intra )
2611         {
2612             if( !h->param.analyse.b_psy )
2613             {
2614                 x264_mb_analyse_init_qp( h, &analysis, X264_MAX( h->mb.i_qp - h->mb.ip_offset, h->param.rc.i_qp_min ) );
2615                 goto intra_analysis;
2616             }
2617         }
2618         else
2619         {
2620             /* Fast P_SKIP detection */
2621             if( h->param.analyse.b_fast_pskip )
2622             {
2623                 if( h->i_thread_frames > 1 && h->mb.cache.pskip_mv[1] > h->mb.mv_max_spel[1] )
2624                     // FIXME don't need to check this if the reference frame is done
2625                     {}
2626                 else if( h->param.analyse.i_subpel_refine >= 3 )
2627                     analysis.b_try_skip = 1;
2628                 else if( h->mb.i_mb_type_left == P_SKIP ||
2629                          h->mb.i_mb_type_top == P_SKIP ||
2630                          h->mb.i_mb_type_topleft == P_SKIP ||
2631                          h->mb.i_mb_type_topright == P_SKIP )
2632                     b_skip = x264_macroblock_probe_pskip( h );
2633             }
2634         }
2635
2636         h->mc.prefetch_ref( h->mb.pic.p_fref[0][0][h->mb.i_mb_x&3], h->mb.pic.i_stride[0], 1 );
2637
2638         if( b_skip )
2639         {
2640             h->mb.i_type = P_SKIP;
2641             h->mb.i_partition = D_16x16;
2642             assert( h->mb.cache.pskip_mv[1] <= h->mb.mv_max_spel[1] || h->i_thread_frames == 1 );
2643             /* Set up MVs for future predictors */
2644             if( b_skip )
2645                 for( int i = 0; i < h->mb.pic.i_fref[0]; i++ )
2646                     M32( h->mb.mvr[0][i][h->mb.i_mb_xy] ) = 0;
2647         }
2648         else
2649         {
2650             const unsigned int flags = h->param.analyse.inter;
2651             int i_type;
2652             int i_partition;
2653             int i_thresh16x8;
2654             int i_satd_inter, i_satd_intra;
2655
2656             x264_mb_analyse_load_costs( h, &analysis );
2657
2658             x264_mb_analyse_inter_p16x16( h, &analysis );
2659
2660             if( h->mb.i_type == P_SKIP )
2661             {
2662                 for( int i = 1; i < h->mb.pic.i_fref[0]; i++ )
2663                     M32( h->mb.mvr[0][i][h->mb.i_mb_xy] ) = 0;
2664                 return;
2665             }
2666
2667             if( flags & X264_ANALYSE_PSUB16x16 )
2668             {
2669                 if( h->param.analyse.b_mixed_references )
2670                     x264_mb_analyse_inter_p8x8_mixed_ref( h, &analysis );
2671                 else
2672                     x264_mb_analyse_inter_p8x8( h, &analysis );
2673             }
2674
2675             /* Select best inter mode */
2676             i_type = P_L0;
2677             i_partition = D_16x16;
2678             i_cost = analysis.l0.me16x16.cost;
2679
2680             if( ( flags & X264_ANALYSE_PSUB16x16 ) &&
2681                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost )
2682             {
2683                 i_type = P_8x8;
2684                 i_partition = D_8x8;
2685                 i_cost = analysis.l0.i_cost8x8;
2686
2687                 /* Do sub 8x8 */
2688                 if( flags & X264_ANALYSE_PSUB8x8 )
2689                 {
2690                     for( int i = 0; i < 4; i++ )
2691                     {
2692                         x264_mb_analyse_inter_p4x4( h, &analysis, i );
2693                         if( analysis.l0.i_cost4x4[i] < analysis.l0.me8x8[i].cost )
2694                         {
2695                             int i_cost8x8 = analysis.l0.i_cost4x4[i];
2696                             h->mb.i_sub_partition[i] = D_L0_4x4;
2697
2698                             x264_mb_analyse_inter_p8x4( h, &analysis, i );
2699                             COPY2_IF_LT( i_cost8x8, analysis.l0.i_cost8x4[i],
2700                                          h->mb.i_sub_partition[i], D_L0_8x4 );
2701
2702                             x264_mb_analyse_inter_p4x8( h, &analysis, i );
2703                             COPY2_IF_LT( i_cost8x8, analysis.l0.i_cost4x8[i],
2704                                          h->mb.i_sub_partition[i], D_L0_4x8 );
2705
2706                             i_cost += i_cost8x8 - analysis.l0.me8x8[i].cost;
2707                         }
2708                         x264_mb_cache_mv_p8x8( h, &analysis, i );
2709                     }
2710                     analysis.l0.i_cost8x8 = i_cost;
2711                 }
2712             }
2713
2714             /* Now do 16x8/8x16 */
2715             i_thresh16x8 = analysis.l0.me8x8[1].cost_mv + analysis.l0.me8x8[2].cost_mv;
2716             if( ( flags & X264_ANALYSE_PSUB16x16 ) &&
2717                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost + i_thresh16x8 )
2718             {
2719                 int i_avg_mv_ref_cost = (analysis.l0.me8x8[2].cost_mv + analysis.l0.me8x8[2].i_ref_cost
2720                                       + analysis.l0.me8x8[3].cost_mv + analysis.l0.me8x8[3].i_ref_cost + 1) >> 1;
2721                 analysis.i_cost_est16x8[1] = analysis.i_satd8x8[0][2] + analysis.i_satd8x8[0][3] + i_avg_mv_ref_cost;
2722
2723                 x264_mb_analyse_inter_p16x8( h, &analysis, i_cost );
2724                 COPY3_IF_LT( i_cost, analysis.l0.i_cost16x8, i_type, P_L0, i_partition, D_16x8 );
2725
2726                 i_avg_mv_ref_cost = (analysis.l0.me8x8[1].cost_mv + analysis.l0.me8x8[1].i_ref_cost
2727                                   + analysis.l0.me8x8[3].cost_mv + analysis.l0.me8x8[3].i_ref_cost + 1) >> 1;
2728                 analysis.i_cost_est8x16[1] = analysis.i_satd8x8[0][1] + analysis.i_satd8x8[0][3] + i_avg_mv_ref_cost;
2729
2730                 x264_mb_analyse_inter_p8x16( h, &analysis, i_cost );
2731                 COPY3_IF_LT( i_cost, analysis.l0.i_cost8x16, i_type, P_L0, i_partition, D_8x16 );
2732             }
2733
2734             h->mb.i_partition = i_partition;
2735
2736             /* refine qpel */
2737             //FIXME mb_type costs?
2738             if( analysis.i_mbrd || !h->mb.i_subpel_refine )
2739             {
2740                 /* refine later */
2741             }
2742             else if( i_partition == D_16x16 )
2743             {
2744                 x264_me_refine_qpel( h, &analysis.l0.me16x16 );
2745                 i_cost = analysis.l0.me16x16.cost;
2746             }
2747             else if( i_partition == D_16x8 )
2748             {
2749                 x264_me_refine_qpel( h, &analysis.l0.me16x8[0] );
2750                 x264_me_refine_qpel( h, &analysis.l0.me16x8[1] );
2751                 i_cost = analysis.l0.me16x8[0].cost + analysis.l0.me16x8[1].cost;
2752             }
2753             else if( i_partition == D_8x16 )
2754             {
2755                 x264_me_refine_qpel( h, &analysis.l0.me8x16[0] );
2756                 x264_me_refine_qpel( h, &analysis.l0.me8x16[1] );
2757                 i_cost = analysis.l0.me8x16[0].cost + analysis.l0.me8x16[1].cost;
2758             }
2759             else if( i_partition == D_8x8 )
2760             {
2761                 i_cost = 0;
2762                 for( int i8x8 = 0; i8x8 < 4; i8x8++ )
2763                 {
2764                     switch( h->mb.i_sub_partition[i8x8] )
2765                     {
2766                         case D_L0_8x8:
2767                             x264_me_refine_qpel( h, &analysis.l0.me8x8[i8x8] );
2768                             i_cost += analysis.l0.me8x8[i8x8].cost;
2769                             break;
2770                         case D_L0_8x4:
2771                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][0] );
2772                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][1] );
2773                             i_cost += analysis.l0.me8x4[i8x8][0].cost +
2774                                       analysis.l0.me8x4[i8x8][1].cost;
2775                             break;
2776                         case D_L0_4x8:
2777                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][0] );
2778                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][1] );
2779                             i_cost += analysis.l0.me4x8[i8x8][0].cost +
2780                                       analysis.l0.me4x8[i8x8][1].cost;
2781                             break;
2782
2783                         case D_L0_4x4:
2784                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][0] );
2785                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][1] );
2786                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][2] );
2787                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][3] );
2788                             i_cost += analysis.l0.me4x4[i8x8][0].cost +
2789                                       analysis.l0.me4x4[i8x8][1].cost +
2790                                       analysis.l0.me4x4[i8x8][2].cost +
2791                                       analysis.l0.me4x4[i8x8][3].cost;
2792                             break;
2793                         default:
2794                             x264_log( h, X264_LOG_ERROR, "internal error (!8x8 && !4x4)\n" );
2795                             break;
2796                     }
2797                 }
2798             }
2799
2800             if( h->mb.b_chroma_me )
2801             {
2802                 x264_mb_analyse_intra_chroma( h, &analysis );
2803                 x264_mb_analyse_intra( h, &analysis, i_cost - analysis.i_satd_i8x8chroma );
2804                 analysis.i_satd_i16x16 += analysis.i_satd_i8x8chroma;
2805                 analysis.i_satd_i8x8 += analysis.i_satd_i8x8chroma;
2806                 analysis.i_satd_i4x4 += analysis.i_satd_i8x8chroma;
2807             }
2808             else
2809                 x264_mb_analyse_intra( h, &analysis, i_cost );
2810
2811             i_satd_inter = i_cost;
2812             i_satd_intra = X264_MIN3( analysis.i_satd_i16x16,
2813                                       analysis.i_satd_i8x8,
2814                                       analysis.i_satd_i4x4 );
2815
2816             if( analysis.i_mbrd )
2817             {
2818                 x264_mb_analyse_p_rd( h, &analysis, X264_MIN(i_satd_inter, i_satd_intra) );
2819                 i_type = P_L0;
2820                 i_partition = D_16x16;
2821                 i_cost = analysis.l0.i_rd16x16;
2822                 COPY2_IF_LT( i_cost, analysis.l0.i_cost16x8, i_partition, D_16x8 );
2823                 COPY2_IF_LT( i_cost, analysis.l0.i_cost8x16, i_partition, D_8x16 );
2824                 COPY3_IF_LT( i_cost, analysis.l0.i_cost8x8, i_partition, D_8x8, i_type, P_8x8 );
2825                 h->mb.i_type = i_type;
2826                 h->mb.i_partition = i_partition;
2827                 if( i_cost < COST_MAX )
2828                     x264_mb_analyse_transform_rd( h, &analysis, &i_satd_inter, &i_cost );
2829                 x264_intra_rd( h, &analysis, i_satd_inter * 5/4 );
2830             }
2831
2832             COPY2_IF_LT( i_cost, analysis.i_satd_i16x16, i_type, I_16x16 );
2833             COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, i_type, I_8x8 );
2834             COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, i_type, I_4x4 );
2835             COPY2_IF_LT( i_cost, analysis.i_satd_pcm, i_type, I_PCM );
2836
2837             h->mb.i_type = i_type;
2838
2839             if( analysis.b_force_intra && !IS_INTRA(i_type) )
2840             {
2841                 /* Intra masking: copy fdec to fenc and re-encode the block as intra in order to make it appear as if
2842                  * it was an inter block. */
2843                 x264_analyse_update_cache( h, &analysis );
2844                 x264_macroblock_encode( h );
2845                 h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE, h->mb.pic.p_fdec[0], FDEC_STRIDE, 16 );
2846                 h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fenc[1], FENC_STRIDE, h->mb.pic.p_fdec[1], FDEC_STRIDE, 8 );
2847                 h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fenc[2], FENC_STRIDE, h->mb.pic.p_fdec[2], FDEC_STRIDE, 8 );
2848                 x264_mb_analyse_init_qp( h, &analysis, X264_MAX( h->mb.i_qp - h->mb.ip_offset, h->param.rc.i_qp_min ) );
2849                 goto intra_analysis;
2850             }
2851
2852             if( analysis.i_mbrd >= 2 && h->mb.i_type != I_PCM )
2853             {
2854                 if( IS_INTRA( h->mb.i_type ) )
2855                 {
2856                     x264_intra_rd_refine( h, &analysis );
2857                 }
2858                 else if( i_partition == D_16x16 )
2859                 {
2860                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.i_ref );
2861                     analysis.l0.me16x16.cost = i_cost;
2862                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x16, analysis.i_lambda2, 0, 0 );
2863                 }
2864                 else if( i_partition == D_16x8 )
2865                 {
2866                     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
2867                     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
2868                     x264_macroblock_cache_ref( h, 0, 0, 4, 2, 0, analysis.l0.me16x8[0].i_ref );
2869                     x264_macroblock_cache_ref( h, 0, 2, 4, 2, 0, analysis.l0.me16x8[1].i_ref );
2870                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[0], analysis.i_lambda2, 0, 0 );
2871                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[1], analysis.i_lambda2, 8, 0 );
2872                 }
2873                 else if( i_partition == D_8x16 )
2874                 {
2875                     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
2876                     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
2877                     x264_macroblock_cache_ref( h, 0, 0, 2, 4, 0, analysis.l0.me8x16[0].i_ref );
2878                     x264_macroblock_cache_ref( h, 2, 0, 2, 4, 0, analysis.l0.me8x16[1].i_ref );
2879                     x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[0], analysis.i_lambda2, 0, 0 );
2880                     x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[1], analysis.i_lambda2, 4, 0 );
2881                 }
2882                 else if( i_partition == D_8x8 )
2883                 {
2884                     x264_analyse_update_cache( h, &analysis );
2885                     for( int i8x8 = 0; i8x8 < 4; i8x8++ )
2886                     {
2887                         if( h->mb.i_sub_partition[i8x8] == D_L0_8x8 )
2888                         {
2889                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x8[i8x8], analysis.i_lambda2, i8x8*4, 0 );
2890                         }
2891                         else if( h->mb.i_sub_partition[i8x8] == D_L0_8x4 )
2892                         {
2893                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x4[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
2894                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x4[i8x8][1], analysis.i_lambda2, i8x8*4+2, 0 );
2895                         }
2896                         else if( h->mb.i_sub_partition[i8x8] == D_L0_4x8 )
2897                         {
2898                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x8[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
2899                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x8[i8x8][1], analysis.i_lambda2, i8x8*4+1, 0 );
2900                         }
2901                         else if( h->mb.i_sub_partition[i8x8] == D_L0_4x4 )
2902                         {
2903                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][0], analysis.i_lambda2, i8x8*4+0, 0 );
2904                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][1], analysis.i_lambda2, i8x8*4+1, 0 );
2905                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][2], analysis.i_lambda2, i8x8*4+2, 0 );
2906                             x264_me_refine_qpel_rd( h, &analysis.l0.me4x4[i8x8][3], analysis.i_lambda2, i8x8*4+3, 0 );
2907                         }
2908                     }
2909                 }
2910             }
2911         }
2912     }
2913     else if( h->sh.i_type == SLICE_TYPE_B )
2914     {
2915         int i_bskip_cost = COST_MAX;
2916         int b_skip = 0;
2917
2918         if( analysis.i_mbrd )
2919             x264_mb_init_fenc_cache( h, analysis.i_mbrd >= 2 );
2920
2921         h->mb.i_type = B_SKIP;
2922         if( h->mb.b_direct_auto_write )
2923         {
2924             /* direct=auto heuristic: prefer whichever mode allows more Skip macroblocks */
2925             for( int i = 0; i < 2; i++ )
2926             {
2927                 int b_changed = 1;
2928                 h->sh.b_direct_spatial_mv_pred ^= 1;
2929                 analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h, i && analysis.b_direct_available ? &b_changed : NULL );
2930                 if( analysis.b_direct_available )
2931                 {
2932                     if( b_changed )
2933                     {
2934                         x264_mb_mc( h );
2935                         b_skip = x264_macroblock_probe_bskip( h );
2936                     }
2937                     h->stat.frame.i_direct_score[ h->sh.b_direct_spatial_mv_pred ] += b_skip;
2938                 }
2939                 else
2940                     b_skip = 0;
2941             }
2942         }
2943         else
2944             analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h, NULL );
2945
2946         analysis.b_try_skip = 0;
2947         if( analysis.b_direct_available )
2948         {
2949             if( !h->mb.b_direct_auto_write )
2950                 x264_mb_mc( h );
2951             if( analysis.i_mbrd )
2952             {
2953                 i_bskip_cost = ssd_mb( h );
2954                 /* 6 = minimum cavlc cost of a non-skipped MB */
2955                 b_skip = h->mb.b_skip_mc = i_bskip_cost <= ((6 * analysis.i_lambda2 + 128) >> 8);
2956             }
2957             else if( !h->mb.b_direct_auto_write )
2958             {
2959                 /* Conditioning the probe on neighboring block types
2960                  * doesn't seem to help speed or quality. */
2961                 analysis.b_try_skip = x264_macroblock_probe_bskip( h );
2962                 if( h->param.analyse.i_subpel_refine < 3 )
2963                     b_skip = analysis.b_try_skip;
2964             }
2965             /* Set up MVs for future predictors */
2966             if( b_skip )
2967             {
2968                 for( int i = 0; i < h->mb.pic.i_fref[0]; i++ )
2969                     M32( h->mb.mvr[0][i][h->mb.i_mb_xy] ) = 0;
2970                 for( int i = 0; i < h->mb.pic.i_fref[1]; i++ )
2971                     M32( h->mb.mvr[1][i][h->mb.i_mb_xy] ) = 0;
2972             }
2973         }
2974
2975         if( !b_skip )
2976         {
2977             const unsigned int flags = h->param.analyse.inter;
2978             int i_type;
2979             int i_partition;
2980             int i_satd_inter;
2981             h->mb.b_skip_mc = 0;
2982             h->mb.i_type = B_DIRECT;
2983
2984             x264_mb_analyse_load_costs( h, &analysis );
2985
2986             /* select best inter mode */
2987             /* direct must be first */
2988             if( analysis.b_direct_available )
2989                 x264_mb_analyse_inter_direct( h, &analysis );
2990
2991             x264_mb_analyse_inter_b16x16( h, &analysis );
2992
2993             if( h->mb.i_type == B_SKIP )
2994             {
2995                 for( int i = 1; i < h->mb.pic.i_fref[0]; i++ )
2996                     M32( h->mb.mvr[0][i][h->mb.i_mb_xy] ) = 0;
2997                 for( int i = 1; i < h->mb.pic.i_fref[1]; i++ )
2998                     M32( h->mb.mvr[0][i][h->mb.i_mb_xy] ) = 0;
2999                 return;
3000             }
3001
3002             i_type = B_L0_L0;
3003             i_partition = D_16x16;
3004             i_cost = analysis.l0.me16x16.cost;
3005             COPY2_IF_LT( i_cost, analysis.l1.me16x16.cost, i_type, B_L1_L1 );
3006             COPY2_IF_LT( i_cost, analysis.i_cost16x16bi, i_type, B_BI_BI );
3007             COPY2_IF_LT( i_cost, analysis.i_cost16x16direct, i_type, B_DIRECT );
3008
3009             if( analysis.i_mbrd && analysis.i_cost16x16direct <= i_cost * 33/32 )
3010             {
3011                 x264_mb_analyse_b_rd( h, &analysis, i_cost );
3012                 if( i_bskip_cost < analysis.i_rd16x16direct &&
3013                     i_bskip_cost < analysis.i_rd16x16bi &&
3014                     i_bskip_cost < analysis.l0.i_rd16x16 &&
3015                     i_bskip_cost < analysis.l1.i_rd16x16 )
3016                 {
3017                     h->mb.i_type = B_SKIP;
3018                     x264_analyse_update_cache( h, &analysis );
3019                     return;
3020                 }
3021             }
3022
3023             if( flags & X264_ANALYSE_BSUB16x16 )
3024             {
3025                 if( h->param.analyse.b_mixed_references )
3026                     x264_mb_analyse_inter_b8x8_mixed_ref( h, &analysis );
3027                 else
3028                     x264_mb_analyse_inter_b8x8( h, &analysis );
3029
3030                 COPY3_IF_LT( i_cost, analysis.i_cost8x8bi, i_type, B_8x8, i_partition, D_8x8 );
3031
3032                 /* Try to estimate the cost of b16x8/b8x16 based on the satd scores of the b8x8 modes */
3033                 int i_cost_est16x8bi_total = 0, i_cost_est8x16bi_total = 0;
3034                 int i_mb_type, i_partition16x8[2], i_partition8x16[2];
3035                 for( int i = 0; i < 2; i++ )
3036                 {
3037                     int avg_l0_mv_ref_cost, avg_l1_mv_ref_cost;
3038                     int i_l0_satd, i_l1_satd, i_bi_satd, i_best_cost;
3039                     // 16x8
3040                     i_best_cost = COST_MAX;
3041                     i_l0_satd = analysis.i_satd8x8[0][i*2] + analysis.i_satd8x8[0][i*2+1];
3042                     i_l1_satd = analysis.i_satd8x8[1][i*2] + analysis.i_satd8x8[1][i*2+1];
3043                     i_bi_satd = analysis.i_satd8x8[2][i*2] + analysis.i_satd8x8[2][i*2+1];
3044                     avg_l0_mv_ref_cost = ( analysis.l0.me8x8[i*2].cost_mv + analysis.l0.me8x8[i*2].i_ref_cost
3045                                          + analysis.l0.me8x8[i*2+1].cost_mv + analysis.l0.me8x8[i*2+1].i_ref_cost + 1 ) >> 1;
3046                     avg_l1_mv_ref_cost = ( analysis.l1.me8x8[i*2].cost_mv + analysis.l1.me8x8[i*2].i_ref_cost
3047                                          + analysis.l1.me8x8[i*2+1].cost_mv + analysis.l1.me8x8[i*2+1].i_ref_cost + 1 ) >> 1;
3048                     COPY2_IF_LT( i_best_cost, i_l0_satd + avg_l0_mv_ref_cost, i_partition16x8[i], D_L0_8x8 );
3049                     COPY2_IF_LT( i_best_cost, i_l1_satd + avg_l1_mv_ref_cost, i_partition16x8[i], D_L1_8x8 );
3050                     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 );
3051                     analysis.i_cost_est16x8[i] = i_best_cost;
3052
3053                     // 8x16
3054                     i_best_cost = COST_MAX;
3055                     i_l0_satd = analysis.i_satd8x8[0][i] + analysis.i_satd8x8[0][i+2];
3056                     i_l1_satd = analysis.i_satd8x8[1][i] + analysis.i_satd8x8[1][i+2];
3057                     i_bi_satd = analysis.i_satd8x8[2][i] + analysis.i_satd8x8[2][i+2];
3058                     avg_l0_mv_ref_cost = ( analysis.l0.me8x8[i].cost_mv + analysis.l0.me8x8[i].i_ref_cost
3059                                          + analysis.l0.me8x8[i+2].cost_mv + analysis.l0.me8x8[i+2].i_ref_cost + 1 ) >> 1;
3060                     avg_l1_mv_ref_cost = ( analysis.l1.me8x8[i].cost_mv + analysis.l1.me8x8[i].i_ref_cost
3061                                          + analysis.l1.me8x8[i+2].cost_mv + analysis.l1.me8x8[i+2].i_ref_cost + 1 ) >> 1;
3062                     COPY2_IF_LT( i_best_cost, i_l0_satd + avg_l0_mv_ref_cost, i_partition8x16[i], D_L0_8x8 );
3063                     COPY2_IF_LT( i_best_cost, i_l1_satd + avg_l1_mv_ref_cost, i_partition8x16[i], D_L1_8x8 );
3064                     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 );
3065                     analysis.i_cost_est8x16[i] = i_best_cost;
3066                 }
3067                 i_mb_type = B_L0_L0 + (i_partition16x8[0]>>2) * 3 + (i_partition16x8[1]>>2);
3068                 analysis.i_cost_est16x8[1] += analysis.i_lambda * i_mb_b16x8_cost_table[i_mb_type];
3069                 i_cost_est16x8bi_total = analysis.i_cost_est16x8[0] + analysis.i_cost_est16x8[1];
3070                 i_mb_type = B_L0_L0 + (i_partition8x16[0]>>2) * 3 + (i_partition8x16[1]>>2);
3071                 analysis.i_cost_est8x16[1] += analysis.i_lambda * i_mb_b16x8_cost_table[i_mb_type];
3072                 i_cost_est8x16bi_total = analysis.i_cost_est8x16[0] + analysis.i_cost_est8x16[1];
3073
3074                 /* We can gain a little speed by checking the mode with the lowest estimated cost first */
3075                 int try_16x8_first = i_cost_est16x8bi_total < i_cost_est8x16bi_total;
3076                 if( try_16x8_first && i_cost_est16x8bi_total < i_cost )
3077                 {
3078                     x264_mb_analyse_inter_b16x8( h, &analysis, i_cost );
3079                     COPY3_IF_LT( i_cost, analysis.i_cost16x8bi, i_type, analysis.i_mb_type16x8, i_partition, D_16x8 );
3080                 }
3081                 if( i_cost_est8x16bi_total < i_cost )
3082                 {
3083                     x264_mb_analyse_inter_b8x16( h, &analysis, i_cost );
3084                     COPY3_IF_LT( i_cost, analysis.i_cost8x16bi, i_type, analysis.i_mb_type8x16, i_partition, D_8x16 );
3085                 }
3086                 if( !try_16x8_first && i_cost_est16x8bi_total < i_cost )
3087                 {
3088                     x264_mb_analyse_inter_b16x8( h, &analysis, i_cost );
3089                     COPY3_IF_LT( i_cost, analysis.i_cost16x8bi, i_type, analysis.i_mb_type16x8, i_partition, D_16x8 );
3090                 }
3091             }
3092
3093             if( analysis.i_mbrd || !h->mb.i_subpel_refine )
3094             {
3095                 /* refine later */
3096             }
3097             /* refine qpel */
3098             else if( i_partition == D_16x16 )
3099             {
3100                 analysis.l0.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
3101                 analysis.l1.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
3102                 if( i_type == B_L0_L0 )
3103                 {
3104                     x264_me_refine_qpel( h, &analysis.l0.me16x16 );
3105                     i_cost = analysis.l0.me16x16.cost
3106                            + analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
3107                 }
3108                 else if( i_type == B_L1_L1 )
3109                 {
3110                     x264_me_refine_qpel( h, &analysis.l1.me16x16 );
3111                     i_cost = analysis.l1.me16x16.cost
3112                            + analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
3113                 }
3114                 else if( i_type == B_BI_BI )
3115                 {
3116                     x264_me_refine_qpel( h, &analysis.l0.bi16x16 );
3117                     x264_me_refine_qpel( h, &analysis.l1.bi16x16 );
3118                 }
3119             }
3120             else if( i_partition == D_16x8 )
3121             {
3122                 for( int i = 0; i < 2; i++ )
3123                 {
3124                     if( analysis.i_mb_partition16x8[i] != D_L1_8x8 )
3125                         x264_me_refine_qpel( h, &analysis.l0.me16x8[i] );
3126                     if( analysis.i_mb_partition16x8[i] != D_L0_8x8 )
3127                         x264_me_refine_qpel( h, &analysis.l1.me16x8[i] );
3128                 }
3129             }
3130             else if( i_partition == D_8x16 )
3131             {
3132                 for( int i = 0; i < 2; i++ )
3133                 {
3134                     if( analysis.i_mb_partition8x16[i] != D_L1_8x8 )
3135                         x264_me_refine_qpel( h, &analysis.l0.me8x16[i] );
3136                     if( analysis.i_mb_partition8x16[i] != D_L0_8x8 )
3137                         x264_me_refine_qpel( h, &analysis.l1.me8x16[i] );
3138                 }
3139             }
3140             else if( i_partition == D_8x8 )
3141             {
3142                 for( int i = 0; i < 4; i++ )
3143                 {
3144                     x264_me_t *m;
3145                     int i_part_cost_old;
3146                     int i_type_cost;
3147                     int i_part_type = h->mb.i_sub_partition[i];
3148                     int b_bidir = (i_part_type == D_BI_8x8);
3149
3150                     if( i_part_type == D_DIRECT_8x8 )
3151                         continue;
3152                     if( x264_mb_partition_listX_table[0][i_part_type] )
3153                     {
3154                         m = &analysis.l0.me8x8[i];
3155                         i_part_cost_old = m->cost;
3156                         i_type_cost = analysis.i_lambda * i_sub_mb_b_cost_table[D_L0_8x8];
3157                         m->cost -= i_type_cost;
3158                         x264_me_refine_qpel( h, m );
3159                         if( !b_bidir )
3160                             analysis.i_cost8x8bi += m->cost + i_type_cost - i_part_cost_old;
3161                     }
3162                     if( x264_mb_partition_listX_table[1][i_part_type] )
3163                     {
3164                         m = &analysis.l1.me8x8[i];
3165                         i_part_cost_old = m->cost;
3166                         i_type_cost = analysis.i_lambda * i_sub_mb_b_cost_table[D_L1_8x8];
3167                         m->cost -= i_type_cost;
3168                         x264_me_refine_qpel( h, m );
3169                         if( !b_bidir )
3170                             analysis.i_cost8x8bi += m->cost + i_type_cost - i_part_cost_old;
3171                     }
3172                     /* TODO: update mvp? */
3173                 }
3174             }
3175
3176             i_satd_inter = i_cost;
3177
3178             if( analysis.i_mbrd )
3179             {
3180                 x264_mb_analyse_b_rd( h, &analysis, i_satd_inter );
3181                 i_type = B_SKIP;
3182                 i_cost = i_bskip_cost;
3183                 i_partition = D_16x16;
3184                 COPY2_IF_LT( i_cost, analysis.l0.i_rd16x16, i_type, B_L0_L0 );
3185                 COPY2_IF_LT( i_cost, analysis.l1.i_rd16x16, i_type, B_L1_L1 );
3186                 COPY2_IF_LT( i_cost, analysis.i_rd16x16bi, i_type, B_BI_BI );
3187                 COPY2_IF_LT( i_cost, analysis.i_rd16x16direct, i_type, B_DIRECT );
3188                 COPY3_IF_LT( i_cost, analysis.i_rd16x8bi, i_type, analysis.i_mb_type16x8, i_partition, D_16x8 );
3189                 COPY3_IF_LT( i_cost, analysis.i_rd8x16bi, i_type, analysis.i_mb_type8x16, i_partition, D_8x16 );
3190                 COPY3_IF_LT( i_cost, analysis.i_rd8x8bi, i_type, B_8x8, i_partition, D_8x8 );
3191
3192                 h->mb.i_type = i_type;
3193                 h->mb.i_partition = i_partition;
3194             }
3195
3196             x264_mb_analyse_intra( h, &analysis, i_satd_inter );
3197
3198             if( analysis.i_mbrd )
3199             {
3200                 x264_mb_analyse_transform_rd( h, &analysis, &i_satd_inter, &i_cost );
3201                 x264_intra_rd( h, &analysis, i_satd_inter * 17/16 );
3202             }
3203
3204             COPY2_IF_LT( i_cost, analysis.i_satd_i16x16, i_type, I_16x16 );
3205             COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, i_type, I_8x8 );
3206             COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, i_type, I_4x4 );
3207             COPY2_IF_LT( i_cost, analysis.i_satd_pcm, i_type, I_PCM );
3208
3209             h->mb.i_type = i_type;
3210             h->mb.i_partition = i_partition;
3211
3212             if( analysis.i_mbrd >= 2 && IS_INTRA( i_type ) && i_type != I_PCM )
3213                 x264_intra_rd_refine( h, &analysis );
3214             if( h->mb.i_subpel_refine >= 5 )
3215                 x264_refine_bidir( h, &analysis );
3216
3217             if( analysis.i_mbrd >= 2 && i_type > B_DIRECT && i_type < B_SKIP )
3218             {
3219                 int i_biweight;
3220                 x264_analyse_update_cache( h, &analysis );
3221
3222                 if( i_partition == D_16x16 )
3223                 {
3224                     if( i_type == B_L0_L0 )
3225                     {
3226                         analysis.l0.me16x16.cost = i_cost;
3227                         x264_me_refine_qpel_rd( h, &analysis.l0.me16x16, analysis.i_lambda2, 0, 0 );
3228                     }
3229                     else if( i_type == B_L1_L1 )
3230                     {
3231                         analysis.l1.me16x16.cost = i_cost;
3232                         x264_me_refine_qpel_rd( h, &analysis.l1.me16x16, analysis.i_lambda2, 0, 1 );
3233                     }
3234                     else if( i_type == B_BI_BI )
3235                     {
3236                         i_biweight = h->mb.bipred_weight[analysis.l0.bi16x16.i_ref][analysis.l1.bi16x16.i_ref];
3237                         x264_me_refine_bidir_rd( h, &analysis.l0.bi16x16, &analysis.l1.bi16x16, i_biweight, 0, analysis.i_lambda2 );
3238                     }
3239                 }
3240                 else if( i_partition == D_16x8 )
3241                 {
3242                     for( int i = 0; i < 2; i++ )
3243                     {
3244                         h->mb.i_sub_partition[i*2] = h->mb.i_sub_partition[i*2+1] = analysis.i_mb_partition16x8[i];
3245                         if( analysis.i_mb_partition16x8[i] == D_L0_8x8 )
3246                             x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[i], analysis.i_lambda2, i*8, 0 );
3247                         else if( analysis.i_mb_partition16x8[i] == D_L1_8x8 )
3248                             x264_me_refine_qpel_rd( h, &analysis.l1.me16x8[i], analysis.i_lambda2, i*8, 1 );
3249                         else if( analysis.i_mb_partition16x8[i] == D_BI_8x8 )
3250                         {
3251                             i_biweight = h->mb.bipred_weight[analysis.l0.me16x8[i].i_ref][analysis.l1.me16x8[i].i_ref];
3252                             x264_me_refine_bidir_rd( h, &analysis.l0.me16x8[i], &analysis.l1.me16x8[i], i_biweight, i*2, analysis.i_lambda2 );
3253                         }
3254                     }
3255                 }
3256                 else if( i_partition == D_8x16 )
3257                 {
3258                     for( int i = 0; i < 2; i++ )
3259                     {
3260                         h->mb.i_sub_partition[i] = h->mb.i_sub_partition[i+2] = analysis.i_mb_partition8x16[i];
3261                         if( analysis.i_mb_partition8x16[i] == D_L0_8x8 )
3262                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[i], analysis.i_lambda2, i*4, 0 );
3263                         else if( analysis.i_mb_partition8x16[i] == D_L1_8x8 )
3264                             x264_me_refine_qpel_rd( h, &analysis.l1.me8x16[i], analysis.i_lambda2, i*4, 1 );
3265                         else if( analysis.i_mb_partition8x16[i] == D_BI_8x8 )
3266                         {
3267                             i_biweight = h->mb.bipred_weight[analysis.l0.me8x16[i].i_ref][analysis.l1.me8x16[i].i_ref];
3268                             x264_me_refine_bidir_rd( h, &analysis.l0.me8x16[i], &analysis.l1.me8x16[i], i_biweight, i, analysis.i_lambda2 );
3269                         }
3270                     }
3271                 }
3272                 else if( i_partition == D_8x8 )
3273                 {
3274                     for( int i = 0; i < 4; i++ )
3275                     {
3276                         if( h->mb.i_sub_partition[i] == D_L0_8x8 )
3277                             x264_me_refine_qpel_rd( h, &analysis.l0.me8x8[i], analysis.i_lambda2, i*4, 0 );
3278                         else if( h->mb.i_sub_partition[i] == D_L1_8x8 )
3279                             x264_me_refine_qpel_rd( h, &analysis.l1.me8x8[i], analysis.i_lambda2, i*4, 1 );
3280                         else if( h->mb.i_sub_partition[i] == D_BI_8x8 )
3281                         {
3282                             i_biweight = h->mb.bipred_weight[analysis.l0.me8x8[i].i_ref][analysis.l1.me8x8[i].i_ref];
3283                             x264_me_refine_bidir_rd( h, &analysis.l0.me8x8[i], &analysis.l1.me8x8[i], i_biweight, i, analysis.i_lambda2 );
3284                         }
3285                     }
3286                 }
3287             }
3288         }
3289     }
3290
3291     x264_analyse_update_cache( h, &analysis );
3292
3293     /* In rare cases we can end up qpel-RDing our way back to a larger partition size
3294      * without realizing it.  Check for this and account for it if necessary. */
3295     if( analysis.i_mbrd >= 2 )
3296     {
3297         /* Don't bother with bipred or 8x8-and-below, the odds are incredibly low. */
3298         static const uint8_t check_mv_lists[X264_MBTYPE_MAX] = {[P_L0]=1, [B_L0_L0]=1, [B_L1_L1]=2};
3299         int list = check_mv_lists[h->mb.i_type] - 1;
3300         if( list >= 0 && h->mb.i_partition != D_16x16 &&
3301             M32( &h->mb.cache.mv[list][x264_scan8[0]] ) == M32( &h->mb.cache.mv[list][x264_scan8[12]] ) &&
3302             h->mb.cache.ref[list][x264_scan8[0]] == h->mb.cache.ref[list][x264_scan8[12]] )
3303                 h->mb.i_partition = D_16x16;
3304     }
3305
3306     if( !analysis.i_mbrd )
3307         x264_mb_analyse_transform( h );
3308
3309     if( analysis.i_mbrd == 3 && !IS_SKIP(h->mb.i_type) )
3310         x264_mb_analyse_qp_rd( h, &analysis );
3311
3312     h->mb.b_trellis = h->param.analyse.i_trellis;
3313     h->mb.b_noise_reduction = !!h->param.analyse.i_noise_reduction;
3314     if( !IS_SKIP(h->mb.i_type) && h->mb.i_psy_trellis && h->param.analyse.i_trellis == 1 )
3315         x264_psy_trellis_init( h, 0 );
3316     if( h->mb.b_trellis == 1 || h->mb.b_noise_reduction )
3317         h->mb.i_skip_intra = 0;
3318 }
3319
3320 /*-------------------- Update MB from the analysis ----------------------*/
3321 static void x264_analyse_update_cache( x264_t *h, x264_mb_analysis_t *a  )
3322 {
3323     switch( h->mb.i_type )
3324     {
3325         case I_4x4:
3326             for( int i = 0; i < 16; i++ )
3327                 h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] = a->i_predict4x4[i];
3328
3329             x264_mb_analyse_intra_chroma( h, a );
3330             break;
3331         case I_8x8:
3332             for( int i = 0; i < 4; i++ )
3333                 x264_macroblock_cache_intra8x8_pred( h, 2*(i&1), 2*(i>>1), a->i_predict8x8[i] );
3334
3335             x264_mb_analyse_intra_chroma( h, a );
3336             break;
3337         case I_16x16:
3338             h->mb.i_intra16x16_pred_mode = a->i_predict16x16;
3339             x264_mb_analyse_intra_chroma( h, a );
3340             break;
3341
3342         case I_PCM:
3343             break;
3344
3345         case P_L0:
3346             switch( h->mb.i_partition )
3347             {
3348                 case D_16x16:
3349                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.me16x16.i_ref );
3350                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
3351                     break;
3352
3353                 case D_16x8:
3354                     x264_macroblock_cache_ref( h, 0, 0, 4, 2, 0, a->l0.me16x8[0].i_ref );
3355                     x264_macroblock_cache_ref( h, 0, 2, 4, 2, 0, a->l0.me16x8[1].i_ref );
3356                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 2, 0, a->l0.me16x8[0].mv );
3357                     x264_macroblock_cache_mv_ptr( h, 0, 2, 4, 2, 0, a->l0.me16x8[1].mv );
3358                     break;
3359
3360                 case D_8x16:
3361                     x264_macroblock_cache_ref( h, 0, 0, 2, 4, 0, a->l0.me8x16[0].i_ref );
3362                     x264_macroblock_cache_ref( h, 2, 0, 2, 4, 0, a->l0.me8x16[1].i_ref );
3363                     x264_macroblock_cache_mv_ptr( h, 0, 0, 2, 4, 0, a->l0.me8x16[0].mv );
3364                     x264_macroblock_cache_mv_ptr( h, 2, 0, 2, 4, 0, a->l0.me8x16[1].mv );
3365                     break;
3366
3367                 default:
3368                     x264_log( h, X264_LOG_ERROR, "internal error P_L0 and partition=%d\n", h->mb.i_partition );
3369                     break;
3370             }
3371             break;
3372
3373         case P_8x8:
3374             x264_macroblock_cache_ref( h, 0, 0, 2, 2, 0, a->l0.me8x8[0].i_ref );
3375             x264_macroblock_cache_ref( h, 2, 0, 2, 2, 0, a->l0.me8x8[1].i_ref );
3376             x264_macroblock_cache_ref( h, 0, 2, 2, 2, 0, a->l0.me8x8[2].i_ref );
3377             x264_macroblock_cache_ref( h, 2, 2, 2, 2, 0, a->l0.me8x8[3].i_ref );
3378             for( int i = 0; i < 4; i++ )
3379                 x264_mb_cache_mv_p8x8( h, a, i );
3380             break;
3381
3382         case P_SKIP:
3383         {
3384             h->mb.i_partition = D_16x16;
3385             x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, 0 );
3386             x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, h->mb.cache.pskip_mv );
3387             break;
3388         }
3389
3390         case B_SKIP:
3391         case B_DIRECT:
3392             h->mb.i_partition = h->mb.cache.direct_partition;
3393             x264_mb_load_mv_direct8x8( h, 0 );
3394             x264_mb_load_mv_direct8x8( h, 1 );
3395             x264_mb_load_mv_direct8x8( h, 2 );
3396             x264_mb_load_mv_direct8x8( h, 3 );
3397             break;
3398
3399         case B_8x8:
3400             /* optimize: cache might not need to be rewritten */
3401             for( int i = 0; i < 4; i++ )
3402                 x264_mb_cache_mv_b8x8( h, a, i, 1 );
3403             break;
3404
3405         default: /* the rest of the B types */
3406             switch( h->mb.i_partition )
3407             {
3408             case D_16x16:
3409                 switch( h->mb.i_type )
3410                 {
3411                 case B_L0_L0:
3412                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.me16x16.i_ref );
3413                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
3414
3415                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, -1 );
3416                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 1, 0 );
3417                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 1, 0 );
3418                     break;
3419                 case B_L1_L1:
3420                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, -1 );
3421                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, 0 );
3422                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 0, 0 );
3423
3424                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.me16x16.i_ref );
3425                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 1, a->l1.me16x16.mv );
3426                     break;
3427                 case B_BI_BI:
3428                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.bi16x16.i_ref );
3429                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.bi16x16.mv );
3430
3431                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.bi16x16.i_ref );
3432                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 1, a->l1.bi16x16.mv );
3433                     break;
3434                 }
3435                 break;
3436             case D_16x8:
3437                 x264_mb_cache_mv_b16x8( h, a, 0, 1 );
3438                 x264_mb_cache_mv_b16x8( h, a, 1, 1 );
3439                 break;
3440             case D_8x16:
3441                 x264_mb_cache_mv_b8x16( h, a, 0, 1 );
3442                 x264_mb_cache_mv_b8x16( h, a, 1, 1 );
3443                 break;
3444             default:
3445                 x264_log( h, X264_LOG_ERROR, "internal error (invalid MB type)\n" );
3446                 break;
3447             }
3448     }
3449
3450 #ifndef NDEBUG
3451     if( h->i_thread_frames > 1 && !IS_INTRA(h->mb.i_type) )
3452     {
3453         for( int l = 0; l <= (h->sh.i_type == SLICE_TYPE_B); l++ )
3454         {
3455             int completed;
3456             int ref = h->mb.cache.ref[l][x264_scan8[0]];
3457             if( ref < 0 )
3458                 continue;
3459             completed = (l ? h->fref1 : h->fref0)[ ref >> h->mb.b_interlaced ]->orig->i_lines_completed;
3460             if( (h->mb.cache.mv[l][x264_scan8[15]][1] >> (2 - h->mb.b_interlaced)) + h->mb.i_mb_y*16 > completed )
3461             {
3462                 x264_log( h, X264_LOG_WARNING, "internal error (MV out of thread range)\n");
3463                 x264_log( h, X264_LOG_DEBUG, "mb type: %d \n", h->mb.i_type);
3464                 x264_log( h, X264_LOG_DEBUG, "mv: l%dr%d (%d,%d) \n", l, ref,
3465                                 h->mb.cache.mv[l][x264_scan8[15]][0],
3466                                 h->mb.cache.mv[l][x264_scan8[15]][1] );
3467                 x264_log( h, X264_LOG_DEBUG, "limit: %d \n", h->mb.mv_max_spel[1]);
3468                 x264_log( h, X264_LOG_DEBUG, "mb_xy: %d,%d \n", h->mb.i_mb_x, h->mb.i_mb_y);
3469                 x264_log( h, X264_LOG_DEBUG, "completed: %d \n", completed );
3470                 x264_log( h, X264_LOG_WARNING, "recovering by using intra mode\n");
3471                 x264_mb_analyse_intra( h, a, COST_MAX );
3472                 h->mb.i_type = I_16x16;
3473                 h->mb.i_intra16x16_pred_mode = a->i_predict16x16;
3474                 x264_mb_analyse_intra_chroma( h, a );
3475             }
3476         }
3477     }
3478 #endif
3479 }
3480
3481 #include "slicetype.c"
3482