Replace High 4:4:4 profile lossless with High 4:4:4 Predictive.
[x262.git] / encoder / analyse.c
1 /*****************************************************************************
2  * analyse.c: h264 encoder library
3  *****************************************************************************
4  * Copyright (C) 2003-2008 x264 project
5  *
6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7  *          Loren Merritt <lorenm@u.washington.edu>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 #include <math.h>
25 #include <limits.h>
26 #ifndef _MSC_VER
27 #include <unistd.h>
28 #endif
29
30 #include "common/common.h"
31 #include "macroblock.h"
32 #include "me.h"
33 #include "ratecontrol.h"
34 #include "analyse.h"
35 #include "rdo.c"
36
37 typedef struct
38 {
39     /* 16x16 */
40     int i_ref;
41     int       i_rd16x16;
42     x264_me_t me16x16;
43
44     /* 8x8 */
45     int       i_cost8x8;
46     /* [ref][0] is 16x16 mv, [ref][1..4] are 8x8 mv from partition [0..3] */
47     DECLARE_ALIGNED_4( int16_t mvc[32][5][2] );
48     x264_me_t me8x8[4];
49
50     /* Sub 4x4 */
51     int       i_cost4x4[4]; /* cost per 8x8 partition */
52     x264_me_t me4x4[4][4];
53
54     /* Sub 8x4 */
55     int       i_cost8x4[4]; /* cost per 8x8 partition */
56     x264_me_t me8x4[4][2];
57
58     /* Sub 4x8 */
59     int       i_cost4x8[4]; /* cost per 8x8 partition */
60     x264_me_t me4x8[4][2];
61
62     /* 16x8 */
63     int       i_cost16x8;
64     x264_me_t me16x8[2];
65
66     /* 8x16 */
67     int       i_cost8x16;
68     x264_me_t me8x16[2];
69
70 } x264_mb_analysis_list_t;
71
72 typedef struct
73 {
74     /* conduct the analysis using this lamda and QP */
75     int i_lambda;
76     int i_lambda2;
77     int i_qp;
78     int16_t *p_cost_mv;
79     int b_mbrd;
80
81
82     /* I: Intra part */
83     /* Take some shortcuts in intra search if intra is deemed unlikely */
84     int b_fast_intra;
85     int b_try_pskip;
86
87     /* Luma part */
88     int i_satd_i16x16;
89     int i_satd_i16x16_dir[7];
90     int i_predict16x16;
91
92     int i_satd_i8x8;
93     int i_satd_i8x8_dir[12][4];
94     int i_predict8x8[4];
95
96     int i_satd_i4x4;
97     int i_predict4x4[16];
98
99     int i_satd_pcm;
100
101     /* Chroma part */
102     int i_satd_i8x8chroma;
103     int i_satd_i8x8chroma_dir[4];
104     int i_predict8x8chroma;
105
106     /* II: Inter part P/B frame */
107     x264_mb_analysis_list_t l0;
108     x264_mb_analysis_list_t l1;
109
110     int i_cost16x16bi; /* used the same ref and mv as l0 and l1 (at least for now) */
111     int i_cost16x16direct;
112     int i_cost8x8bi;
113     int i_cost8x8direct[4];
114     int i_cost16x8bi;
115     int i_cost8x16bi;
116     int i_rd16x16bi;
117     int i_rd16x16direct;
118     int i_rd16x8bi;
119     int i_rd8x16bi;
120     int i_rd8x8bi;
121
122     int i_mb_partition16x8[2]; /* mb_partition_e */
123     int i_mb_partition8x16[2];
124     int i_mb_type16x8; /* mb_class_e */
125     int i_mb_type8x16;
126
127     int b_direct_available;
128
129 } x264_mb_analysis_t;
130
131 /* lambda = pow(2,qp/6-2) */
132 const int x264_lambda_tab[52] = {
133    1, 1, 1, 1, 1, 1, 1, 1,  /*  0-7 */
134    1, 1, 1, 1,              /*  8-11 */
135    1, 1, 1, 1, 2, 2, 2, 2,  /* 12-19 */
136    3, 3, 3, 4, 4, 4, 5, 6,  /* 20-27 */
137    6, 7, 8, 9,10,11,13,14,  /* 28-35 */
138   16,18,20,23,25,29,32,36,  /* 36-43 */
139   40,45,51,57,64,72,81,91   /* 44-51 */
140 };
141
142 /* lambda2 = pow(lambda,2) * .9 * 256 */
143 const int x264_lambda2_tab[52] = {
144     14,      18,      22,      28,     36,     45,     57,     72, /*  0 -  7 */
145     91,     115,     145,     182,    230,    290,    365,    460, /*  8 - 15 */
146    580,     731,     921,    1161,   1462,   1843,   2322,   2925, /* 16 - 23 */
147   3686,    4644,    5851,    7372,   9289,  11703,  14745,  18578, /* 24 - 31 */
148  23407,   29491,   37156,   46814,  58982,  74313,  93628, 117964, /* 32 - 39 */
149 148626,  187257,  235929,  297252, 374514, 471859, 594505, 749029, /* 40 - 47 */
150 943718, 1189010, 1498059, 1887436                                  /* 48 - 51 */
151 };
152
153 /* TODO: calculate CABAC costs */
154 static const int i_mb_b_cost_table[X264_MBTYPE_MAX] = {
155     9, 9, 9, 9, 0, 0, 0, 1, 3, 7, 7, 7, 3, 7, 7, 7, 5, 9, 0
156 };
157 static const int i_mb_b16x8_cost_table[17] = {
158     0, 0, 0, 0, 0, 0, 0, 0, 5, 7, 7, 7, 5, 7, 9, 9, 9
159 };
160 static const int i_sub_mb_b_cost_table[13] = {
161     7, 5, 5, 3, 7, 5, 7, 3, 7, 7, 7, 5, 1
162 };
163 static const int i_sub_mb_p_cost_table[4] = {
164     5, 3, 3, 1
165 };
166
167 static void x264_analyse_update_cache( x264_t *h, x264_mb_analysis_t *a );
168
169 uint16_t *x264_cost_mv_fpel[52][4];
170
171 /* initialize an array of lambda*nbits for all possible mvs */
172 static void x264_mb_analyse_load_costs( x264_t *h, x264_mb_analysis_t *a )
173 {
174     static int16_t *p_cost_mv[52];
175     int i, j;
176
177     if( !p_cost_mv[a->i_qp] )
178     {
179         /* could be faster, but isn't called many times */
180         /* factor of 4 from qpel, 2 from sign, and 2 because mv can be opposite from mvp */
181         p_cost_mv[a->i_qp] = x264_malloc( (4*4*2048 + 1) * sizeof(int16_t) );
182         p_cost_mv[a->i_qp] += 2*4*2048;
183         for( i = 0; i <= 2*4*2048; i++ )
184         {
185             p_cost_mv[a->i_qp][-i] =
186             p_cost_mv[a->i_qp][i]  = a->i_lambda * bs_size_se( i );
187         }
188     }
189     a->p_cost_mv = p_cost_mv[a->i_qp];
190
191     /* FIXME is this useful for all me methods? */
192     if( h->param.analyse.i_me_method >= X264_ME_ESA && !x264_cost_mv_fpel[a->i_qp][0] )
193     {
194         for( j=0; j<4; j++ )
195         {
196             x264_cost_mv_fpel[a->i_qp][j] = x264_malloc( (4*2048 + 1) * sizeof(int16_t) );
197             x264_cost_mv_fpel[a->i_qp][j] += 2*2048;
198             for( i = -2*2048; i < 2*2048; i++ )
199                 x264_cost_mv_fpel[a->i_qp][j][i] = p_cost_mv[a->i_qp][i*4+j];
200         }
201     }
202 }
203
204 static void x264_mb_analyse_init( x264_t *h, x264_mb_analysis_t *a, int i_qp )
205 {
206     /* conduct the analysis using this lamda and QP */
207     a->i_qp = h->mb.i_qp = i_qp;
208     h->mb.i_chroma_qp = h->chroma_qp_table[i_qp];
209     a->i_lambda = x264_lambda_tab[i_qp];
210     a->i_lambda2 = x264_lambda2_tab[i_qp];
211     a->b_mbrd = h->param.analyse.i_subpel_refine >= 6 &&
212                 ( h->sh.i_type != SLICE_TYPE_B || h->param.analyse.b_bframe_rdo );
213
214     h->mb.i_me_method = h->param.analyse.i_me_method;
215     h->mb.i_subpel_refine = h->param.analyse.i_subpel_refine;
216     h->mb.b_chroma_me = h->param.analyse.b_chroma_me && h->sh.i_type == SLICE_TYPE_P
217                         && h->mb.i_subpel_refine >= 5;
218     h->mb.b_trellis = h->param.analyse.i_trellis > 1 && a->b_mbrd;
219     h->mb.b_transform_8x8 = 0;
220     h->mb.b_noise_reduction = 0;
221
222     /* I: Intra part */
223     a->i_satd_i16x16 =
224     a->i_satd_i8x8   =
225     a->i_satd_i4x4   =
226     a->i_satd_i8x8chroma = COST_MAX;
227
228     /* non-RD PCM decision is inaccurate (as is psy-rd), so don't do it */
229     a->i_satd_pcm = !h->mb.i_psy_rd && a->b_mbrd ? ((uint64_t)X264_PCM_COST*a->i_lambda2 + 128) >> 8 : COST_MAX;
230
231     a->b_fast_intra = 0;
232     h->mb.i_skip_intra =
233         h->mb.b_lossless ? 0 :
234         a->b_mbrd ? 2 :
235         !h->param.analyse.i_trellis && !h->param.analyse.i_noise_reduction;
236
237     /* II: Inter part P/B frame */
238     if( h->sh.i_type != SLICE_TYPE_I )
239     {
240         int i, j;
241         int i_fmv_range = 4 * h->param.analyse.i_mv_range;
242         // limit motion search to a slightly smaller range than the theoretical limit,
243         // since the search may go a few iterations past its given range
244         int i_fpel_border = 5; // umh unconditional radius
245         int i_spel_border = 8; // 1.5 for subpel_satd, 1.5 for subpel_rd, 2 for bime, round up
246
247         /* Calculate max allowed MV range */
248 #define CLIP_FMV(mv) x264_clip3( mv, -i_fmv_range, i_fmv_range-1 )
249         h->mb.mv_min[0] = 4*( -16*h->mb.i_mb_x - 24 );
250         h->mb.mv_max[0] = 4*( 16*( h->sps->i_mb_width - h->mb.i_mb_x - 1 ) + 24 );
251         h->mb.mv_min_spel[0] = CLIP_FMV( h->mb.mv_min[0] );
252         h->mb.mv_max_spel[0] = CLIP_FMV( h->mb.mv_max[0] );
253         h->mb.mv_min_fpel[0] = (h->mb.mv_min_spel[0]>>2) + i_fpel_border;
254         h->mb.mv_max_fpel[0] = (h->mb.mv_max_spel[0]>>2) - i_fpel_border;
255         if( h->mb.i_mb_x == 0)
256         {
257             int mb_y = h->mb.i_mb_y >> h->sh.b_mbaff;
258             int mb_height = h->sps->i_mb_height >> h->sh.b_mbaff;
259             int thread_mvy_range = i_fmv_range;
260
261             if( h->param.i_threads > 1 )
262             {
263                 int pix_y = (h->mb.i_mb_y | h->mb.b_interlaced) * 16;
264                 int thresh = pix_y + h->param.analyse.i_mv_range_thread;
265                 for( i = (h->sh.i_type == SLICE_TYPE_B); i >= 0; i-- )
266                 {
267                     x264_frame_t **fref = i ? h->fref1 : h->fref0;
268                     int i_ref = i ? h->i_ref1 : h->i_ref0;
269                     for( j=0; j<i_ref; j++ )
270                     {
271                         x264_frame_cond_wait( fref[j], thresh );
272                         thread_mvy_range = X264_MIN( thread_mvy_range, fref[j]->i_lines_completed - pix_y );
273                     }
274                 }
275                 if( h->param.b_deterministic )
276                     thread_mvy_range = h->param.analyse.i_mv_range_thread;
277                 if( h->mb.b_interlaced )
278                     thread_mvy_range >>= 1;
279             }
280
281             h->mb.mv_min[1] = 4*( -16*mb_y - 24 );
282             h->mb.mv_max[1] = 4*( 16*( mb_height - mb_y - 1 ) + 24 );
283             h->mb.mv_min_spel[1] = x264_clip3( h->mb.mv_min[1], X264_MAX(4*(-512+i_spel_border), -i_fmv_range), i_fmv_range );
284             h->mb.mv_max_spel[1] = CLIP_FMV( h->mb.mv_max[1] );
285             h->mb.mv_max_spel[1] = X264_MIN( h->mb.mv_max_spel[1], thread_mvy_range*4 );
286             h->mb.mv_min_fpel[1] = (h->mb.mv_min_spel[1]>>2) + i_fpel_border;
287             h->mb.mv_max_fpel[1] = (h->mb.mv_max_spel[1]>>2) - i_fpel_border;
288         }
289 #undef CLIP_FMV
290
291         a->l0.me16x16.cost =
292         a->l0.i_rd16x16    =
293         a->l0.i_cost8x8    = COST_MAX;
294
295         for( i = 0; i < 4; i++ )
296         {
297             a->l0.i_cost4x4[i] =
298             a->l0.i_cost8x4[i] =
299             a->l0.i_cost4x8[i] = COST_MAX;
300         }
301
302         a->l0.i_cost16x8   =
303         a->l0.i_cost8x16   = COST_MAX;
304         if( h->sh.i_type == SLICE_TYPE_B )
305         {
306             a->l1.me16x16.cost =
307             a->l1.i_rd16x16    =
308             a->l1.i_cost8x8    = COST_MAX;
309
310             for( i = 0; i < 4; i++ )
311             {
312                 a->l1.i_cost4x4[i] =
313                 a->l1.i_cost8x4[i] =
314                 a->l1.i_cost4x8[i] =
315                 a->i_cost8x8direct[i] = COST_MAX;
316             }
317
318             a->l1.i_cost16x8   =
319             a->l1.i_cost8x16   =
320             a->i_rd16x16bi     =
321             a->i_rd16x16direct =
322             a->i_rd8x8bi       =
323             a->i_rd16x8bi      =
324             a->i_rd8x16bi      =
325             a->i_cost16x16bi   =
326             a->i_cost16x16direct =
327             a->i_cost8x8bi     =
328             a->i_cost16x8bi    =
329             a->i_cost8x16bi    = COST_MAX;
330         }
331
332         /* Fast intra decision */
333         if( h->mb.i_mb_xy - h->sh.i_first_mb > 4 )
334         {
335             if(   IS_INTRA( h->mb.i_mb_type_left )
336                || IS_INTRA( h->mb.i_mb_type_top )
337                || IS_INTRA( h->mb.i_mb_type_topleft )
338                || IS_INTRA( h->mb.i_mb_type_topright )
339                || (h->sh.i_type == SLICE_TYPE_P && IS_INTRA( h->fref0[0]->mb_type[h->mb.i_mb_xy] ))
340                || (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])) )
341             { /* intra is likely */ }
342             else
343             {
344                 a->b_fast_intra = 1;
345             }
346         }
347         h->mb.b_skip_mc = 0;
348     }
349 }
350
351
352
353 /*
354  * Handle intra mb
355  */
356 /* Max = 4 */
357 static void predict_16x16_mode_available( unsigned int i_neighbour, int *mode, int *pi_count )
358 {
359     if( i_neighbour & MB_TOPLEFT )
360     {
361         /* top and left available */
362         *mode++ = I_PRED_16x16_V;
363         *mode++ = I_PRED_16x16_H;
364         *mode++ = I_PRED_16x16_DC;
365         *mode++ = I_PRED_16x16_P;
366         *pi_count = 4;
367     }
368     else if( i_neighbour & MB_LEFT )
369     {
370         /* left available*/
371         *mode++ = I_PRED_16x16_DC_LEFT;
372         *mode++ = I_PRED_16x16_H;
373         *pi_count = 2;
374     }
375     else if( i_neighbour & MB_TOP )
376     {
377         /* top available*/
378         *mode++ = I_PRED_16x16_DC_TOP;
379         *mode++ = I_PRED_16x16_V;
380         *pi_count = 2;
381     }
382     else
383     {
384         /* none available */
385         *mode = I_PRED_16x16_DC_128;
386         *pi_count = 1;
387     }
388 }
389
390 /* Max = 4 */
391 static void predict_8x8chroma_mode_available( unsigned int i_neighbour, int *mode, int *pi_count )
392 {
393     if( i_neighbour & MB_TOPLEFT )
394     {
395         /* top and left available */
396         *mode++ = I_PRED_CHROMA_V;
397         *mode++ = I_PRED_CHROMA_H;
398         *mode++ = I_PRED_CHROMA_DC;
399         *mode++ = I_PRED_CHROMA_P;
400         *pi_count = 4;
401     }
402     else if( i_neighbour & MB_LEFT )
403     {
404         /* left available*/
405         *mode++ = I_PRED_CHROMA_DC_LEFT;
406         *mode++ = I_PRED_CHROMA_H;
407         *pi_count = 2;
408     }
409     else if( i_neighbour & MB_TOP )
410     {
411         /* top available*/
412         *mode++ = I_PRED_CHROMA_DC_TOP;
413         *mode++ = I_PRED_CHROMA_V;
414         *pi_count = 2;
415     }
416     else
417     {
418         /* none available */
419         *mode = I_PRED_CHROMA_DC_128;
420         *pi_count = 1;
421     }
422 }
423
424 /* MAX = 9 */
425 static void predict_4x4_mode_available( unsigned int i_neighbour,
426                                         int *mode, int *pi_count )
427 {
428     int b_l = i_neighbour & MB_LEFT;
429     int b_t = i_neighbour & MB_TOP;
430
431     if( b_l && b_t )
432     {
433         *pi_count = 6;
434         *mode++ = I_PRED_4x4_DC;
435         *mode++ = I_PRED_4x4_H;
436         *mode++ = I_PRED_4x4_V;
437         *mode++ = I_PRED_4x4_DDL;
438         if( i_neighbour & MB_TOPLEFT )
439         {
440             *mode++ = I_PRED_4x4_DDR;
441             *mode++ = I_PRED_4x4_VR;
442             *mode++ = I_PRED_4x4_HD;
443             *pi_count += 3;
444         }
445         *mode++ = I_PRED_4x4_VL;
446         *mode++ = I_PRED_4x4_HU;
447     }
448     else if( b_l )
449     {
450         *mode++ = I_PRED_4x4_DC_LEFT;
451         *mode++ = I_PRED_4x4_H;
452         *mode++ = I_PRED_4x4_HU;
453         *pi_count = 3;
454     }
455     else if( b_t )
456     {
457         *mode++ = I_PRED_4x4_DC_TOP;
458         *mode++ = I_PRED_4x4_V;
459         *mode++ = I_PRED_4x4_DDL;
460         *mode++ = I_PRED_4x4_VL;
461         *pi_count = 4;
462     }
463     else
464     {
465         *mode++ = I_PRED_4x4_DC_128;
466         *pi_count = 1;
467     }
468 }
469
470 /* 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. */
471 static void inline x264_psy_trellis_init( x264_t *h, int do_both_dct )
472 {
473     DECLARE_ALIGNED_16( int16_t dct8x8[4][8][8] );
474     DECLARE_ALIGNED_16( int16_t dct4x4[16][4][4] );
475     DECLARE_ALIGNED_16( uint8_t zero[16*FDEC_STRIDE] ) = {0};
476     int i;
477
478     if( do_both_dct || h->mb.b_transform_8x8 )
479     {
480         h->dctf.sub16x16_dct8( dct8x8, h->mb.pic.p_fenc[0], zero );
481         for( i = 0; i < 4; i++ )
482             h->zigzagf.scan_8x8( h->mb.pic.fenc_dct8[i], dct8x8[i] );
483     }
484     if( do_both_dct || !h->mb.b_transform_8x8 )
485     {
486         h->dctf.sub16x16_dct( dct4x4, h->mb.pic.p_fenc[0], zero );
487         for( i = 0; i < 16; i++ )
488             h->zigzagf.scan_4x4( h->mb.pic.fenc_dct4[i], dct4x4[i] );
489     }
490 }
491
492 /* Pre-calculate fenc satd scores for psy RD, minus DC coefficients */
493 static inline void x264_mb_cache_fenc_satd( x264_t *h )
494 {
495     DECLARE_ALIGNED_16(uint8_t zero[16]) = {0};
496     uint8_t *fenc;
497     int x, y, satd_sum = 0, sa8d_sum = 0;
498     if( h->param.analyse.i_trellis == 2 && h->mb.i_psy_trellis )
499         x264_psy_trellis_init( h, h->param.analyse.b_transform_8x8 );
500     if( !h->mb.i_psy_rd )
501         return;
502     for( y = 0; y < 4; y++ )
503         for( x = 0; x < 4; x++ )
504         {
505             fenc = h->mb.pic.p_fenc[0]+x*4+y*4*FENC_STRIDE;
506             h->mb.pic.fenc_satd[y][x] = h->pixf.satd[PIXEL_4x4]( zero, 0, fenc, FENC_STRIDE )
507                                       - (h->pixf.sad[PIXEL_4x4]( zero, 0, fenc, FENC_STRIDE )>>1);
508             satd_sum += h->mb.pic.fenc_satd[y][x];
509         }
510     for( y = 0; y < 2; y++ )
511         for( x = 0; x < 2; x++ )
512         {
513             fenc = h->mb.pic.p_fenc[0]+x*8+y*8*FENC_STRIDE;
514             h->mb.pic.fenc_sa8d[y][x] = h->pixf.sa8d[PIXEL_8x8]( zero, 0, fenc, FENC_STRIDE )
515                                       - (h->pixf.sad[PIXEL_8x8]( zero, 0, fenc, FENC_STRIDE )>>2);
516             sa8d_sum += h->mb.pic.fenc_sa8d[y][x];
517         }
518     h->mb.pic.fenc_satd_sum = satd_sum;
519     h->mb.pic.fenc_sa8d_sum = sa8d_sum;
520 }
521
522 static void x264_mb_analyse_intra_chroma( x264_t *h, x264_mb_analysis_t *a )
523 {
524     int i;
525
526     int i_max;
527     int predict_mode[4];
528
529     uint8_t *p_dstc[2], *p_srcc[2];
530
531     if( a->i_satd_i8x8chroma < COST_MAX )
532         return;
533
534     /* 8x8 prediction selection for chroma */
535     p_dstc[0] = h->mb.pic.p_fdec[1];
536     p_dstc[1] = h->mb.pic.p_fdec[2];
537     p_srcc[0] = h->mb.pic.p_fenc[1];
538     p_srcc[1] = h->mb.pic.p_fenc[2];
539
540     predict_8x8chroma_mode_available( h->mb.i_neighbour, predict_mode, &i_max );
541     a->i_satd_i8x8chroma = COST_MAX;
542     if( i_max == 4 && h->pixf.intra_satd_x3_8x8c && h->pixf.mbcmp[0] == h->pixf.satd[0] )
543     {
544         int satdu[4], satdv[4];
545         h->pixf.intra_satd_x3_8x8c( p_srcc[0], p_dstc[0], satdu );
546         h->pixf.intra_satd_x3_8x8c( p_srcc[1], p_dstc[1], satdv );
547         h->predict_8x8c[I_PRED_CHROMA_P]( p_dstc[0] );
548         h->predict_8x8c[I_PRED_CHROMA_P]( p_dstc[1] );
549         satdu[I_PRED_CHROMA_P] =
550             h->pixf.mbcmp[PIXEL_8x8]( p_dstc[0], FDEC_STRIDE, p_srcc[0], FENC_STRIDE );
551         satdv[I_PRED_CHROMA_P] =
552             h->pixf.mbcmp[PIXEL_8x8]( p_dstc[1], FDEC_STRIDE, p_srcc[1], FENC_STRIDE );
553
554         for( i=0; i<i_max; i++ )
555         {
556             int i_mode = predict_mode[i];
557             int i_satd = satdu[i_mode] + satdv[i_mode]
558                        + a->i_lambda * bs_size_ue(i_mode);
559
560             a->i_satd_i8x8chroma_dir[i] = i_satd;
561             COPY2_IF_LT( a->i_satd_i8x8chroma, i_satd, a->i_predict8x8chroma, i_mode );
562         }
563     }
564     else
565     {
566         for( i=0; i<i_max; i++ )
567         {
568             int i_satd;
569             int i_mode = predict_mode[i];
570
571             /* we do the prediction */
572             if( h->mb.b_lossless )
573                 x264_predict_lossless_8x8_chroma( h, i_mode );
574             else
575             {
576                 h->predict_8x8c[i_mode]( p_dstc[0] );
577                 h->predict_8x8c[i_mode]( p_dstc[1] );
578             }
579
580             /* we calculate the cost */
581             i_satd = h->pixf.mbcmp[PIXEL_8x8]( p_dstc[0], FDEC_STRIDE,
582                                                p_srcc[0], FENC_STRIDE ) +
583                      h->pixf.mbcmp[PIXEL_8x8]( p_dstc[1], FDEC_STRIDE,
584                                                p_srcc[1], FENC_STRIDE ) +
585                      a->i_lambda * bs_size_ue( x264_mb_pred_mode8x8c_fix[i_mode] );
586
587             a->i_satd_i8x8chroma_dir[i] = i_satd;
588             COPY2_IF_LT( a->i_satd_i8x8chroma, i_satd, a->i_predict8x8chroma, i_mode );
589         }
590     }
591
592     h->mb.i_chroma_pred_mode = a->i_predict8x8chroma;
593 }
594
595 static void x264_mb_analyse_intra( x264_t *h, x264_mb_analysis_t *a, int i_satd_inter )
596 {
597     const unsigned int flags = h->sh.i_type == SLICE_TYPE_I ? h->param.analyse.intra : h->param.analyse.inter;
598     uint8_t  *p_src = h->mb.pic.p_fenc[0];
599     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
600
601     int i, idx;
602     int i_max;
603     int predict_mode[9];
604     int b_merged_satd = !!h->pixf.intra_mbcmp_x3_16x16 && !h->mb.b_lossless;
605
606     /*---------------- Try all mode and calculate their score ---------------*/
607
608     /* 16x16 prediction selection */
609     predict_16x16_mode_available( h->mb.i_neighbour, predict_mode, &i_max );
610
611     if( b_merged_satd && i_max == 4 )
612     {
613         h->pixf.intra_mbcmp_x3_16x16( p_src, p_dst, a->i_satd_i16x16_dir );
614         h->predict_16x16[I_PRED_16x16_P]( p_dst );
615         a->i_satd_i16x16_dir[I_PRED_16x16_P] =
616             h->pixf.mbcmp[PIXEL_16x16]( p_dst, FDEC_STRIDE, p_src, FENC_STRIDE );
617         for( i=0; i<4; i++ )
618         {
619             int cost = a->i_satd_i16x16_dir[i] += a->i_lambda * bs_size_ue(i);
620             COPY2_IF_LT( a->i_satd_i16x16, cost, a->i_predict16x16, i );
621         }
622     }
623     else
624     {
625         for( i = 0; i < i_max; i++ )
626         {
627             int i_satd;
628             int i_mode = predict_mode[i];
629
630             if( h->mb.b_lossless )
631                 x264_predict_lossless_16x16( h, i_mode );
632             else
633                 h->predict_16x16[i_mode]( p_dst );
634
635             i_satd = h->pixf.mbcmp[PIXEL_16x16]( p_dst, FDEC_STRIDE, p_src, FENC_STRIDE ) +
636                     a->i_lambda * bs_size_ue( x264_mb_pred_mode16x16_fix[i_mode] );
637             COPY2_IF_LT( a->i_satd_i16x16, i_satd, a->i_predict16x16, i_mode );
638             a->i_satd_i16x16_dir[i_mode] = i_satd;
639         }
640     }
641
642     if( h->sh.i_type == SLICE_TYPE_B )
643         /* cavlc mb type prefix */
644         a->i_satd_i16x16 += a->i_lambda * i_mb_b_cost_table[I_16x16];
645     if( a->b_fast_intra && a->i_satd_i16x16 > 2*i_satd_inter )
646         return;
647
648     /* 8x8 prediction selection */
649     if( flags & X264_ANALYSE_I8x8 )
650     {
651         DECLARE_ALIGNED_16( uint8_t edge[33] );
652         x264_pixel_cmp_t sa8d = (h->pixf.mbcmp[0] == h->pixf.satd[0]) ? h->pixf.sa8d[PIXEL_8x8] : h->pixf.mbcmp[PIXEL_8x8];
653         int i_satd_thresh = a->b_mbrd ? COST_MAX : X264_MIN( i_satd_inter, a->i_satd_i16x16 );
654         int i_cost = 0;
655         b_merged_satd = h->pixf.intra_sa8d_x3_8x8 && h->pixf.mbcmp[0] == h->pixf.satd[0];
656
657         // FIXME some bias like in i4x4?
658         if( h->sh.i_type == SLICE_TYPE_B )
659             i_cost += a->i_lambda * i_mb_b_cost_table[I_8x8];
660
661         for( idx = 0;; idx++ )
662         {
663             int x = idx&1;
664             int y = idx>>1;
665             uint8_t *p_src_by = p_src + 8*x + 8*y*FENC_STRIDE;
666             uint8_t *p_dst_by = p_dst + 8*x + 8*y*FDEC_STRIDE;
667             int i_best = COST_MAX;
668             int i_pred_mode = x264_mb_predict_intra4x4_mode( h, 4*idx );
669
670             predict_4x4_mode_available( h->mb.i_neighbour8[idx], predict_mode, &i_max );
671             x264_predict_8x8_filter( p_dst_by, edge, h->mb.i_neighbour8[idx], ALL_NEIGHBORS );
672
673             if( b_merged_satd && i_max == 9 )
674             {
675                 int satd[9];
676                 h->pixf.intra_sa8d_x3_8x8( p_src_by, edge, satd );
677                 satd[i_pred_mode] -= 3 * a->i_lambda;
678                 for( i=2; i>=0; i-- )
679                 {
680                     int cost = a->i_satd_i8x8_dir[i][idx] = satd[i] + 4 * a->i_lambda;
681                     COPY2_IF_LT( i_best, cost, a->i_predict8x8[idx], i );
682                 }
683                 i = 3;
684             }
685             else
686                 i = 0;
687
688             for( ; i<i_max; i++ )
689             {
690                 int i_satd;
691                 int i_mode = predict_mode[i];
692
693                 if( h->mb.b_lossless )
694                     x264_predict_lossless_8x8( h, p_dst_by, idx, i_mode, edge );
695                 else
696                     h->predict_8x8[i_mode]( p_dst_by, edge );
697
698                 i_satd = sa8d( p_dst_by, FDEC_STRIDE, p_src_by, FENC_STRIDE )
699                        + a->i_lambda * (i_pred_mode == x264_mb_pred_mode4x4_fix(i_mode) ? 1 : 4);
700
701                 COPY2_IF_LT( i_best, i_satd, a->i_predict8x8[idx], i_mode );
702                 a->i_satd_i8x8_dir[i_mode][idx] = i_satd;
703             }
704             i_cost += i_best;
705
706             if( idx == 3 || i_cost > i_satd_thresh )
707                 break;
708
709             /* we need to encode this block now (for next ones) */
710             h->predict_8x8[a->i_predict8x8[idx]]( p_dst_by, edge );
711             x264_mb_encode_i8x8( h, idx, a->i_qp );
712
713             x264_macroblock_cache_intra8x8_pred( h, 2*x, 2*y, a->i_predict8x8[idx] );
714         }
715
716         if( idx == 3 )
717         {
718             a->i_satd_i8x8 = i_cost;
719             if( h->mb.i_skip_intra )
720             {
721                 h->mc.copy[PIXEL_16x16]( h->mb.pic.i8x8_fdec_buf, 16, p_dst, FDEC_STRIDE, 16 );
722                 if( h->mb.i_skip_intra == 2 )
723                     h->mc.memcpy_aligned( h->mb.pic.i8x8_dct_buf, h->dct.luma8x8, sizeof(h->mb.pic.i8x8_dct_buf) );
724             }
725         }
726         else
727         {
728             a->i_satd_i8x8 = COST_MAX;
729             i_cost = i_cost * 4/(idx+1);
730         }
731         if( X264_MIN(i_cost, a->i_satd_i16x16) > i_satd_inter*(5+a->b_mbrd)/4 )
732             return;
733     }
734
735     /* 4x4 prediction selection */
736     if( flags & X264_ANALYSE_I4x4 )
737     {
738         int i_cost;
739         int i_satd_thresh = X264_MIN3( i_satd_inter, a->i_satd_i16x16, a->i_satd_i8x8 );
740         b_merged_satd = h->pixf.intra_satd_x3_4x4 && h->pixf.mbcmp[0] == h->pixf.satd[0];
741         if( a->b_mbrd )
742             i_satd_thresh = i_satd_thresh * (10-a->b_fast_intra)/8;
743
744         i_cost = a->i_lambda * 24;    /* from JVT (SATD0) */
745         if( h->sh.i_type == SLICE_TYPE_B )
746             i_cost += a->i_lambda * i_mb_b_cost_table[I_4x4];
747
748         for( idx = 0;; idx++ )
749         {
750             uint8_t *p_src_by = p_src + block_idx_xy_fenc[idx];
751             uint8_t *p_dst_by = p_dst + block_idx_xy_fdec[idx];
752             int i_best = COST_MAX;
753             int i_pred_mode = x264_mb_predict_intra4x4_mode( h, idx );
754
755             predict_4x4_mode_available( h->mb.i_neighbour4[idx], predict_mode, &i_max );
756
757             if( (h->mb.i_neighbour4[idx] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
758                 /* emulate missing topright samples */
759                 *(uint32_t*) &p_dst_by[4 - FDEC_STRIDE] = p_dst_by[3 - FDEC_STRIDE] * 0x01010101U;
760
761             if( b_merged_satd && i_max >= 6 )
762             {
763                 int satd[9];
764                 h->pixf.intra_satd_x3_4x4( p_src_by, p_dst_by, satd );
765                 satd[i_pred_mode] -= 3 * a->i_lambda;
766                 for( i=2; i>=0; i-- )
767                     COPY2_IF_LT( i_best, satd[i] + 4 * a->i_lambda,
768                                  a->i_predict4x4[idx], i );
769                 i = 3;
770             }
771             else
772                 i = 0;
773
774             for( ; i<i_max; i++ )
775             {
776                 int i_satd;
777                 int i_mode = predict_mode[i];
778                 if( h->mb.b_lossless )
779                     x264_predict_lossless_4x4( h, p_dst_by, idx, i_mode );
780                 else
781                     h->predict_4x4[i_mode]( p_dst_by );
782
783                 i_satd = h->pixf.mbcmp[PIXEL_4x4]( p_dst_by, FDEC_STRIDE,
784                                                    p_src_by, FENC_STRIDE )
785                        + a->i_lambda * (i_pred_mode == x264_mb_pred_mode4x4_fix(i_mode) ? 1 : 4);
786
787                 COPY2_IF_LT( i_best, i_satd, a->i_predict4x4[idx], i_mode );
788             }
789             i_cost += i_best;
790
791             if( i_cost > i_satd_thresh || idx == 15 )
792                 break;
793
794             /* we need to encode this block now (for next ones) */
795             h->predict_4x4[a->i_predict4x4[idx]]( p_dst_by );
796             x264_mb_encode_i4x4( h, idx, a->i_qp );
797
798             h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] = a->i_predict4x4[idx];
799         }
800         if( idx == 15 )
801         {
802             a->i_satd_i4x4 = i_cost;
803             if( h->mb.i_skip_intra )
804             {
805                 h->mc.copy[PIXEL_16x16]( h->mb.pic.i4x4_fdec_buf, 16, p_dst, FDEC_STRIDE, 16 );
806                 if( h->mb.i_skip_intra == 2 )
807                     h->mc.memcpy_aligned( h->mb.pic.i4x4_dct_buf, h->dct.luma4x4, sizeof(h->mb.pic.i4x4_dct_buf) );
808             }
809         }
810         else
811             a->i_satd_i4x4 = COST_MAX;
812     }
813 }
814
815 static void x264_intra_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd_thresh )
816 {
817     if( a->i_satd_i16x16 <= i_satd_thresh )
818     {
819         h->mb.i_type = I_16x16;
820         x264_analyse_update_cache( h, a );
821         a->i_satd_i16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
822     }
823     else
824         a->i_satd_i16x16 = COST_MAX;
825
826     if( a->i_satd_i4x4 <= i_satd_thresh && a->i_satd_i4x4 < COST_MAX )
827     {
828         h->mb.i_type = I_4x4;
829         x264_analyse_update_cache( h, a );
830         a->i_satd_i4x4 = x264_rd_cost_mb( h, a->i_lambda2 );
831     }
832     else
833         a->i_satd_i4x4 = COST_MAX;
834
835     if( a->i_satd_i8x8 <= i_satd_thresh && a->i_satd_i8x8 < COST_MAX )
836     {
837         h->mb.i_type = I_8x8;
838         x264_analyse_update_cache( h, a );
839         a->i_satd_i8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
840     }
841     else
842         a->i_satd_i8x8 = COST_MAX;
843 }
844
845 static void x264_intra_rd_refine( x264_t *h, x264_mb_analysis_t *a )
846 {
847     uint8_t  *p_src = h->mb.pic.p_fenc[0];
848     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
849
850     int i, j, idx, x, y;
851     int i_max, i_mode, i_thresh;
852     uint64_t i_satd, i_best;
853     int i_pred_mode;
854     int predict_mode[9];
855     h->mb.i_skip_intra = 0;
856
857     if( h->mb.i_type == I_16x16 )
858     {
859         int old_pred_mode = a->i_predict16x16;
860         i_thresh = a->i_satd_i16x16_dir[old_pred_mode] * 9/8;
861         i_best = a->i_satd_i16x16;
862         predict_16x16_mode_available( h->mb.i_neighbour, predict_mode, &i_max );
863         for( i = 0; i < i_max; i++ )
864         {
865             int i_mode = predict_mode[i];
866             if( i_mode == old_pred_mode || a->i_satd_i16x16_dir[i_mode] > i_thresh )
867                 continue;
868             h->mb.i_intra16x16_pred_mode = i_mode;
869             i_satd = x264_rd_cost_mb( h, a->i_lambda2 );
870             COPY2_IF_LT( i_best, i_satd, a->i_predict16x16, i_mode );
871         }
872     }
873     else if( h->mb.i_type == I_4x4 )
874     {
875         uint32_t pels[4] = {0}; // doesn't need initting, just shuts up a gcc warning
876         int i_nnz = 0;
877         for( idx = 0; idx < 16; idx++ )
878         {
879             uint8_t *p_dst_by = p_dst + block_idx_xy_fdec[idx];
880             i_best = COST_MAX64;
881
882             i_pred_mode = x264_mb_predict_intra4x4_mode( h, idx );
883
884             predict_4x4_mode_available( h->mb.i_neighbour4[idx], predict_mode, &i_max );
885
886             if( (h->mb.i_neighbour4[idx] & (MB_TOPRIGHT|MB_TOP)) == MB_TOP )
887                 /* emulate missing topright samples */
888                 *(uint32_t*) &p_dst_by[4 - FDEC_STRIDE] = p_dst_by[3 - FDEC_STRIDE] * 0x01010101U;
889
890             for( i = 0; i < i_max; i++ )
891             {
892                 i_mode = predict_mode[i];
893                 if( h->mb.b_lossless )
894                     x264_predict_lossless_4x4( h, p_dst_by, idx, i_mode );
895                 else
896                     h->predict_4x4[i_mode]( p_dst_by );
897                 i_satd = x264_rd_cost_i4x4( h, a->i_lambda2, idx, i_mode );
898
899                 if( i_best > i_satd )
900                 {
901                     a->i_predict4x4[idx] = i_mode;
902                     i_best = i_satd;
903                     pels[0] = *(uint32_t*)(p_dst_by+0*FDEC_STRIDE);
904                     pels[1] = *(uint32_t*)(p_dst_by+1*FDEC_STRIDE);
905                     pels[2] = *(uint32_t*)(p_dst_by+2*FDEC_STRIDE);
906                     pels[3] = *(uint32_t*)(p_dst_by+3*FDEC_STRIDE);
907                     i_nnz = h->mb.cache.non_zero_count[x264_scan8[idx]];
908                 }
909             }
910
911             *(uint32_t*)(p_dst_by+0*FDEC_STRIDE) = pels[0];
912             *(uint32_t*)(p_dst_by+1*FDEC_STRIDE) = pels[1];
913             *(uint32_t*)(p_dst_by+2*FDEC_STRIDE) = pels[2];
914             *(uint32_t*)(p_dst_by+3*FDEC_STRIDE) = pels[3];
915             h->mb.cache.non_zero_count[x264_scan8[idx]] = i_nnz;
916
917             h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] = a->i_predict4x4[idx];
918         }
919     }
920     else if( h->mb.i_type == I_8x8 )
921     {
922         DECLARE_ALIGNED_16( uint8_t edge[33] );
923         for( idx = 0; idx < 4; idx++ )
924         {
925             uint64_t pels_h = 0;
926             uint8_t pels_v[7];
927             int i_nnz[3];
928             uint8_t *p_src_by;
929             uint8_t *p_dst_by;
930             int j;
931             i_thresh = a->i_satd_i8x8_dir[a->i_predict8x8[idx]][idx] * 11/8;
932
933             i_best = COST_MAX64;
934             i_pred_mode = x264_mb_predict_intra4x4_mode( h, 4*idx );
935             x = idx&1;
936             y = idx>>1;
937
938             p_src_by = p_src + 8*x + 8*y*FENC_STRIDE;
939             p_dst_by = p_dst + 8*x + 8*y*FDEC_STRIDE;
940             predict_4x4_mode_available( h->mb.i_neighbour8[idx], predict_mode, &i_max );
941             x264_predict_8x8_filter( p_dst_by, edge, h->mb.i_neighbour8[idx], ALL_NEIGHBORS );
942
943             for( i = 0; i < i_max; i++ )
944             {
945                 i_mode = predict_mode[i];
946                 if( a->i_satd_i8x8_dir[i_mode][idx] > i_thresh )
947                     continue;
948                 if( h->mb.b_lossless )
949                     x264_predict_lossless_8x8( h, p_dst_by, idx, i_mode, edge );
950                 else
951                     h->predict_8x8[i_mode]( p_dst_by, edge );
952                 i_satd = x264_rd_cost_i8x8( h, a->i_lambda2, idx, i_mode );
953
954                 if( i_best > i_satd )
955                 {
956                     a->i_predict8x8[idx] = i_mode;
957                     i_best = i_satd;
958
959                     pels_h = *(uint64_t*)(p_dst_by+7*FDEC_STRIDE);
960                     if( !(idx&1) )
961                         for( j=0; j<7; j++ )
962                             pels_v[j] = p_dst_by[7+j*FDEC_STRIDE];
963                     for( j=0; j<3; j++ )
964                         i_nnz[j] = h->mb.cache.non_zero_count[x264_scan8[4*idx+j+1]];
965                 }
966             }
967
968             *(uint64_t*)(p_dst_by+7*FDEC_STRIDE) = pels_h;
969             if( !(idx&1) )
970                 for( j=0; j<7; j++ )
971                     p_dst_by[7+j*FDEC_STRIDE] = pels_v[j];
972             for( j=0; j<3; j++ )
973                 h->mb.cache.non_zero_count[x264_scan8[4*idx+j+1]] = i_nnz[j];
974
975             x264_macroblock_cache_intra8x8_pred( h, 2*x, 2*y, a->i_predict8x8[idx] );
976         }
977     }
978
979     /* RD selection for chroma prediction */
980     predict_8x8chroma_mode_available( h->mb.i_neighbour, predict_mode, &i_max );
981     if( i_max > 1 )
982     {
983         i_thresh = a->i_satd_i8x8chroma * 5/4;
984
985         for( i = j = 0; i < i_max; i++ )
986             if( a->i_satd_i8x8chroma_dir[i] < i_thresh &&
987                 predict_mode[i] != a->i_predict8x8chroma )
988             {
989                 predict_mode[j++] = predict_mode[i];
990             }
991         i_max = j;
992
993         if( i_max > 0 )
994         {
995             int i_chroma_lambda = x264_lambda2_tab[h->mb.i_chroma_qp];
996             /* the previous thing encoded was x264_intra_rd(), so the pixels and
997              * coefs for the current chroma mode are still around, so we only
998              * have to recount the bits. */
999             i_best = x264_rd_cost_i8x8_chroma( h, i_chroma_lambda, a->i_predict8x8chroma, 0 );
1000             for( i = 0; i < i_max; i++ )
1001             {
1002                 i_mode = predict_mode[i];
1003                 if( h->mb.b_lossless )
1004                     x264_predict_lossless_8x8_chroma( h, i_mode );
1005                 else
1006                 {
1007                     h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[1] );
1008                     h->predict_8x8c[i_mode]( h->mb.pic.p_fdec[2] );
1009                 }
1010                 /* if we've already found a mode that needs no residual, then
1011                  * probably any mode with a residual will be worse.
1012                  * so avoid dct on the remaining modes to improve speed. */
1013                 i_satd = x264_rd_cost_i8x8_chroma( h, i_chroma_lambda, i_mode, h->mb.i_cbp_chroma != 0x00 );
1014                 COPY2_IF_LT( i_best, i_satd, a->i_predict8x8chroma, i_mode );
1015             }
1016             h->mb.i_chroma_pred_mode = a->i_predict8x8chroma;
1017         }
1018     }
1019 }
1020
1021 #define LOAD_FENC( m, src, xoff, yoff) \
1022     (m)->i_stride[0] = h->mb.pic.i_stride[0]; \
1023     (m)->i_stride[1] = h->mb.pic.i_stride[1]; \
1024     (m)->p_fenc[0] = &(src)[0][(xoff)+(yoff)*FENC_STRIDE]; \
1025     (m)->p_fenc[1] = &(src)[1][((xoff)>>1)+((yoff)>>1)*FENC_STRIDE]; \
1026     (m)->p_fenc[2] = &(src)[2][((xoff)>>1)+((yoff)>>1)*FENC_STRIDE];
1027
1028 #define LOAD_HPELS(m, src, list, ref, xoff, yoff) \
1029     (m)->p_fref[0] = &(src)[0][(xoff)+(yoff)*(m)->i_stride[0]]; \
1030     (m)->p_fref[1] = &(src)[1][(xoff)+(yoff)*(m)->i_stride[0]]; \
1031     (m)->p_fref[2] = &(src)[2][(xoff)+(yoff)*(m)->i_stride[0]]; \
1032     (m)->p_fref[3] = &(src)[3][(xoff)+(yoff)*(m)->i_stride[0]]; \
1033     (m)->p_fref[4] = &(src)[4][((xoff)>>1)+((yoff)>>1)*(m)->i_stride[1]]; \
1034     (m)->p_fref[5] = &(src)[5][((xoff)>>1)+((yoff)>>1)*(m)->i_stride[1]]; \
1035     (m)->integral = &h->mb.pic.p_integral[list][ref][(xoff)+(yoff)*(m)->i_stride[0]];
1036
1037 #define REF_COST(list, ref) \
1038     (a->i_lambda * bs_size_te( h->sh.i_num_ref_idx_l##list##_active - 1, ref ))
1039
1040 static void x264_mb_analyse_inter_p16x16( x264_t *h, x264_mb_analysis_t *a )
1041 {
1042     x264_me_t m;
1043     int i_ref, i_mvc;
1044     DECLARE_ALIGNED_4( int16_t mvc[8][2] );
1045     int i_halfpel_thresh = INT_MAX;
1046     int *p_halfpel_thresh = h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh : NULL;
1047
1048     /* 16x16 Search on all ref frame */
1049     m.i_pixel = PIXEL_16x16;
1050     m.p_cost_mv = a->p_cost_mv;
1051     LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 0 );
1052
1053     a->l0.me16x16.cost = INT_MAX;
1054     for( i_ref = 0; i_ref < h->mb.pic.i_fref[0]; i_ref++ )
1055     {
1056         const int i_ref_cost = REF_COST( 0, i_ref );
1057         i_halfpel_thresh -= i_ref_cost;
1058         m.i_ref_cost = i_ref_cost;
1059         m.i_ref = i_ref;
1060
1061         /* search with ref */
1062         LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 0 );
1063         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
1064         x264_mb_predict_mv_ref16x16( h, 0, i_ref, mvc, &i_mvc );
1065         x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );
1066
1067         /* early termination
1068          * SSD threshold would probably be better than SATD */
1069         if( i_ref == 0
1070             && a->b_try_pskip
1071             && m.cost-m.cost_mv < 300*a->i_lambda
1072             &&  abs(m.mv[0]-h->mb.cache.pskip_mv[0])
1073               + abs(m.mv[1]-h->mb.cache.pskip_mv[1]) <= 1
1074             && x264_macroblock_probe_pskip( h ) )
1075         {
1076             h->mb.i_type = P_SKIP;
1077             x264_analyse_update_cache( h, a );
1078             assert( h->mb.cache.pskip_mv[1] <= h->mb.mv_max_spel[1] || h->param.i_threads == 1 );
1079             return;
1080         }
1081
1082         m.cost += i_ref_cost;
1083         i_halfpel_thresh += i_ref_cost;
1084
1085         if( m.cost < a->l0.me16x16.cost )
1086             h->mc.memcpy_aligned( &a->l0.me16x16, &m, sizeof(x264_me_t) );
1087
1088         /* save mv for predicting neighbors */
1089         *(uint32_t*)a->l0.mvc[i_ref][0] =
1090         *(uint32_t*)h->mb.mvr[0][i_ref][h->mb.i_mb_xy] = *(uint32_t*)m.mv;
1091     }
1092
1093     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.me16x16.i_ref );
1094     assert( a->l0.me16x16.mv[1] <= h->mb.mv_max_spel[1] || h->param.i_threads == 1 );
1095
1096     h->mb.i_type = P_L0;
1097     if( a->b_mbrd )
1098     {
1099         x264_mb_cache_fenc_satd( h );
1100         if( a->l0.me16x16.i_ref == 0 && *(uint32_t*)a->l0.me16x16.mv == *(uint32_t*)h->mb.cache.pskip_mv )
1101         {
1102             h->mb.i_partition = D_16x16;
1103             x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
1104             a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
1105         }
1106     }
1107 }
1108
1109 static void x264_mb_analyse_inter_p8x8_mixed_ref( x264_t *h, x264_mb_analysis_t *a )
1110 {
1111     x264_me_t m;
1112     int i_ref;
1113     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1114     int i_halfpel_thresh = INT_MAX;
1115     int *p_halfpel_thresh = /*h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh : */NULL;
1116     int i;
1117     int i_maxref = h->mb.pic.i_fref[0]-1;
1118
1119     h->mb.i_partition = D_8x8;
1120
1121     /* early termination: if 16x16 chose ref 0, then evalute no refs older
1122      * than those used by the neighbors */
1123     if( i_maxref > 0 && a->l0.me16x16.i_ref == 0 &&
1124         h->mb.i_mb_type_top && h->mb.i_mb_type_left )
1125     {
1126         i_maxref = 0;
1127         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 - 1 ] );
1128         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 + 0 ] );
1129         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 + 2 ] );
1130         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 - 8 + 4 ] );
1131         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 + 0 - 1 ] );
1132         i_maxref = X264_MAX( i_maxref, h->mb.cache.ref[0][ X264_SCAN8_0 + 2*8 - 1 ] );
1133     }
1134
1135     for( i_ref = 0; i_ref <= i_maxref; i_ref++ )
1136          *(uint32_t*)a->l0.mvc[i_ref][0] = *(uint32_t*)h->mb.mvr[0][i_ref][h->mb.i_mb_xy];
1137
1138     for( i = 0; i < 4; i++ )
1139     {
1140         x264_me_t *l0m = &a->l0.me8x8[i];
1141         const int x8 = i%2;
1142         const int y8 = i/2;
1143
1144         m.i_pixel = PIXEL_8x8;
1145         m.p_cost_mv = a->p_cost_mv;
1146
1147         LOAD_FENC( &m, p_fenc, 8*x8, 8*y8 );
1148         l0m->cost = INT_MAX;
1149         for( i_ref = 0; i_ref <= i_maxref; i_ref++ )
1150         {
1151             const int i_ref_cost = REF_COST( 0, i_ref );
1152             i_halfpel_thresh -= i_ref_cost;
1153             m.i_ref_cost = i_ref_cost;
1154             m.i_ref = i_ref;
1155
1156             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*x8, 8*y8 );
1157             x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, i_ref );
1158             x264_mb_predict_mv( h, 0, 4*i, 2, m.mvp );
1159             x264_me_search_ref( h, &m, a->l0.mvc[i_ref], i+1, p_halfpel_thresh );
1160
1161             m.cost += i_ref_cost;
1162             i_halfpel_thresh += i_ref_cost;
1163             *(uint32_t*)a->l0.mvc[i_ref][i+1] = *(uint32_t*)m.mv;
1164
1165             if( m.cost < l0m->cost )
1166                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
1167         }
1168         x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, 0, l0m->mv );
1169         x264_macroblock_cache_ref( h, 2*x8, 2*y8, 2, 2, 0, l0m->i_ref );
1170
1171         /* mb type cost */
1172         l0m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
1173     }
1174
1175     a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
1176                       a->l0.me8x8[2].cost + a->l0.me8x8[3].cost;
1177     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
1178     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
1179 }
1180
1181 static void x264_mb_analyse_inter_p8x8( x264_t *h, x264_mb_analysis_t *a )
1182 {
1183     const int i_ref = a->l0.me16x16.i_ref;
1184     const int i_ref_cost = REF_COST( 0, i_ref );
1185     uint8_t  **p_fref = h->mb.pic.p_fref[0][i_ref];
1186     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1187     int i_mvc;
1188     int16_t (*mvc)[2] = a->l0.mvc[i_ref];
1189     int i;
1190
1191     /* XXX Needed for x264_mb_predict_mv */
1192     h->mb.i_partition = D_8x8;
1193
1194     i_mvc = 1;
1195     *(uint32_t*)mvc[0] = *(uint32_t*)a->l0.me16x16.mv;
1196
1197     for( i = 0; i < 4; i++ )
1198     {
1199         x264_me_t *m = &a->l0.me8x8[i];
1200         const int x8 = i%2;
1201         const int y8 = i/2;
1202
1203         m->i_pixel = PIXEL_8x8;
1204         m->p_cost_mv = a->p_cost_mv;
1205         m->i_ref_cost = i_ref_cost;
1206         m->i_ref = i_ref;
1207
1208         LOAD_FENC( m, p_fenc, 8*x8, 8*y8 );
1209         LOAD_HPELS( m, p_fref, 0, i_ref, 8*x8, 8*y8 );
1210         x264_mb_predict_mv( h, 0, 4*i, 2, m->mvp );
1211         x264_me_search( h, m, mvc, i_mvc );
1212
1213         x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, 0, m->mv );
1214
1215         *(uint32_t*)mvc[i_mvc] = *(uint32_t*)m->mv;
1216         i_mvc++;
1217
1218         /* mb type cost */
1219         m->cost += i_ref_cost;
1220         m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
1221     }
1222
1223     /* theoretically this should include 4*ref_cost,
1224      * but 3 seems a better approximation of cabac. */
1225     a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
1226                       a->l0.me8x8[2].cost + a->l0.me8x8[3].cost -
1227                       REF_COST( 0, a->l0.me16x16.i_ref );
1228     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
1229     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
1230 }
1231
1232 static void x264_mb_analyse_inter_p16x8( x264_t *h, x264_mb_analysis_t *a )
1233 {
1234     x264_me_t m;
1235     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1236     DECLARE_ALIGNED_4( int16_t mvc[3][2] );
1237     int i, j;
1238
1239     /* XXX Needed for x264_mb_predict_mv */
1240     h->mb.i_partition = D_16x8;
1241
1242     for( i = 0; i < 2; i++ )
1243     {
1244         x264_me_t *l0m = &a->l0.me16x8[i];
1245         const int ref8[2] = { a->l0.me8x8[2*i].i_ref, a->l0.me8x8[2*i+1].i_ref };
1246         const int i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;
1247
1248         m.i_pixel = PIXEL_16x8;
1249         m.p_cost_mv = a->p_cost_mv;
1250
1251         LOAD_FENC( &m, p_fenc, 0, 8*i );
1252         l0m->cost = INT_MAX;
1253         for( j = 0; j < i_ref8s; j++ )
1254         {
1255             const int i_ref = ref8[j];
1256             const int i_ref_cost = REF_COST( 0, i_ref );
1257             m.i_ref_cost = i_ref_cost;
1258             m.i_ref = i_ref;
1259
1260             /* if we skipped the 16x16 predictor, we wouldn't have to copy anything... */
1261             *(uint32_t*)mvc[0] = *(uint32_t*)a->l0.mvc[i_ref][0];
1262             *(uint32_t*)mvc[1] = *(uint32_t*)a->l0.mvc[i_ref][2*i+1];
1263             *(uint32_t*)mvc[2] = *(uint32_t*)a->l0.mvc[i_ref][2*i+2];
1264
1265             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 8*i );
1266             x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, 0, i_ref );
1267             x264_mb_predict_mv( h, 0, 8*i, 4, m.mvp );
1268             x264_me_search( h, &m, mvc, 3 );
1269
1270             m.cost += i_ref_cost;
1271
1272             if( m.cost < l0m->cost )
1273                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
1274         }
1275         x264_macroblock_cache_mv_ptr( h, 0, 2*i, 4, 2, 0, l0m->mv );
1276         x264_macroblock_cache_ref( h, 0, 2*i, 4, 2, 0, l0m->i_ref );
1277     }
1278
1279     a->l0.i_cost16x8 = a->l0.me16x8[0].cost + a->l0.me16x8[1].cost;
1280 }
1281
1282 static void x264_mb_analyse_inter_p8x16( x264_t *h, x264_mb_analysis_t *a )
1283 {
1284     x264_me_t m;
1285     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1286     DECLARE_ALIGNED_4( int16_t mvc[3][2] );
1287     int i, j;
1288
1289     /* XXX Needed for x264_mb_predict_mv */
1290     h->mb.i_partition = D_8x16;
1291
1292     for( i = 0; i < 2; i++ )
1293     {
1294         x264_me_t *l0m = &a->l0.me8x16[i];
1295         const int ref8[2] = { a->l0.me8x8[i].i_ref, a->l0.me8x8[i+2].i_ref };
1296         const int i_ref8s = ( ref8[0] == ref8[1] ) ? 1 : 2;
1297
1298         m.i_pixel = PIXEL_8x16;
1299         m.p_cost_mv = a->p_cost_mv;
1300
1301         LOAD_FENC( &m, p_fenc, 8*i, 0 );
1302         l0m->cost = INT_MAX;
1303         for( j = 0; j < i_ref8s; j++ )
1304         {
1305             const int i_ref = ref8[j];
1306             const int i_ref_cost = REF_COST( 0, i_ref );
1307             m.i_ref_cost = i_ref_cost;
1308             m.i_ref = i_ref;
1309
1310             *(uint32_t*)mvc[0] = *(uint32_t*)a->l0.mvc[i_ref][0];
1311             *(uint32_t*)mvc[1] = *(uint32_t*)a->l0.mvc[i_ref][i+1];
1312             *(uint32_t*)mvc[2] = *(uint32_t*)a->l0.mvc[i_ref][i+3];
1313
1314             LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 8*i, 0 );
1315             x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, 0, i_ref );
1316             x264_mb_predict_mv( h, 0, 4*i, 2, m.mvp );
1317             x264_me_search( h, &m, mvc, 3 );
1318
1319             m.cost += i_ref_cost;
1320
1321             if( m.cost < l0m->cost )
1322                 h->mc.memcpy_aligned( l0m, &m, sizeof(x264_me_t) );
1323         }
1324         x264_macroblock_cache_mv_ptr( h, 2*i, 0, 2, 4, 0, l0m->mv );
1325         x264_macroblock_cache_ref( h, 2*i, 0, 2, 4, 0, l0m->i_ref );
1326     }
1327
1328     a->l0.i_cost8x16 = a->l0.me8x16[0].cost + a->l0.me8x16[1].cost;
1329 }
1330
1331 static int x264_mb_analyse_inter_p4x4_chroma( x264_t *h, x264_mb_analysis_t *a, uint8_t **p_fref, int i8x8, int pixel )
1332 {
1333     DECLARE_ALIGNED_8( uint8_t pix1[16*8] );
1334     uint8_t *pix2 = pix1+8;
1335     const int i_stride = h->mb.pic.i_stride[1];
1336     const int or = 4*(i8x8&1) + 2*(i8x8&2)*i_stride;
1337     const int oe = 4*(i8x8&1) + 2*(i8x8&2)*FENC_STRIDE;
1338
1339 #define CHROMA4x4MC( width, height, me, x, y ) \
1340     h->mc.mc_chroma( &pix1[x+y*16], 16, &p_fref[4][or+x+y*i_stride], i_stride, (me).mv[0], (me).mv[1], width, height ); \
1341     h->mc.mc_chroma( &pix2[x+y*16], 16, &p_fref[5][or+x+y*i_stride], i_stride, (me).mv[0], (me).mv[1], width, height );
1342
1343     if( pixel == PIXEL_4x4 )
1344     {
1345         CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][0], 0,0 );
1346         CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][1], 2,0 );
1347         CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][2], 0,2 );
1348         CHROMA4x4MC( 2,2, a->l0.me4x4[i8x8][3], 2,2 );
1349     }
1350     else if( pixel == PIXEL_8x4 )
1351     {
1352         CHROMA4x4MC( 4,2, a->l0.me8x4[i8x8][0], 0,0 );
1353         CHROMA4x4MC( 4,2, a->l0.me8x4[i8x8][1], 0,2 );
1354     }
1355     else
1356     {
1357         CHROMA4x4MC( 2,4, a->l0.me4x8[i8x8][0], 0,0 );
1358         CHROMA4x4MC( 2,4, a->l0.me4x8[i8x8][1], 2,0 );
1359     }
1360
1361     return h->pixf.mbcmp[PIXEL_4x4]( &h->mb.pic.p_fenc[1][oe], FENC_STRIDE, pix1, 16 )
1362          + h->pixf.mbcmp[PIXEL_4x4]( &h->mb.pic.p_fenc[2][oe], FENC_STRIDE, pix2, 16 );
1363 }
1364
1365 static void x264_mb_analyse_inter_p4x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
1366 {
1367     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
1368     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1369     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1370     int i4x4;
1371
1372     /* XXX Needed for x264_mb_predict_mv */
1373     h->mb.i_partition = D_8x8;
1374
1375     for( i4x4 = 0; i4x4 < 4; i4x4++ )
1376     {
1377         const int idx = 4*i8x8 + i4x4;
1378         const int x4 = block_idx_x[idx];
1379         const int y4 = block_idx_y[idx];
1380         const int i_mvc = (i4x4 == 0);
1381
1382         x264_me_t *m = &a->l0.me4x4[i8x8][i4x4];
1383
1384         m->i_pixel = PIXEL_4x4;
1385         m->p_cost_mv = a->p_cost_mv;
1386
1387         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
1388         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
1389
1390         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
1391         x264_me_search( h, m, &a->l0.me8x8[i8x8].mv, i_mvc );
1392
1393         x264_macroblock_cache_mv_ptr( h, x4, y4, 1, 1, 0, m->mv );
1394     }
1395     a->l0.i_cost4x4[i8x8] = a->l0.me4x4[i8x8][0].cost +
1396                             a->l0.me4x4[i8x8][1].cost +
1397                             a->l0.me4x4[i8x8][2].cost +
1398                             a->l0.me4x4[i8x8][3].cost +
1399                             REF_COST( 0, i_ref ) +
1400                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x4];
1401     if( h->mb.b_chroma_me )
1402         a->l0.i_cost4x4[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_4x4 );
1403 }
1404
1405 static void x264_mb_analyse_inter_p8x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
1406 {
1407     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
1408     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1409     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1410     int i8x4;
1411
1412     /* XXX Needed for x264_mb_predict_mv */
1413     h->mb.i_partition = D_8x8;
1414
1415     for( i8x4 = 0; i8x4 < 2; i8x4++ )
1416     {
1417         const int idx = 4*i8x8 + 2*i8x4;
1418         const int x4 = block_idx_x[idx];
1419         const int y4 = block_idx_y[idx];
1420         const int i_mvc = (i8x4 == 0);
1421
1422         x264_me_t *m = &a->l0.me8x4[i8x8][i8x4];
1423
1424         m->i_pixel = PIXEL_8x4;
1425         m->p_cost_mv = a->p_cost_mv;
1426
1427         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
1428         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
1429
1430         x264_mb_predict_mv( h, 0, idx, 2, m->mvp );
1431         x264_me_search( h, m, &a->l0.me4x4[i8x8][0].mv, i_mvc );
1432
1433         x264_macroblock_cache_mv_ptr( h, x4, y4, 2, 1, 0, m->mv );
1434     }
1435     a->l0.i_cost8x4[i8x8] = a->l0.me8x4[i8x8][0].cost + a->l0.me8x4[i8x8][1].cost +
1436                             REF_COST( 0, i_ref ) +
1437                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x4];
1438     if( h->mb.b_chroma_me )
1439         a->l0.i_cost8x4[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_8x4 );
1440 }
1441
1442 static void x264_mb_analyse_inter_p4x8( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
1443 {
1444     uint8_t  **p_fref = h->mb.pic.p_fref[0][a->l0.me8x8[i8x8].i_ref];
1445     uint8_t  **p_fenc = h->mb.pic.p_fenc;
1446     const int i_ref = a->l0.me8x8[i8x8].i_ref;
1447     int i4x8;
1448
1449     /* XXX Needed for x264_mb_predict_mv */
1450     h->mb.i_partition = D_8x8;
1451
1452     for( i4x8 = 0; i4x8 < 2; i4x8++ )
1453     {
1454         const int idx = 4*i8x8 + i4x8;
1455         const int x4 = block_idx_x[idx];
1456         const int y4 = block_idx_y[idx];
1457         const int i_mvc = (i4x8 == 0);
1458
1459         x264_me_t *m = &a->l0.me4x8[i8x8][i4x8];
1460
1461         m->i_pixel = PIXEL_4x8;
1462         m->p_cost_mv = a->p_cost_mv;
1463
1464         LOAD_FENC( m, p_fenc, 4*x4, 4*y4 );
1465         LOAD_HPELS( m, p_fref, 0, i_ref, 4*x4, 4*y4 );
1466
1467         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
1468         x264_me_search( h, m, &a->l0.me4x4[i8x8][0].mv, i_mvc );
1469
1470         x264_macroblock_cache_mv_ptr( h, x4, y4, 1, 2, 0, m->mv );
1471     }
1472     a->l0.i_cost4x8[i8x8] = a->l0.me4x8[i8x8][0].cost + a->l0.me4x8[i8x8][1].cost +
1473                             REF_COST( 0, i_ref ) +
1474                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x8];
1475     if( h->mb.b_chroma_me )
1476         a->l0.i_cost4x8[i8x8] += x264_mb_analyse_inter_p4x4_chroma( h, a, p_fref, i8x8, PIXEL_4x8 );
1477 }
1478
1479 static void x264_mb_analyse_inter_direct( x264_t *h, x264_mb_analysis_t *a )
1480 {
1481     /* Assumes that fdec still contains the results of
1482      * x264_mb_predict_mv_direct16x16 and x264_mb_mc */
1483
1484     uint8_t **p_fenc = h->mb.pic.p_fenc;
1485     uint8_t **p_fdec = h->mb.pic.p_fdec;
1486     int i;
1487
1488     a->i_cost16x16direct = a->i_lambda * i_mb_b_cost_table[B_DIRECT];
1489     for( i = 0; i < 4; i++ )
1490     {
1491         const int x = (i&1)*8;
1492         const int y = (i>>1)*8;
1493         a->i_cost16x16direct +=
1494         a->i_cost8x8direct[i] =
1495             h->pixf.mbcmp[PIXEL_8x8]( &p_fenc[0][x+y*FENC_STRIDE], FENC_STRIDE, &p_fdec[0][x+y*FDEC_STRIDE], FDEC_STRIDE );
1496
1497         /* mb type cost */
1498         a->i_cost8x8direct[i] += a->i_lambda * i_sub_mb_b_cost_table[D_DIRECT_8x8];
1499     }
1500 }
1501
1502 #define WEIGHTED_AVG( size, pix, stride, src1, stride1, src2, stride2 ) \
1503 { \
1504     h->mc.avg[size]( pix, stride, src1, stride1, src2, stride2, h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] ); \
1505 }
1506
1507 static void x264_mb_analyse_inter_b16x16( x264_t *h, x264_mb_analysis_t *a )
1508 {
1509     DECLARE_ALIGNED_16( uint8_t pix0[16*16] );
1510     DECLARE_ALIGNED_16( uint8_t pix1[16*16] );
1511     uint8_t *src0, *src1;
1512     int stride0 = 16, stride1 = 16;
1513
1514     x264_me_t m;
1515     int i_ref, i_mvc;
1516     DECLARE_ALIGNED_4( int16_t mvc[9][2] );
1517     int i_halfpel_thresh = INT_MAX;
1518     int *p_halfpel_thresh = h->mb.pic.i_fref[0]>1 ? &i_halfpel_thresh : NULL;
1519
1520     /* 16x16 Search on all ref frame */
1521     m.i_pixel = PIXEL_16x16;
1522     m.p_cost_mv = a->p_cost_mv;
1523     LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 0 );
1524
1525     /* ME for List 0 */
1526     a->l0.me16x16.cost = INT_MAX;
1527     for( i_ref = 0; i_ref < h->mb.pic.i_fref[0]; i_ref++ )
1528     {
1529         /* search with ref */
1530         LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 0 );
1531         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
1532         x264_mb_predict_mv_ref16x16( h, 0, i_ref, mvc, &i_mvc );
1533         x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );
1534
1535         /* add ref cost */
1536         m.cost += REF_COST( 0, i_ref );
1537
1538         if( m.cost < a->l0.me16x16.cost )
1539         {
1540             a->l0.i_ref = i_ref;
1541             h->mc.memcpy_aligned( &a->l0.me16x16, &m, sizeof(x264_me_t) );
1542         }
1543
1544         /* save mv for predicting neighbors */
1545         *(uint32_t*)h->mb.mvr[0][i_ref][h->mb.i_mb_xy] = *(uint32_t*)m.mv;
1546     }
1547     /* subtract ref cost, so we don't have to add it for the other MB types */
1548     a->l0.me16x16.cost -= REF_COST( 0, a->l0.i_ref );
1549
1550     /* ME for list 1 */
1551     i_halfpel_thresh = INT_MAX;
1552     p_halfpel_thresh = h->mb.pic.i_fref[1]>1 ? &i_halfpel_thresh : NULL;
1553     a->l1.me16x16.cost = INT_MAX;
1554     for( i_ref = 0; i_ref < h->mb.pic.i_fref[1]; i_ref++ )
1555     {
1556         /* search with ref */
1557         LOAD_HPELS( &m, h->mb.pic.p_fref[1][i_ref], 1, i_ref, 0, 0 );
1558         x264_mb_predict_mv_16x16( h, 1, i_ref, m.mvp );
1559         x264_mb_predict_mv_ref16x16( h, 1, i_ref, mvc, &i_mvc );
1560         x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );
1561
1562         /* add ref cost */
1563         m.cost += REF_COST( 1, i_ref );
1564
1565         if( m.cost < a->l1.me16x16.cost )
1566         {
1567             a->l1.i_ref = i_ref;
1568             h->mc.memcpy_aligned( &a->l1.me16x16, &m, sizeof(x264_me_t) );
1569         }
1570
1571         /* save mv for predicting neighbors */
1572         *(uint32_t*)h->mb.mvr[1][i_ref][h->mb.i_mb_xy] = *(uint32_t*)m.mv;
1573     }
1574     /* subtract ref cost, so we don't have to add it for the other MB types */
1575     a->l1.me16x16.cost -= REF_COST( 1, a->l1.i_ref );
1576
1577     /* Set global ref, needed for other modes? */
1578     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
1579     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.i_ref );
1580
1581     /* get cost of BI mode */
1582     src0 = h->mc.get_ref( pix0, &stride0,
1583                            h->mb.pic.p_fref[0][a->l0.i_ref], h->mb.pic.i_stride[0],
1584                            a->l0.me16x16.mv[0], a->l0.me16x16.mv[1], 16, 16 );
1585     src1 = h->mc.get_ref( pix1, &stride1,
1586                            h->mb.pic.p_fref[1][a->l1.i_ref], h->mb.pic.i_stride[0],
1587                            a->l1.me16x16.mv[0], a->l1.me16x16.mv[1], 16, 16 );
1588
1589     h->mc.avg[PIXEL_16x16]( pix0, 16, src0, stride0, src1, stride1, h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
1590
1591     a->i_cost16x16bi = h->pixf.mbcmp[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE, pix0, 16 )
1592                      + REF_COST( 0, a->l0.i_ref )
1593                      + REF_COST( 1, a->l1.i_ref )
1594                      + a->l0.me16x16.cost_mv
1595                      + a->l1.me16x16.cost_mv;
1596
1597     /* mb type cost */
1598     a->i_cost16x16bi   += a->i_lambda * i_mb_b_cost_table[B_BI_BI];
1599     a->l0.me16x16.cost += a->i_lambda * i_mb_b_cost_table[B_L0_L0];
1600     a->l1.me16x16.cost += a->i_lambda * i_mb_b_cost_table[B_L1_L1];
1601 }
1602
1603 static inline void x264_mb_cache_mv_p8x8( x264_t *h, x264_mb_analysis_t *a, int i )
1604 {
1605     const int x = 2*(i%2);
1606     const int y = 2*(i/2);
1607
1608     switch( h->mb.i_sub_partition[i] )
1609     {
1610         case D_L0_8x8:
1611             x264_macroblock_cache_mv_ptr( h, x, y, 2, 2, 0, a->l0.me8x8[i].mv );
1612             break;
1613         case D_L0_8x4:
1614             x264_macroblock_cache_mv_ptr( h, x, y+0, 2, 1, 0, a->l0.me8x4[i][0].mv );
1615             x264_macroblock_cache_mv_ptr( h, x, y+1, 2, 1, 0, a->l0.me8x4[i][1].mv );
1616             break;
1617         case D_L0_4x8:
1618             x264_macroblock_cache_mv_ptr( h, x+0, y, 1, 2, 0, a->l0.me4x8[i][0].mv );
1619             x264_macroblock_cache_mv_ptr( h, x+1, y, 1, 2, 0, a->l0.me4x8[i][1].mv );
1620             break;
1621         case D_L0_4x4:
1622             x264_macroblock_cache_mv_ptr( h, x+0, y+0, 1, 1, 0, a->l0.me4x4[i][0].mv );
1623             x264_macroblock_cache_mv_ptr( h, x+1, y+0, 1, 1, 0, a->l0.me4x4[i][1].mv );
1624             x264_macroblock_cache_mv_ptr( h, x+0, y+1, 1, 1, 0, a->l0.me4x4[i][2].mv );
1625             x264_macroblock_cache_mv_ptr( h, x+1, y+1, 1, 1, 0, a->l0.me4x4[i][3].mv );
1626             break;
1627         default:
1628             x264_log( h, X264_LOG_ERROR, "internal error\n" );
1629             break;
1630     }
1631 }
1632
1633 #define CACHE_MV_BI(x,y,dx,dy,me0,me1,part) \
1634     if( x264_mb_partition_listX_table[0][part] ) \
1635     { \
1636         x264_macroblock_cache_ref( h, x,y,dx,dy, 0, a->l0.i_ref ); \
1637         x264_macroblock_cache_mv_ptr( h, x,y,dx,dy, 0, me0.mv ); \
1638     } \
1639     else \
1640     { \
1641         x264_macroblock_cache_ref( h, x,y,dx,dy, 0, -1 ); \
1642         x264_macroblock_cache_mv(  h, x,y,dx,dy, 0, 0 ); \
1643         if( b_mvd ) \
1644             x264_macroblock_cache_mvd( h, x,y,dx,dy, 0, 0 ); \
1645     } \
1646     if( x264_mb_partition_listX_table[1][part] ) \
1647     { \
1648         x264_macroblock_cache_ref( h, x,y,dx,dy, 1, a->l1.i_ref ); \
1649         x264_macroblock_cache_mv_ptr( h, x,y,dx,dy, 1, me1.mv ); \
1650     } \
1651     else \
1652     { \
1653         x264_macroblock_cache_ref( h, x,y,dx,dy, 1, -1 ); \
1654         x264_macroblock_cache_mv(  h, x,y,dx,dy, 1, 0 ); \
1655         if( b_mvd ) \
1656             x264_macroblock_cache_mvd( h, x,y,dx,dy, 1, 0 ); \
1657     }
1658
1659 static inline void x264_mb_cache_mv_b8x8( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
1660 {
1661     int x = (i%2)*2;
1662     int y = (i/2)*2;
1663     if( h->mb.i_sub_partition[i] == D_DIRECT_8x8 )
1664     {
1665         x264_mb_load_mv_direct8x8( h, i );
1666         if( b_mvd )
1667         {
1668             x264_macroblock_cache_mvd(  h, x, y, 2, 2, 0, 0 );
1669             x264_macroblock_cache_mvd(  h, x, y, 2, 2, 1, 0 );
1670             x264_macroblock_cache_skip( h, x, y, 2, 2, 1 );
1671         }
1672     }
1673     else
1674     {
1675         CACHE_MV_BI( x, y, 2, 2, a->l0.me8x8[i], a->l1.me8x8[i], h->mb.i_sub_partition[i] );
1676     }
1677 }
1678 static inline void x264_mb_cache_mv_b16x8( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
1679 {
1680     CACHE_MV_BI( 0, 2*i, 4, 2, a->l0.me16x8[i], a->l1.me16x8[i], a->i_mb_partition16x8[i] );
1681 }
1682 static inline void x264_mb_cache_mv_b8x16( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
1683 {
1684     CACHE_MV_BI( 2*i, 0, 2, 4, a->l0.me8x16[i], a->l1.me8x16[i], a->i_mb_partition8x16[i] );
1685 }
1686 #undef CACHE_MV_BI
1687
1688 static void x264_mb_analyse_inter_b8x8( x264_t *h, x264_mb_analysis_t *a )
1689 {
1690     uint8_t **p_fref[2] =
1691         { h->mb.pic.p_fref[0][a->l0.i_ref],
1692           h->mb.pic.p_fref[1][a->l1.i_ref] };
1693     DECLARE_ALIGNED_8( uint8_t pix[2][8*8] );
1694     int i, l;
1695
1696     /* XXX Needed for x264_mb_predict_mv */
1697     h->mb.i_partition = D_8x8;
1698
1699     a->i_cost8x8bi = 0;
1700
1701     for( i = 0; i < 4; i++ )
1702     {
1703         const int x8 = i%2;
1704         const int y8 = i/2;
1705         int i_part_cost;
1706         int i_part_cost_bi = 0;
1707         int stride[2] = {8,8};
1708         uint8_t *src[2];
1709
1710         for( l = 0; l < 2; l++ )
1711         {
1712             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
1713             x264_me_t *m = &lX->me8x8[i];
1714
1715             m->i_pixel = PIXEL_8x8;
1716             m->p_cost_mv = a->p_cost_mv;
1717
1718             LOAD_FENC( m, h->mb.pic.p_fenc, 8*x8, 8*y8 );
1719             LOAD_HPELS( m, p_fref[l], l, lX->i_ref, 8*x8, 8*y8 );
1720
1721             x264_mb_predict_mv( h, l, 4*i, 2, m->mvp );
1722             x264_me_search( h, m, &lX->me16x16.mv, 1 );
1723
1724             x264_macroblock_cache_mv_ptr( h, 2*x8, 2*y8, 2, 2, l, m->mv );
1725
1726             /* BI mode */
1727             src[l] = h->mc.get_ref( pix[l], &stride[l], m->p_fref, m->i_stride[0],
1728                                     m->mv[0], m->mv[1], 8, 8 );
1729             i_part_cost_bi += m->cost_mv;
1730             /* FIXME: ref cost */
1731         }
1732         h->mc.avg[PIXEL_8x8]( pix[0], 8, src[0], stride[0], src[1], stride[1], h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
1733         i_part_cost_bi += h->pixf.mbcmp[PIXEL_8x8]( a->l0.me8x8[i].p_fenc[0], FENC_STRIDE, pix[0], 8 )
1734                         + a->i_lambda * i_sub_mb_b_cost_table[D_BI_8x8];
1735         a->l0.me8x8[i].cost += a->i_lambda * i_sub_mb_b_cost_table[D_L0_8x8];
1736         a->l1.me8x8[i].cost += a->i_lambda * i_sub_mb_b_cost_table[D_L1_8x8];
1737
1738         i_part_cost = a->l0.me8x8[i].cost;
1739         h->mb.i_sub_partition[i] = D_L0_8x8;
1740         COPY2_IF_LT( i_part_cost, a->l1.me8x8[i].cost, h->mb.i_sub_partition[i], D_L1_8x8 );
1741         COPY2_IF_LT( i_part_cost, i_part_cost_bi, h->mb.i_sub_partition[i], D_BI_8x8 );
1742         COPY2_IF_LT( i_part_cost, a->i_cost8x8direct[i], h->mb.i_sub_partition[i], D_DIRECT_8x8 );
1743         a->i_cost8x8bi += i_part_cost;
1744
1745         /* XXX Needed for x264_mb_predict_mv */
1746         x264_mb_cache_mv_b8x8( h, a, i, 0 );
1747     }
1748
1749     /* mb type cost */
1750     a->i_cost8x8bi += a->i_lambda * i_mb_b_cost_table[B_8x8];
1751 }
1752
1753 static void x264_mb_analyse_inter_b16x8( x264_t *h, x264_mb_analysis_t *a )
1754 {
1755     uint8_t **p_fref[2] =
1756         { h->mb.pic.p_fref[0][a->l0.i_ref],
1757           h->mb.pic.p_fref[1][a->l1.i_ref] };
1758     DECLARE_ALIGNED_16( uint8_t pix[2][16*8] );
1759     DECLARE_ALIGNED_4( int16_t mvc[2][2] );
1760     int i, l;
1761
1762     h->mb.i_partition = D_16x8;
1763     a->i_cost16x8bi = 0;
1764
1765     for( i = 0; i < 2; i++ )
1766     {
1767         int i_part_cost;
1768         int i_part_cost_bi = 0;
1769         int stride[2] = {16,16};
1770         uint8_t *src[2];
1771
1772         /* TODO: check only the list(s) that were used in b8x8? */
1773         for( l = 0; l < 2; l++ )
1774         {
1775             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
1776             x264_me_t *m = &lX->me16x8[i];
1777
1778             m->i_pixel = PIXEL_16x8;
1779             m->p_cost_mv = a->p_cost_mv;
1780
1781             LOAD_FENC( m, h->mb.pic.p_fenc, 0, 8*i );
1782             LOAD_HPELS( m, p_fref[l], l, lX->i_ref, 0, 8*i );
1783
1784             *(uint32_t*)mvc[0] = *(uint32_t*)lX->me8x8[2*i].mv;
1785             *(uint32_t*)mvc[1] = *(uint32_t*)lX->me8x8[2*i+1].mv;
1786
1787             x264_mb_predict_mv( h, l, 8*i, 2, m->mvp );
1788             x264_me_search( h, m, mvc, 2 );
1789
1790             /* BI mode */
1791             src[l] = h->mc.get_ref( pix[l], &stride[l], m->p_fref, m->i_stride[0],
1792                                     m->mv[0], m->mv[1], 16, 8 );
1793             /* FIXME: ref cost */
1794             i_part_cost_bi += m->cost_mv;
1795         }
1796         h->mc.avg[PIXEL_16x8]( pix[0], 16, src[0], stride[0], src[1], stride[1], h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
1797         i_part_cost_bi += h->pixf.mbcmp[PIXEL_16x8]( a->l0.me16x8[i].p_fenc[0], FENC_STRIDE, pix[0], 16 );
1798
1799         i_part_cost = a->l0.me16x8[i].cost;
1800         a->i_mb_partition16x8[i] = D_L0_8x8; /* not actually 8x8, only the L0 matters */
1801         if( a->l1.me16x8[i].cost < i_part_cost )
1802         {
1803             i_part_cost = a->l1.me16x8[i].cost;
1804             a->i_mb_partition16x8[i] = D_L1_8x8;
1805         }
1806         if( i_part_cost_bi + a->i_lambda * 1 < i_part_cost )
1807         {
1808             i_part_cost = i_part_cost_bi;
1809             a->i_mb_partition16x8[i] = D_BI_8x8;
1810         }
1811         a->i_cost16x8bi += i_part_cost;
1812
1813         x264_mb_cache_mv_b16x8( h, a, i, 0 );
1814     }
1815
1816     /* mb type cost */
1817     a->i_mb_type16x8 = B_L0_L0
1818         + (a->i_mb_partition16x8[0]>>2) * 3
1819         + (a->i_mb_partition16x8[1]>>2);
1820     a->i_cost16x8bi += a->i_lambda * i_mb_b16x8_cost_table[a->i_mb_type16x8];
1821 }
1822
1823 static void x264_mb_analyse_inter_b8x16( x264_t *h, x264_mb_analysis_t *a )
1824 {
1825     uint8_t **p_fref[2] =
1826         { h->mb.pic.p_fref[0][a->l0.i_ref],
1827           h->mb.pic.p_fref[1][a->l1.i_ref] };
1828     DECLARE_ALIGNED_8( uint8_t pix[2][8*16] );
1829     DECLARE_ALIGNED_4( int16_t mvc[2][2] );
1830     int i, l;
1831
1832     h->mb.i_partition = D_8x16;
1833     a->i_cost8x16bi = 0;
1834
1835     for( i = 0; i < 2; i++ )
1836     {
1837         int i_part_cost;
1838         int i_part_cost_bi = 0;
1839         int stride[2] = {8,8};
1840         uint8_t *src[2];
1841
1842         for( l = 0; l < 2; l++ )
1843         {
1844             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
1845             x264_me_t *m = &lX->me8x16[i];
1846
1847             m->i_pixel = PIXEL_8x16;
1848             m->p_cost_mv = a->p_cost_mv;
1849
1850             LOAD_FENC( m, h->mb.pic.p_fenc, 8*i, 0 );
1851             LOAD_HPELS( m, p_fref[l], l, lX->i_ref, 8*i, 0 );
1852
1853             *(uint32_t*)mvc[0] = *(uint32_t*)lX->me8x8[i].mv;
1854             *(uint32_t*)mvc[1] = *(uint32_t*)lX->me8x8[i+2].mv;
1855
1856             x264_mb_predict_mv( h, l, 4*i, 2, m->mvp );
1857             x264_me_search( h, m, mvc, 2 );
1858
1859             /* BI mode */
1860             src[l] = h->mc.get_ref( pix[l], &stride[l], m->p_fref,  m->i_stride[0],
1861                                     m->mv[0], m->mv[1], 8, 16 );
1862             /* FIXME: ref cost */
1863             i_part_cost_bi += m->cost_mv;
1864         }
1865
1866         h->mc.avg[PIXEL_8x16]( pix[0], 8, src[0], stride[0], src[1], stride[1], h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref] );
1867         i_part_cost_bi += h->pixf.mbcmp[PIXEL_8x16]( a->l0.me8x16[i].p_fenc[0], FENC_STRIDE, pix[0], 8 );
1868
1869         i_part_cost = a->l0.me8x16[i].cost;
1870         a->i_mb_partition8x16[i] = D_L0_8x8;
1871         if( a->l1.me8x16[i].cost < i_part_cost )
1872         {
1873             i_part_cost = a->l1.me8x16[i].cost;
1874             a->i_mb_partition8x16[i] = D_L1_8x8;
1875         }
1876         if( i_part_cost_bi + a->i_lambda * 1 < i_part_cost )
1877         {
1878             i_part_cost = i_part_cost_bi;
1879             a->i_mb_partition8x16[i] = D_BI_8x8;
1880         }
1881         a->i_cost8x16bi += i_part_cost;
1882
1883         x264_mb_cache_mv_b8x16( h, a, i, 0 );
1884     }
1885
1886     /* mb type cost */
1887     a->i_mb_type8x16 = B_L0_L0
1888         + (a->i_mb_partition8x16[0]>>2) * 3
1889         + (a->i_mb_partition8x16[1]>>2);
1890     a->i_cost8x16bi += a->i_lambda * i_mb_b16x8_cost_table[a->i_mb_type8x16];
1891 }
1892
1893 static void x264_mb_analyse_p_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd )
1894 {
1895     int thresh = i_satd * 5/4;
1896
1897     h->mb.i_type = P_L0;
1898     if( a->l0.i_rd16x16 == COST_MAX && a->l0.me16x16.cost <= i_satd * 3/2 )
1899     {
1900         h->mb.i_partition = D_16x16;
1901         x264_analyse_update_cache( h, a );
1902         a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
1903     }
1904     a->l0.me16x16.cost = a->l0.i_rd16x16;
1905
1906     if( a->l0.i_cost16x8 <= thresh )
1907     {
1908         h->mb.i_partition = D_16x8;
1909         x264_analyse_update_cache( h, a );
1910         a->l0.i_cost16x8 = x264_rd_cost_mb( h, a->i_lambda2 );
1911     }
1912     else
1913         a->l0.i_cost16x8 = COST_MAX;
1914
1915     if( a->l0.i_cost8x16 <= thresh )
1916     {
1917         h->mb.i_partition = D_8x16;
1918         x264_analyse_update_cache( h, a );
1919         a->l0.i_cost8x16 = x264_rd_cost_mb( h, a->i_lambda2 );
1920     }
1921     else
1922         a->l0.i_cost8x16 = COST_MAX;
1923
1924     if( a->l0.i_cost8x8 <= thresh )
1925     {
1926         h->mb.i_type = P_8x8;
1927         h->mb.i_partition = D_8x8;
1928         x264_analyse_update_cache( h, a );
1929         a->l0.i_cost8x8 = x264_rd_cost_mb( h, a->i_lambda2 );
1930
1931         if( h->param.analyse.inter & X264_ANALYSE_PSUB8x8 )
1932         {
1933             /* FIXME: RD per subpartition */
1934             int part_bak[4];
1935             int i, i_cost;
1936             int b_sub8x8 = 0;
1937             for( i=0; i<4; i++ )
1938             {
1939                 part_bak[i] = h->mb.i_sub_partition[i];
1940                 b_sub8x8 |= (part_bak[i] != D_L0_8x8);
1941             }
1942             if( b_sub8x8 )
1943             {
1944                 h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
1945                 h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
1946                 x264_analyse_update_cache( h, a );
1947                 i_cost = x264_rd_cost_mb( h, a->i_lambda2 );
1948                 if( a->l0.i_cost8x8 < i_cost )
1949                 {
1950                     for( i=0; i<4; i++ )
1951                         h->mb.i_sub_partition[i] = part_bak[i];
1952                 }
1953                 else
1954                    a->l0.i_cost8x8 = i_cost;
1955             }
1956         }
1957     }
1958     else
1959         a->l0.i_cost8x8 = COST_MAX;
1960 }
1961
1962 static void x264_mb_analyse_b_rd( x264_t *h, x264_mb_analysis_t *a, int i_satd_inter )
1963 {
1964     int thresh = i_satd_inter * (17 + (!!h->mb.i_psy_rd))/16;
1965
1966     if( a->b_direct_available && a->i_rd16x16direct == COST_MAX )
1967     {
1968         h->mb.i_type = B_DIRECT;
1969         /* Assumes direct/skip MC is still in fdec */
1970         /* Requires b-rdo to be done before intra analysis */
1971         h->mb.b_skip_mc = 1;
1972         x264_analyse_update_cache( h, a );
1973         a->i_rd16x16direct = x264_rd_cost_mb( h, a->i_lambda2 );
1974         h->mb.b_skip_mc = 0;
1975     }
1976
1977     //FIXME not all the update_cache calls are needed
1978     h->mb.i_partition = D_16x16;
1979     /* L0 */
1980     if( a->l0.me16x16.cost <= thresh && a->l0.i_rd16x16 == COST_MAX )
1981     {
1982         h->mb.i_type = B_L0_L0;
1983         x264_analyse_update_cache( h, a );
1984         a->l0.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
1985     }
1986
1987     /* L1 */
1988     if( a->l1.me16x16.cost <= thresh && a->l1.i_rd16x16 == COST_MAX )
1989     {
1990         h->mb.i_type = B_L1_L1;
1991         x264_analyse_update_cache( h, a );
1992         a->l1.i_rd16x16 = x264_rd_cost_mb( h, a->i_lambda2 );
1993     }
1994
1995     /* BI */
1996     if( a->i_cost16x16bi <= thresh && a->i_rd16x16bi == COST_MAX )
1997     {
1998         h->mb.i_type = B_BI_BI;
1999         x264_analyse_update_cache( h, a );
2000         a->i_rd16x16bi = x264_rd_cost_mb( h, a->i_lambda2 );
2001     }
2002
2003     /* 8x8 */
2004     if( a->i_cost8x8bi <= thresh && a->i_rd8x8bi == COST_MAX )
2005     {
2006         h->mb.i_type = B_8x8;
2007         h->mb.i_partition = D_8x8;
2008         x264_analyse_update_cache( h, a );
2009         a->i_rd8x8bi = x264_rd_cost_mb( h, a->i_lambda2 );
2010         x264_macroblock_cache_skip( h, 0, 0, 4, 4, 0 );
2011     }
2012
2013     /* 16x8 */
2014     if( a->i_cost16x8bi <= thresh && a->i_rd16x8bi == COST_MAX )
2015     {
2016         h->mb.i_type = a->i_mb_type16x8;
2017         h->mb.i_partition = D_16x8;
2018         x264_analyse_update_cache( h, a );
2019         a->i_rd16x8bi = x264_rd_cost_mb( h, a->i_lambda2 );
2020     }
2021
2022     /* 8x16 */
2023     if( a->i_cost8x16bi <= thresh && a->i_rd8x16bi == COST_MAX )
2024     {
2025         h->mb.i_type = a->i_mb_type8x16;
2026         h->mb.i_partition = D_8x16;
2027         x264_analyse_update_cache( h, a );
2028         a->i_rd8x16bi = x264_rd_cost_mb( h, a->i_lambda2 );
2029     }
2030 }
2031
2032 static void refine_bidir( x264_t *h, x264_mb_analysis_t *a )
2033 {
2034     const int i_biweight = h->mb.bipred_weight[a->l0.i_ref][a->l1.i_ref];
2035     int i;
2036
2037     switch( h->mb.i_partition )
2038     {
2039     case D_16x16:
2040         if( h->mb.i_type == B_BI_BI )
2041             x264_me_refine_bidir( h, &a->l0.me16x16, &a->l1.me16x16, i_biweight );
2042         break;
2043     case D_16x8:
2044         for( i=0; i<2; i++ )
2045             if( a->i_mb_partition16x8[i] == D_BI_8x8 )
2046                 x264_me_refine_bidir( h, &a->l0.me16x8[i], &a->l1.me16x8[i], i_biweight );
2047         break;
2048     case D_8x16:
2049         for( i=0; i<2; i++ )
2050             if( a->i_mb_partition8x16[i] == D_BI_8x8 )
2051                 x264_me_refine_bidir( h, &a->l0.me8x16[i], &a->l1.me8x16[i], i_biweight );
2052         break;
2053     case D_8x8:
2054         for( i=0; i<4; i++ )
2055             if( h->mb.i_sub_partition[i] == D_BI_8x8 )
2056                 x264_me_refine_bidir( h, &a->l0.me8x8[i], &a->l1.me8x8[i], i_biweight );
2057         break;
2058     }
2059 }
2060
2061 static inline void x264_mb_analyse_transform( x264_t *h )
2062 {
2063     if( x264_mb_transform_8x8_allowed( h ) && h->param.analyse.b_transform_8x8 && !h->mb.b_lossless )
2064     {
2065         int i_cost4, i_cost8;
2066         /* Only luma MC is really needed, but the full MC is re-used in macroblock_encode. */
2067         x264_mb_mc( h );
2068
2069         i_cost8 = h->pixf.sa8d[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE,
2070                                              h->mb.pic.p_fdec[0], FDEC_STRIDE );
2071         i_cost4 = h->pixf.satd[PIXEL_16x16]( h->mb.pic.p_fenc[0], FENC_STRIDE,
2072                                              h->mb.pic.p_fdec[0], FDEC_STRIDE );
2073
2074         h->mb.b_transform_8x8 = i_cost8 < i_cost4;
2075         h->mb.b_skip_mc = 1;
2076     }
2077 }
2078
2079 static inline void x264_mb_analyse_transform_rd( x264_t *h, x264_mb_analysis_t *a, int *i_satd, int *i_rd )
2080 {
2081     if( x264_mb_transform_8x8_allowed( h ) && h->param.analyse.b_transform_8x8 )
2082     {
2083         int i_rd8;
2084         x264_analyse_update_cache( h, a );
2085         h->mb.b_transform_8x8 = !h->mb.b_transform_8x8;
2086         /* FIXME only luma is needed, but the score for comparison already includes chroma */
2087         i_rd8 = x264_rd_cost_mb( h, a->i_lambda2 );
2088
2089         if( *i_rd >= i_rd8 )
2090         {
2091             if( *i_rd > 0 )
2092                 *i_satd = (int64_t)(*i_satd) * i_rd8 / *i_rd;
2093             /* prevent a rare division by zero in estimated intra cost */
2094             if( *i_satd == 0 )
2095                 *i_satd = 1;
2096
2097             *i_rd = i_rd8;
2098         }
2099         else
2100             h->mb.b_transform_8x8 = !h->mb.b_transform_8x8;
2101     }
2102 }
2103
2104
2105 /*****************************************************************************
2106  * x264_macroblock_analyse:
2107  *****************************************************************************/
2108 void x264_macroblock_analyse( x264_t *h )
2109 {
2110     x264_mb_analysis_t analysis;
2111     int i_cost = COST_MAX;
2112     int i;
2113
2114     h->mb.i_qp = x264_ratecontrol_qp( h );
2115     if( h->param.rc.i_aq_mode )
2116         x264_adaptive_quant( h );
2117
2118     x264_mb_analyse_init( h, &analysis, h->mb.i_qp );
2119
2120     /*--------------------------- Do the analysis ---------------------------*/
2121     if( h->sh.i_type == SLICE_TYPE_I )
2122     {
2123         if( analysis.b_mbrd )
2124             x264_mb_cache_fenc_satd( h );
2125         x264_mb_analyse_intra( h, &analysis, COST_MAX );
2126         if( analysis.b_mbrd )
2127             x264_intra_rd( h, &analysis, COST_MAX );
2128
2129         i_cost = analysis.i_satd_i16x16;
2130         h->mb.i_type = I_16x16;
2131         COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, h->mb.i_type, I_4x4 );
2132         COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, h->mb.i_type, I_8x8 );
2133         if( analysis.i_satd_pcm < i_cost )
2134             h->mb.i_type = I_PCM;
2135
2136         else if( h->mb.i_subpel_refine >= 7 )
2137             x264_intra_rd_refine( h, &analysis );
2138     }
2139     else if( h->sh.i_type == SLICE_TYPE_P )
2140     {
2141         int b_skip = 0;
2142         int i_intra_cost, i_intra_type;
2143
2144         h->mc.prefetch_ref( h->mb.pic.p_fref[0][0][h->mb.i_mb_x&3], h->mb.pic.i_stride[0], 0 );
2145
2146         /* Fast P_SKIP detection */
2147         analysis.b_try_pskip = 0;
2148         if( h->param.analyse.b_fast_pskip )
2149         {
2150             if( h->param.i_threads > 1 && h->mb.cache.pskip_mv[1] > h->mb.mv_max_spel[1] )
2151                 // FIXME don't need to check this if the reference frame is done
2152                 {}
2153             else if( h->param.analyse.i_subpel_refine >= 3 )
2154                 analysis.b_try_pskip = 1;
2155             else if( h->mb.i_mb_type_left == P_SKIP ||
2156                      h->mb.i_mb_type_top == P_SKIP ||
2157                      h->mb.i_mb_type_topleft == P_SKIP ||
2158                      h->mb.i_mb_type_topright == P_SKIP )
2159                 b_skip = x264_macroblock_probe_pskip( h );
2160         }
2161
2162         h->mc.prefetch_ref( h->mb.pic.p_fref[0][0][h->mb.i_mb_x&3], h->mb.pic.i_stride[0], 1 );
2163
2164         if( b_skip )
2165         {
2166             h->mb.i_type = P_SKIP;
2167             h->mb.i_partition = D_16x16;
2168             assert( h->mb.cache.pskip_mv[1] <= h->mb.mv_max_spel[1] || h->param.i_threads == 1 );
2169         }
2170         else
2171         {
2172             const unsigned int flags = h->param.analyse.inter;
2173             int i_type;
2174             int i_partition;
2175             int i_thresh16x8;
2176             int i_satd_inter, i_satd_intra;
2177
2178             x264_mb_analyse_load_costs( h, &analysis );
2179
2180             x264_mb_analyse_inter_p16x16( h, &analysis );
2181
2182             if( h->mb.i_type == P_SKIP )
2183                 return;
2184
2185             if( flags & X264_ANALYSE_PSUB16x16 )
2186             {
2187                 if( h->param.analyse.b_mixed_references )
2188                     x264_mb_analyse_inter_p8x8_mixed_ref( h, &analysis );
2189                 else
2190                     x264_mb_analyse_inter_p8x8( h, &analysis );
2191             }
2192
2193             /* Select best inter mode */
2194             i_type = P_L0;
2195             i_partition = D_16x16;
2196             i_cost = analysis.l0.me16x16.cost;
2197
2198             if( ( flags & X264_ANALYSE_PSUB16x16 ) &&
2199                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost )
2200             {
2201                 i_type = P_8x8;
2202                 i_partition = D_8x8;
2203                 i_cost = analysis.l0.i_cost8x8;
2204
2205                 /* Do sub 8x8 */
2206                 if( flags & X264_ANALYSE_PSUB8x8 )
2207                 {
2208                     for( i = 0; i < 4; i++ )
2209                     {
2210                         x264_mb_analyse_inter_p4x4( h, &analysis, i );
2211                         if( analysis.l0.i_cost4x4[i] < analysis.l0.me8x8[i].cost )
2212                         {
2213                             int i_cost8x8 = analysis.l0.i_cost4x4[i];
2214                             h->mb.i_sub_partition[i] = D_L0_4x4;
2215
2216                             x264_mb_analyse_inter_p8x4( h, &analysis, i );
2217                             COPY2_IF_LT( i_cost8x8, analysis.l0.i_cost8x4[i],
2218                                          h->mb.i_sub_partition[i], D_L0_8x4 );
2219
2220                             x264_mb_analyse_inter_p4x8( h, &analysis, i );
2221                             COPY2_IF_LT( i_cost8x8, analysis.l0.i_cost4x8[i],
2222                                          h->mb.i_sub_partition[i], D_L0_4x8 );
2223
2224                             i_cost += i_cost8x8 - analysis.l0.me8x8[i].cost;
2225                         }
2226                         x264_mb_cache_mv_p8x8( h, &analysis, i );
2227                     }
2228                     analysis.l0.i_cost8x8 = i_cost;
2229                 }
2230             }
2231
2232             /* Now do 16x8/8x16 */
2233             i_thresh16x8 = analysis.l0.me8x8[1].cost_mv + analysis.l0.me8x8[2].cost_mv;
2234             if( ( flags & X264_ANALYSE_PSUB16x16 ) &&
2235                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost + i_thresh16x8 )
2236             {
2237                 x264_mb_analyse_inter_p16x8( h, &analysis );
2238                 COPY3_IF_LT( i_cost, analysis.l0.i_cost16x8, i_type, P_L0, i_partition, D_16x8 );
2239
2240                 x264_mb_analyse_inter_p8x16( h, &analysis );
2241                 COPY3_IF_LT( i_cost, analysis.l0.i_cost8x16, i_type, P_L0, i_partition, D_8x16 );
2242             }
2243
2244             h->mb.i_partition = i_partition;
2245
2246             /* refine qpel */
2247             //FIXME mb_type costs?
2248             if( analysis.b_mbrd )
2249             {
2250                 /* refine later */
2251             }
2252             else if( i_partition == D_16x16 )
2253             {
2254                 x264_me_refine_qpel( h, &analysis.l0.me16x16 );
2255                 i_cost = analysis.l0.me16x16.cost;
2256             }
2257             else if( i_partition == D_16x8 )
2258             {
2259                 x264_me_refine_qpel( h, &analysis.l0.me16x8[0] );
2260                 x264_me_refine_qpel( h, &analysis.l0.me16x8[1] );
2261                 i_cost = analysis.l0.me16x8[0].cost + analysis.l0.me16x8[1].cost;
2262             }
2263             else if( i_partition == D_8x16 )
2264             {
2265                 x264_me_refine_qpel( h, &analysis.l0.me8x16[0] );
2266                 x264_me_refine_qpel( h, &analysis.l0.me8x16[1] );
2267                 i_cost = analysis.l0.me8x16[0].cost + analysis.l0.me8x16[1].cost;
2268             }
2269             else if( i_partition == D_8x8 )
2270             {
2271                 int i8x8;
2272                 i_cost = 0;
2273                 for( i8x8 = 0; i8x8 < 4; i8x8++ )
2274                 {
2275                     switch( h->mb.i_sub_partition[i8x8] )
2276                     {
2277                         case D_L0_8x8:
2278                             x264_me_refine_qpel( h, &analysis.l0.me8x8[i8x8] );
2279                             i_cost += analysis.l0.me8x8[i8x8].cost;
2280                             break;
2281                         case D_L0_8x4:
2282                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][0] );
2283                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][1] );
2284                             i_cost += analysis.l0.me8x4[i8x8][0].cost +
2285                                       analysis.l0.me8x4[i8x8][1].cost;
2286                             break;
2287                         case D_L0_4x8:
2288                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][0] );
2289                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][1] );
2290                             i_cost += analysis.l0.me4x8[i8x8][0].cost +
2291                                       analysis.l0.me4x8[i8x8][1].cost;
2292                             break;
2293
2294                         case D_L0_4x4:
2295                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][0] );
2296                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][1] );
2297                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][2] );
2298                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][3] );
2299                             i_cost += analysis.l0.me4x4[i8x8][0].cost +
2300                                       analysis.l0.me4x4[i8x8][1].cost +
2301                                       analysis.l0.me4x4[i8x8][2].cost +
2302                                       analysis.l0.me4x4[i8x8][3].cost;
2303                             break;
2304                         default:
2305                             x264_log( h, X264_LOG_ERROR, "internal error (!8x8 && !4x4)\n" );
2306                             break;
2307                     }
2308                 }
2309             }
2310
2311             if( h->mb.b_chroma_me )
2312             {
2313                 x264_mb_analyse_intra_chroma( h, &analysis );
2314                 x264_mb_analyse_intra( h, &analysis, i_cost - analysis.i_satd_i8x8chroma );
2315                 analysis.i_satd_i16x16 += analysis.i_satd_i8x8chroma;
2316                 analysis.i_satd_i8x8 += analysis.i_satd_i8x8chroma;
2317                 analysis.i_satd_i4x4 += analysis.i_satd_i8x8chroma;
2318             }
2319             else
2320                 x264_mb_analyse_intra( h, &analysis, i_cost );
2321
2322             i_satd_inter = i_cost;
2323             i_satd_intra = X264_MIN3( analysis.i_satd_i16x16,
2324                                       analysis.i_satd_i8x8,
2325                                       analysis.i_satd_i4x4 );
2326
2327             if( analysis.b_mbrd )
2328             {
2329                 x264_mb_analyse_p_rd( h, &analysis, X264_MIN(i_satd_inter, i_satd_intra) );
2330                 i_type = P_L0;
2331                 i_partition = D_16x16;
2332                 i_cost = analysis.l0.me16x16.cost;
2333                 COPY2_IF_LT( i_cost, analysis.l0.i_cost16x8, i_partition, D_16x8 );
2334                 COPY2_IF_LT( i_cost, analysis.l0.i_cost8x16, i_partition, D_8x16 );
2335                 COPY3_IF_LT( i_cost, analysis.l0.i_cost8x8, i_partition, D_8x8, i_type, P_8x8 );
2336                 h->mb.i_type = i_type;
2337                 h->mb.i_partition = i_partition;
2338                 if( i_cost < COST_MAX )
2339                     x264_mb_analyse_transform_rd( h, &analysis, &i_satd_inter, &i_cost );
2340                 x264_intra_rd( h, &analysis, i_satd_inter * 5/4 );
2341             }
2342
2343             i_intra_type = I_16x16;
2344             i_intra_cost = analysis.i_satd_i16x16;
2345             COPY2_IF_LT( i_intra_cost, analysis.i_satd_i8x8, i_intra_type, I_8x8 );
2346             COPY2_IF_LT( i_intra_cost, analysis.i_satd_i4x4, i_intra_type, I_4x4 );
2347             COPY2_IF_LT( i_intra_cost, analysis.i_satd_pcm, i_intra_type, I_PCM );
2348             COPY2_IF_LT( i_cost, i_intra_cost, i_type, i_intra_type );
2349
2350             if( i_intra_cost == COST_MAX )
2351                 i_intra_cost = i_cost * i_satd_intra / i_satd_inter + 1;
2352
2353             h->mb.i_type = i_type;
2354             h->stat.frame.i_intra_cost += i_intra_cost;
2355             h->stat.frame.i_inter_cost += i_cost;
2356             h->stat.frame.i_mbs_analysed++;
2357
2358             if( h->mb.i_subpel_refine >= 7 && h->mb.i_type != I_PCM )
2359             {
2360                 if( IS_INTRA( h->mb.i_type ) )
2361                 {
2362                     x264_intra_rd_refine( h, &analysis );
2363                 }
2364                 else if( i_partition == D_16x16 )
2365                 {
2366                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.i_ref );
2367                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x16, analysis.i_lambda2, 0 );
2368                 }
2369                 else if( i_partition == D_16x8 )
2370                 {
2371                     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
2372                     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
2373                     x264_macroblock_cache_ref( h, 0, 0, 4, 2, 0, analysis.l0.me16x8[0].i_ref );
2374                     x264_macroblock_cache_ref( h, 0, 2, 4, 2, 0, analysis.l0.me16x8[1].i_ref );
2375                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[0], analysis.i_lambda2, 0 );
2376                     x264_me_refine_qpel_rd( h, &analysis.l0.me16x8[1], analysis.i_lambda2, 2 );
2377                 }
2378                 else if( i_partition == D_8x16 )
2379                 {
2380                     h->mb.i_sub_partition[0] = h->mb.i_sub_partition[1] =
2381                     h->mb.i_sub_partition[2] = h->mb.i_sub_partition[3] = D_L0_8x8;
2382                     x264_macroblock_cache_ref( h, 0, 0, 2, 4, 0, analysis.l0.me8x16[0].i_ref );
2383                     x264_macroblock_cache_ref( h, 2, 0, 2, 4, 0, analysis.l0.me8x16[1].i_ref );
2384                     x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[0], analysis.i_lambda2, 0 );
2385                     x264_me_refine_qpel_rd( h, &analysis.l0.me8x16[1], analysis.i_lambda2, 1 );
2386                 }
2387                 else if( i_partition == D_8x8 )
2388                 {
2389                     int i8x8;
2390                     x264_analyse_update_cache( h, &analysis );
2391                     for( i8x8 = 0; i8x8 < 4; i8x8++ )
2392                          if( h->mb.i_sub_partition[i8x8] == D_L0_8x8 )
2393                              x264_me_refine_qpel_rd( h, &analysis.l0.me8x8[i8x8], analysis.i_lambda2, i8x8 );
2394                 }
2395             }
2396         }
2397     }
2398     else if( h->sh.i_type == SLICE_TYPE_B )
2399     {
2400         int i_bskip_cost = COST_MAX;
2401         int b_skip = 0;
2402
2403         if( analysis.b_mbrd )
2404             x264_mb_cache_fenc_satd( h );
2405
2406         h->mb.i_type = B_SKIP;
2407         if( h->mb.b_direct_auto_write )
2408         {
2409             /* direct=auto heuristic: prefer whichever mode allows more Skip macroblocks */
2410             for( i = 0; i < 2; i++ )
2411             {
2412                 int b_changed = 1;
2413                 h->sh.b_direct_spatial_mv_pred ^= 1;
2414                 analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h, i && analysis.b_direct_available ? &b_changed : NULL );
2415                 if( analysis.b_direct_available )
2416                 {
2417                     if( b_changed )
2418                     {
2419                         x264_mb_mc( h );
2420                         b_skip = x264_macroblock_probe_bskip( h );
2421                     }
2422                     h->stat.frame.i_direct_score[ h->sh.b_direct_spatial_mv_pred ] += b_skip;
2423                 }
2424                 else
2425                     b_skip = 0;
2426             }
2427         }
2428         else
2429             analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h, NULL );
2430
2431         if( analysis.b_direct_available )
2432         {
2433             if( !h->mb.b_direct_auto_write )
2434                 x264_mb_mc( h );
2435             if( h->mb.b_lossless )
2436             {
2437                 /* chance of skip is too small to bother */
2438             }
2439             else if( analysis.b_mbrd )
2440             {
2441                 i_bskip_cost = ssd_mb( h );
2442                 /* 6 = minimum cavlc cost of a non-skipped MB */
2443                 b_skip = h->mb.b_skip_mc = i_bskip_cost <= ((6 * analysis.i_lambda2 + 128) >> 8);
2444             }
2445             else if( !h->mb.b_direct_auto_write )
2446             {
2447                 /* Conditioning the probe on neighboring block types
2448                  * doesn't seem to help speed or quality. */
2449                 b_skip = x264_macroblock_probe_bskip( h );
2450             }
2451         }
2452
2453         if( !b_skip )
2454         {
2455             const unsigned int flags = h->param.analyse.inter;
2456             int i_type;
2457             int i_partition;
2458             int i_satd_inter = 0; // shut up uninitialized warning
2459             h->mb.b_skip_mc = 0;
2460
2461             x264_mb_analyse_load_costs( h, &analysis );
2462
2463             /* select best inter mode */
2464             /* direct must be first */
2465             if( analysis.b_direct_available )
2466                 x264_mb_analyse_inter_direct( h, &analysis );
2467
2468             x264_mb_analyse_inter_b16x16( h, &analysis );
2469
2470             i_type = B_L0_L0;
2471             i_partition = D_16x16;
2472             i_cost = analysis.l0.me16x16.cost;
2473             COPY2_IF_LT( i_cost, analysis.l1.me16x16.cost, i_type, B_L1_L1 );
2474             COPY2_IF_LT( i_cost, analysis.i_cost16x16bi, i_type, B_BI_BI );
2475             COPY2_IF_LT( i_cost, analysis.i_cost16x16direct, i_type, B_DIRECT );
2476
2477             if( analysis.b_mbrd && analysis.i_cost16x16direct <= i_cost * 33/32 )
2478             {
2479                 x264_mb_analyse_b_rd( h, &analysis, i_cost );
2480                 if( i_bskip_cost < analysis.i_rd16x16direct &&
2481                     i_bskip_cost < analysis.i_rd16x16bi &&
2482                     i_bskip_cost < analysis.l0.i_rd16x16 &&
2483                     i_bskip_cost < analysis.l1.i_rd16x16 )
2484                 {
2485                     h->mb.i_type = B_SKIP;
2486                     x264_analyse_update_cache( h, &analysis );
2487                     return;
2488                 }
2489             }
2490
2491             if( flags & X264_ANALYSE_BSUB16x16 )
2492             {
2493                 x264_mb_analyse_inter_b8x8( h, &analysis );
2494                 if( analysis.i_cost8x8bi < i_cost )
2495                 {
2496                     i_type = B_8x8;
2497                     i_partition = D_8x8;
2498                     i_cost = analysis.i_cost8x8bi;
2499
2500                     if( h->mb.i_sub_partition[0] == h->mb.i_sub_partition[1] ||
2501                         h->mb.i_sub_partition[2] == h->mb.i_sub_partition[3] )
2502                     {
2503                         x264_mb_analyse_inter_b16x8( h, &analysis );
2504                         COPY3_IF_LT( i_cost, analysis.i_cost16x8bi,
2505                                      i_type, analysis.i_mb_type16x8,
2506                                      i_partition, D_16x8 );
2507                     }
2508                     if( h->mb.i_sub_partition[0] == h->mb.i_sub_partition[2] ||
2509                         h->mb.i_sub_partition[1] == h->mb.i_sub_partition[3] )
2510                     {
2511                         x264_mb_analyse_inter_b8x16( h, &analysis );
2512                         COPY3_IF_LT( i_cost, analysis.i_cost8x16bi,
2513                                      i_type, analysis.i_mb_type8x16,
2514                                      i_partition, D_8x16 );
2515                     }
2516                 }
2517             }
2518
2519             if( analysis.b_mbrd )
2520             {
2521                 /* refine later */
2522             }
2523             /* refine qpel */
2524             else if( i_partition == D_16x16 )
2525             {
2526                 analysis.l0.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
2527                 analysis.l1.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
2528                 if( i_type == B_L0_L0 )
2529                 {
2530                     x264_me_refine_qpel( h, &analysis.l0.me16x16 );
2531                     i_cost = analysis.l0.me16x16.cost
2532                            + analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
2533                 }
2534                 else if( i_type == B_L1_L1 )
2535                 {
2536                     x264_me_refine_qpel( h, &analysis.l1.me16x16 );
2537                     i_cost = analysis.l1.me16x16.cost
2538                            + analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
2539                 }
2540                 else if( i_type == B_BI_BI )
2541                 {
2542                     x264_me_refine_qpel( h, &analysis.l0.me16x16 );
2543                     x264_me_refine_qpel( h, &analysis.l1.me16x16 );
2544                 }
2545             }
2546             else if( i_partition == D_16x8 )
2547             {
2548                 for( i=0; i<2; i++ )
2549                 {
2550                     if( analysis.i_mb_partition16x8[i] != D_L1_8x8 )
2551                         x264_me_refine_qpel( h, &analysis.l0.me16x8[i] );
2552                     if( analysis.i_mb_partition16x8[i] != D_L0_8x8 )
2553                         x264_me_refine_qpel( h, &analysis.l1.me16x8[i] );
2554                 }
2555             }
2556             else if( i_partition == D_8x16 )
2557             {
2558                 for( i=0; i<2; i++ )
2559                 {
2560                     if( analysis.i_mb_partition8x16[i] != D_L1_8x8 )
2561                         x264_me_refine_qpel( h, &analysis.l0.me8x16[i] );
2562                     if( analysis.i_mb_partition8x16[i] != D_L0_8x8 )
2563                         x264_me_refine_qpel( h, &analysis.l1.me8x16[i] );
2564                 }
2565             }
2566             else if( i_partition == D_8x8 )
2567             {
2568                 for( i=0; i<4; i++ )
2569                 {
2570                     x264_me_t *m;
2571                     int i_part_cost_old;
2572                     int i_type_cost;
2573                     int i_part_type = h->mb.i_sub_partition[i];
2574                     int b_bidir = (i_part_type == D_BI_8x8);
2575
2576                     if( i_part_type == D_DIRECT_8x8 )
2577                         continue;
2578                     if( x264_mb_partition_listX_table[0][i_part_type] )
2579                     {
2580                         m = &analysis.l0.me8x8[i];
2581                         i_part_cost_old = m->cost;
2582                         i_type_cost = analysis.i_lambda * i_sub_mb_b_cost_table[D_L0_8x8];
2583                         m->cost -= i_type_cost;
2584                         x264_me_refine_qpel( h, m );
2585                         if( !b_bidir )
2586                             analysis.i_cost8x8bi += m->cost + i_type_cost - i_part_cost_old;
2587                     }
2588                     if( x264_mb_partition_listX_table[1][i_part_type] )
2589                     {
2590                         m = &analysis.l1.me8x8[i];
2591                         i_part_cost_old = m->cost;
2592                         i_type_cost = analysis.i_lambda * i_sub_mb_b_cost_table[D_L1_8x8];
2593                         m->cost -= i_type_cost;
2594                         x264_me_refine_qpel( h, m );
2595                         if( !b_bidir )
2596                             analysis.i_cost8x8bi += m->cost + i_type_cost - i_part_cost_old;
2597                     }
2598                     /* TODO: update mvp? */
2599                 }
2600             }
2601
2602             if( analysis.b_mbrd )
2603             {
2604                 i_satd_inter = i_cost;
2605                 x264_mb_analyse_b_rd( h, &analysis, i_satd_inter );
2606                 i_type = B_SKIP;
2607                 i_cost = i_bskip_cost;
2608                 i_partition = D_16x16;
2609                 COPY2_IF_LT( i_cost, analysis.l0.i_rd16x16, i_type, B_L0_L0 );
2610                 COPY2_IF_LT( i_cost, analysis.l1.i_rd16x16, i_type, B_L1_L1 );
2611                 COPY2_IF_LT( i_cost, analysis.i_rd16x16bi, i_type, B_BI_BI );
2612                 COPY2_IF_LT( i_cost, analysis.i_rd16x16direct, i_type, B_DIRECT );
2613                 COPY3_IF_LT( i_cost, analysis.i_rd16x8bi, i_type, analysis.i_mb_type16x8, i_partition, D_16x8 );
2614                 COPY3_IF_LT( i_cost, analysis.i_rd8x16bi, i_type, analysis.i_mb_type8x16, i_partition, D_8x16 );
2615                 COPY3_IF_LT( i_cost, analysis.i_rd8x8bi, i_type, B_8x8, i_partition, D_8x8 );
2616
2617                 h->mb.i_type = i_type;
2618                 h->mb.i_partition = i_partition;
2619             }
2620
2621             x264_mb_analyse_intra( h, &analysis, i_satd_inter );
2622
2623             if( analysis.b_mbrd )
2624             {
2625                 x264_mb_analyse_transform_rd( h, &analysis, &i_satd_inter, &i_cost );
2626                 x264_intra_rd( h, &analysis, i_satd_inter * 17/16 );
2627             }
2628
2629             COPY2_IF_LT( i_cost, analysis.i_satd_i16x16, i_type, I_16x16 );
2630             COPY2_IF_LT( i_cost, analysis.i_satd_i8x8, i_type, I_8x8 );
2631             COPY2_IF_LT( i_cost, analysis.i_satd_i4x4, i_type, I_4x4 );
2632             COPY2_IF_LT( i_cost, analysis.i_satd_pcm, i_type, I_PCM );
2633
2634             h->mb.i_type = i_type;
2635             h->mb.i_partition = i_partition;
2636
2637             if( analysis.b_mbrd && h->mb.i_subpel_refine >= 7 && IS_INTRA( i_type ) && i_type != I_PCM )
2638                 x264_intra_rd_refine( h, &analysis );
2639             else if( h->param.analyse.b_bidir_me )
2640                 refine_bidir( h, &analysis );
2641         }
2642     }
2643
2644     x264_analyse_update_cache( h, &analysis );
2645
2646     if( !analysis.b_mbrd )
2647         x264_mb_analyse_transform( h );
2648
2649     h->mb.b_trellis = h->param.analyse.i_trellis;
2650     h->mb.b_noise_reduction = !!h->param.analyse.i_noise_reduction;
2651     if( !IS_SKIP(h->mb.i_type) && h->mb.i_psy_trellis && h->param.analyse.i_trellis == 1 )
2652         x264_psy_trellis_init( h, 0 );
2653     if( h->mb.b_trellis == 1 || h->mb.b_noise_reduction )
2654         h->mb.i_skip_intra = 0;
2655 }
2656
2657 /*-------------------- Update MB from the analysis ----------------------*/
2658 static void x264_analyse_update_cache( x264_t *h, x264_mb_analysis_t *a  )
2659 {
2660     int i;
2661
2662     switch( h->mb.i_type )
2663     {
2664         case I_4x4:
2665             for( i = 0; i < 16; i++ )
2666                 h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] = a->i_predict4x4[i];
2667
2668             x264_mb_analyse_intra_chroma( h, a );
2669             break;
2670         case I_8x8:
2671             for( i = 0; i < 4; i++ )
2672                 x264_macroblock_cache_intra8x8_pred( h, 2*(i&1), 2*(i>>1), a->i_predict8x8[i] );
2673
2674             x264_mb_analyse_intra_chroma( h, a );
2675             break;
2676         case I_16x16:
2677             h->mb.i_intra16x16_pred_mode = a->i_predict16x16;
2678             x264_mb_analyse_intra_chroma( h, a );
2679             break;
2680
2681         case I_PCM:
2682             break;
2683
2684         case P_L0:
2685             switch( h->mb.i_partition )
2686             {
2687                 case D_16x16:
2688                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.me16x16.i_ref );
2689                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
2690                     break;
2691
2692                 case D_16x8:
2693                     x264_macroblock_cache_ref( h, 0, 0, 4, 2, 0, a->l0.me16x8[0].i_ref );
2694                     x264_macroblock_cache_ref( h, 0, 2, 4, 2, 0, a->l0.me16x8[1].i_ref );
2695                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 2, 0, a->l0.me16x8[0].mv );
2696                     x264_macroblock_cache_mv_ptr( h, 0, 2, 4, 2, 0, a->l0.me16x8[1].mv );
2697                     break;
2698
2699                 case D_8x16:
2700                     x264_macroblock_cache_ref( h, 0, 0, 2, 4, 0, a->l0.me8x16[0].i_ref );
2701                     x264_macroblock_cache_ref( h, 2, 0, 2, 4, 0, a->l0.me8x16[1].i_ref );
2702                     x264_macroblock_cache_mv_ptr( h, 0, 0, 2, 4, 0, a->l0.me8x16[0].mv );
2703                     x264_macroblock_cache_mv_ptr( h, 2, 0, 2, 4, 0, a->l0.me8x16[1].mv );
2704                     break;
2705
2706                 default:
2707                     x264_log( h, X264_LOG_ERROR, "internal error P_L0 and partition=%d\n", h->mb.i_partition );
2708                     break;
2709             }
2710             break;
2711
2712         case P_8x8:
2713             x264_macroblock_cache_ref( h, 0, 0, 2, 2, 0, a->l0.me8x8[0].i_ref );
2714             x264_macroblock_cache_ref( h, 2, 0, 2, 2, 0, a->l0.me8x8[1].i_ref );
2715             x264_macroblock_cache_ref( h, 0, 2, 2, 2, 0, a->l0.me8x8[2].i_ref );
2716             x264_macroblock_cache_ref( h, 2, 2, 2, 2, 0, a->l0.me8x8[3].i_ref );
2717             for( i = 0; i < 4; i++ )
2718                 x264_mb_cache_mv_p8x8( h, a, i );
2719             break;
2720
2721         case P_SKIP:
2722         {
2723             h->mb.i_partition = D_16x16;
2724             x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, 0 );
2725             x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, h->mb.cache.pskip_mv );
2726             break;
2727         }
2728
2729         case B_SKIP:
2730         case B_DIRECT:
2731             x264_mb_load_mv_direct8x8( h, 0 );
2732             x264_mb_load_mv_direct8x8( h, 1 );
2733             x264_mb_load_mv_direct8x8( h, 2 );
2734             x264_mb_load_mv_direct8x8( h, 3 );
2735             break;
2736
2737         case B_8x8:
2738             /* optimize: cache might not need to be rewritten */
2739             for( i = 0; i < 4; i++ )
2740                 x264_mb_cache_mv_b8x8( h, a, i, 1 );
2741             break;
2742
2743         default: /* the rest of the B types */
2744             switch( h->mb.i_partition )
2745             {
2746             case D_16x16:
2747                 switch( h->mb.i_type )
2748                 {
2749                 case B_L0_L0:
2750                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
2751                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
2752
2753                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, -1 );
2754                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 1, 0 );
2755                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 1, 0 );
2756                     break;
2757                 case B_L1_L1:
2758                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, -1 );
2759                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, 0 );
2760                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 0, 0 );
2761
2762                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.i_ref );
2763                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 1, a->l1.me16x16.mv );
2764                     break;
2765                 case B_BI_BI:
2766                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
2767                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 0, a->l0.me16x16.mv );
2768
2769                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.i_ref );
2770                     x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, 1, a->l1.me16x16.mv );
2771                     break;
2772                 }
2773                 break;
2774             case D_16x8:
2775                 x264_mb_cache_mv_b16x8( h, a, 0, 1 );
2776                 x264_mb_cache_mv_b16x8( h, a, 1, 1 );
2777                 break;
2778             case D_8x16:
2779                 x264_mb_cache_mv_b8x16( h, a, 0, 1 );
2780                 x264_mb_cache_mv_b8x16( h, a, 1, 1 );
2781                 break;
2782             default:
2783                 x264_log( h, X264_LOG_ERROR, "internal error (invalid MB type)\n" );
2784                 break;
2785             }
2786     }
2787
2788 #ifndef NDEBUG
2789     if( h->param.i_threads > 1 && !IS_INTRA(h->mb.i_type) )
2790     {
2791         int l;
2792         for( l=0; l <= (h->sh.i_type == SLICE_TYPE_B); l++ )
2793         {
2794             int completed;
2795             int ref = h->mb.cache.ref[l][x264_scan8[0]];
2796             if( ref < 0 )
2797                 continue;
2798             completed = (l ? h->fref1 : h->fref0)[ ref >> h->mb.b_interlaced ]->i_lines_completed;
2799             if( (h->mb.cache.mv[l][x264_scan8[15]][1] >> (2 - h->mb.b_interlaced)) + h->mb.i_mb_y*16 > completed )
2800             {
2801                 x264_log( h, X264_LOG_WARNING, "internal error (MV out of thread range)\n");
2802                 fprintf(stderr, "mb type: %d \n", h->mb.i_type);
2803                 fprintf(stderr, "mv: l%dr%d (%d,%d) \n", l, ref,
2804                                 h->mb.cache.mv[l][x264_scan8[15]][0],
2805                                 h->mb.cache.mv[l][x264_scan8[15]][1] );
2806                 fprintf(stderr, "limit: %d \n", h->mb.mv_max_spel[1]);
2807                 fprintf(stderr, "mb_xy: %d,%d \n", h->mb.i_mb_x, h->mb.i_mb_y);
2808                 fprintf(stderr, "completed: %d \n", completed );
2809                 x264_log( h, X264_LOG_WARNING, "recovering by using intra mode\n");
2810                 x264_mb_analyse_intra( h, a, COST_MAX );
2811                 h->mb.i_type = I_16x16;
2812                 h->mb.i_intra16x16_pred_mode = a->i_predict16x16;
2813                 x264_mb_analyse_intra_chroma( h, a );
2814             }
2815         }
2816     }
2817 #endif
2818 }
2819
2820 #include "slicetype.c"
2821