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