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