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