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