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