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