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