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