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