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