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