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