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