Changes the mechanics of max keyframe interval:
[x262.git] / encoder / analyse.c
1 /*****************************************************************************
2  * analyse.c: h264 encoder library
3  *****************************************************************************
4  * Copyright (C) 2003 Laurent Aimar
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  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <math.h>
28 #include <limits.h>
29
30 #include "common/common.h"
31 #include "common/macroblock.h"
32 #include "macroblock.h"
33 #include "me.h"
34 #include "ratecontrol.h"
35
36 typedef struct
37 {
38     /* 16x16 */
39     int i_ref;
40     x264_me_t me16x16;
41
42     /* 8x8 */
43     int       i_cost8x8;
44     x264_me_t me8x8[4];
45
46     /* Sub 4x4 */
47     int       i_cost4x4[4]; /* cost per 8x8 partition */
48     x264_me_t me4x4[4][4];
49
50     /* Sub 8x4 */
51     int       i_cost8x4[4]; /* cost per 8x8 partition */
52     x264_me_t me8x4[4][2];
53
54     /* Sub 4x8 */
55     int       i_cost4x8[4]; /* cost per 8x8 partition */
56     x264_me_t me4x8[4][4];
57
58     /* 16x8 */
59     int       i_cost16x8;
60     x264_me_t me16x8[2];
61
62     /* 8x16 */
63     int       i_cost8x16;
64     x264_me_t me8x16[2];
65
66 } x264_mb_analysis_list_t;
67
68 typedef struct
69 {
70     /* conduct the analysis using this lamda and QP */
71     int i_lambda;
72     int i_qp;
73
74
75     /* I: Intra part */
76     /* Luma part 16x16 and 4x4 modes stats */
77     int i_sad_i16x16;
78     int i_predict16x16;
79
80     int i_sad_i4x4;
81     int i_predict4x4[4][4];
82
83     /* Chroma part */
84     int i_sad_i8x8;
85     int i_predict8x8;
86
87     /* II: Inter part P/B frame */
88     int i_mv_range;
89
90     x264_mb_analysis_list_t l0;
91     x264_mb_analysis_list_t l1;
92
93     int i_cost16x16bi; /* used the same ref and mv as l0 and l1 (at least for now) */
94     int i_cost16x16direct;
95     int i_cost8x8bi;
96     int i_cost8x8direct[4];
97     int i_cost16x8bi;
98     int i_cost8x16bi;
99
100     int i_mb_partition16x8[2]; /* mb_partition_e */
101     int i_mb_partition8x16[2];
102     int i_mb_type16x8; /* mb_class_e */
103     int i_mb_type8x16;
104
105     int b_direct_available;
106
107 } x264_mb_analysis_t;
108
109 static const int i_qp0_cost_table[52] = {
110    1, 1, 1, 1, 1, 1, 1, 1,  /*  0-7 */
111    1, 1, 1, 1,              /*  8-11 */
112    1, 1, 1, 1, 2, 2, 2, 2,  /* 12-19 */
113    3, 3, 3, 4, 4, 4, 5, 6,  /* 20-27 */
114    6, 7, 8, 9,10,11,13,14,  /* 28-35 */
115   16,18,20,23,25,29,32,36,  /* 36-43 */
116   40,45,51,57,64,72,81,91   /* 44-51 */
117 };
118
119 static const uint8_t block_idx_x[16] = {
120     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
121 };
122 static const uint8_t block_idx_y[16] = {
123     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
124 };
125
126 /* TODO: calculate CABAC costs */
127 static const int i_mb_b_cost_table[18] = {
128     9, 9, 9, 0, 0, 0, 1, 3, 7, 7, 7, 3, 7, 7, 7, 5, 9, 0
129 };
130 static const int i_mb_b16x8_cost_table[16] = {
131     0, 0, 0, 0, 0, 0, 0, 5, 7, 7, 7, 5, 7, 9, 9, 9
132 };
133 static const int i_sub_mb_b_cost_table[13] = {
134     7, 5, 5, 3, 7, 5, 7, 3, 7, 7, 7, 5, 1
135 };
136 static const int i_sub_mb_p_cost_table[4] = {
137     5, 3, 3, 1
138 };
139
140 static void x264_mb_analyse_init( x264_t *h, x264_mb_analysis_t *a, int i_qp )
141 {
142     memset( a, 0, sizeof( x264_mb_analysis_t ) );
143
144     /* conduct the analysis using this lamda and QP */
145     a->i_qp = i_qp;
146     a->i_lambda = i_qp0_cost_table[i_qp];
147
148     /* I: Intra part */
149     a->i_sad_i16x16 = -1;
150     a->i_sad_i4x4   = -1;
151     a->i_sad_i8x8   = -1;
152
153     /* II: Inter part P/B frame */
154     if( h->sh.i_type != SLICE_TYPE_I )
155     {
156         int dmb;
157         int i;
158
159         /* Calculate max start MV range */
160         dmb = h->mb.i_mb_x;
161         if( h->mb.i_mb_y < dmb )
162             dmb = h->mb.i_mb_y;
163         if( h->sps->i_mb_width - h->mb.i_mb_x < dmb )
164             dmb = h->sps->i_mb_width - h->mb.i_mb_x;
165         if( h->sps->i_mb_height - h->mb.i_mb_y < dmb )
166             dmb = h->sps->i_mb_height - h->mb.i_mb_y;
167
168         a->i_mv_range = 16*dmb + 8;
169
170         a->l0.me16x16.cost = -1;
171         a->l0.i_cost8x8    = -1;
172
173         for( i = 0; i < 4; i++ )
174         {
175             a->l0.i_cost4x4[i] = -1;
176             a->l0.i_cost8x4[i] = -1;
177             a->l0.i_cost4x8[i] = -1;
178         }
179
180         a->l0.i_cost16x8   = -1;
181         a->l0.i_cost8x16   = -1;
182         if( h->sh.i_type == SLICE_TYPE_B )
183         {
184             a->l1.me16x16.cost = -1;
185             a->l1.i_cost8x8    = -1;
186
187             for( i = 0; i < 4; i++ )
188             {
189                 a->l1.i_cost4x4[i] = -1;
190                 a->l1.i_cost8x4[i] = -1;
191                 a->l1.i_cost4x8[i] = -1;
192                 a->i_cost8x8direct[i] = -1;
193             }
194
195             a->l1.i_cost16x8   = -1;
196             a->l1.i_cost8x16   = -1;
197
198             a->i_cost16x16bi   = -1;
199             a->i_cost16x16direct = -1;
200             a->i_cost8x8bi     = -1;
201             a->i_cost16x8bi    = -1;
202             a->i_cost8x16bi    = -1;
203         }
204     }
205 }
206
207
208
209 /*
210  * Handle intra mb
211  */
212 /* Max = 4 */
213 static void predict_16x16_mode_available( unsigned int i_neighbour, int *mode, int *pi_count )
214 {
215     if( ( i_neighbour & (MB_LEFT|MB_TOP) ) == (MB_LEFT|MB_TOP) )
216     {
217         /* top and left avaible */
218         *mode++ = I_PRED_16x16_V;
219         *mode++ = I_PRED_16x16_H;
220         *mode++ = I_PRED_16x16_DC;
221         *mode++ = I_PRED_16x16_P;
222         *pi_count = 4;
223     }
224     else if( ( i_neighbour & MB_LEFT ) )
225     {
226         /* left available*/
227         *mode++ = I_PRED_16x16_DC_LEFT;
228         *mode++ = I_PRED_16x16_H;
229         *pi_count = 2;
230     }
231     else if( ( i_neighbour & MB_TOP ) )
232     {
233         /* top available*/
234         *mode++ = I_PRED_16x16_DC_TOP;
235         *mode++ = I_PRED_16x16_V;
236         *pi_count = 2;
237     }
238     else
239     {
240         /* none avaible */
241         *mode = I_PRED_16x16_DC_128;
242         *pi_count = 1;
243     }
244 }
245
246 /* Max = 4 */
247 static void predict_8x8_mode_available( unsigned int i_neighbour, int *mode, int *pi_count )
248 {
249     if( ( i_neighbour & (MB_LEFT|MB_TOP) ) == (MB_LEFT|MB_TOP) )
250     {
251         /* top and left avaible */
252         *mode++ = I_PRED_CHROMA_V;
253         *mode++ = I_PRED_CHROMA_H;
254         *mode++ = I_PRED_CHROMA_DC;
255         *mode++ = I_PRED_CHROMA_P;
256         *pi_count = 4;
257     }
258     else if( ( i_neighbour & MB_LEFT ) )
259     {
260         /* left available*/
261         *mode++ = I_PRED_CHROMA_DC_LEFT;
262         *mode++ = I_PRED_CHROMA_H;
263         *pi_count = 2;
264     }
265     else if( ( i_neighbour & MB_TOP ) )
266     {
267         /* top available*/
268         *mode++ = I_PRED_CHROMA_DC_TOP;
269         *mode++ = I_PRED_CHROMA_V;
270         *pi_count = 2;
271     }
272     else
273     {
274         /* none avaible */
275         *mode = I_PRED_CHROMA_DC_128;
276         *pi_count = 1;
277     }
278 }
279
280 /* MAX = 8 */
281 static void predict_4x4_mode_available( unsigned int i_neighbour, int idx, int *mode, int *pi_count )
282 {
283     int b_a, b_b, b_c;
284     static const unsigned int needmb[16] =
285     {
286         MB_LEFT|MB_TOP, MB_TOP,
287         MB_LEFT,        MB_PRIVATE,
288         MB_TOP,         MB_TOP|MB_TOPRIGHT,
289         0,              MB_PRIVATE,
290         MB_LEFT,        0,
291         MB_LEFT,        MB_PRIVATE,
292         0,              MB_PRIVATE,
293         0,              MB_PRIVATE
294     };
295
296     /* FIXME even when b_c == 0 there is some case where missing pixels
297      * are emulated and thus more mode are available TODO
298      * analysis and encode should be fixed too */
299     b_a = (needmb[idx]&i_neighbour&MB_LEFT) == (needmb[idx]&MB_LEFT);
300     b_b = (needmb[idx]&i_neighbour&MB_TOP) == (needmb[idx]&MB_TOP);
301     b_c = (needmb[idx]&i_neighbour&(MB_TOPRIGHT|MB_PRIVATE)) == (needmb[idx]&(MB_TOPRIGHT|MB_PRIVATE));
302
303     if( b_a && b_b )
304     {
305         *mode++ = I_PRED_4x4_DC;
306         *mode++ = I_PRED_4x4_H;
307         *mode++ = I_PRED_4x4_V;
308         *mode++ = I_PRED_4x4_DDR;
309         *mode++ = I_PRED_4x4_VR;
310         *mode++ = I_PRED_4x4_HD;
311         *mode++ = I_PRED_4x4_HU;
312
313         *pi_count = 7;
314
315         if( b_c )
316         {
317             *mode++ = I_PRED_4x4_DDL;
318             *mode++ = I_PRED_4x4_VL;
319             (*pi_count) += 2;
320         }
321     }
322     else if( b_a && !b_b )
323     {
324         *mode++ = I_PRED_4x4_DC_LEFT;
325         *mode++ = I_PRED_4x4_H;
326         *mode++ = I_PRED_4x4_HU;
327         *pi_count = 3;
328     }
329     else if( !b_a && b_b )
330     {
331         *mode++ = I_PRED_4x4_DC_TOP;
332         *mode++ = I_PRED_4x4_V;
333         *pi_count = 2;
334     }
335     else
336     {
337         *mode++ = I_PRED_4x4_DC_128;
338         *pi_count = 1;
339     }
340 }
341
342 static void x264_mb_analyse_intra( x264_t *h, x264_mb_analysis_t *res )
343 {
344     const unsigned int flags = h->sh.i_type == SLICE_TYPE_I ? h->param.analyse.intra : h->param.analyse.inter;
345     const int i_stride = h->mb.pic.i_stride[0];
346     uint8_t  *p_src = h->mb.pic.p_fenc[0];
347     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
348
349     int i, idx;
350
351     int i_max;
352     int predict_mode[9];
353
354     /*---------------- Try all mode and calculate their score ---------------*/
355
356     /* 16x16 prediction selection */
357     predict_16x16_mode_available( h->mb.i_neighbour, predict_mode, &i_max );
358     for( i = 0; i < i_max; i++ )
359     {
360         int i_sad;
361         int i_mode;
362
363         i_mode = predict_mode[i];
364
365         /* we do the prediction */
366         h->predict_16x16[i_mode]( p_dst, i_stride );
367
368         /* we calculate the diff and get the square sum of the diff */
369         i_sad = h->pixf.satd[PIXEL_16x16]( p_dst, i_stride, p_src, i_stride ) +
370                 res->i_lambda * bs_size_ue( x264_mb_pred_mode16x16_fix[i_mode] );
371         /* if i_score is lower it is better */
372         if( res->i_sad_i16x16 == -1 || res->i_sad_i16x16 > i_sad )
373         {
374             res->i_predict16x16 = i_mode;
375             res->i_sad_i16x16     = i_sad;
376         }
377     }
378     /* cavlc mb type prefix */
379     if( h->sh.i_type == SLICE_TYPE_B )
380         res->i_sad_i16x16 += res->i_lambda * i_mb_b_cost_table[I_16x16];
381
382     /* 4x4 prediction selection */
383     if( flags & X264_ANALYSE_I4x4 )
384     {
385         res->i_sad_i4x4 = 0;
386         for( idx = 0; idx < 16; idx++ )
387         {
388             uint8_t *p_src_by;
389             uint8_t *p_dst_by;
390             int     i_best;
391             int x, y;
392             int i_pred_mode;
393
394             i_pred_mode= x264_mb_predict_intra4x4_mode( h, idx );
395             x = block_idx_x[idx];
396             y = block_idx_y[idx];
397
398             p_src_by = p_src + 4 * x + 4 * y * i_stride;
399             p_dst_by = p_dst + 4 * x + 4 * y * i_stride;
400
401             i_best = -1;
402             predict_4x4_mode_available( h->mb.i_neighbour, idx, predict_mode, &i_max );
403             for( i = 0; i < i_max; i++ )
404             {
405                 int i_sad;
406                 int i_mode;
407
408                 i_mode = predict_mode[i];
409
410                 /* we do the prediction */
411                 h->predict_4x4[i_mode]( p_dst_by, i_stride );
412
413                 /* we calculate diff and get the square sum of the diff */
414                 i_sad = h->pixf.satd[PIXEL_4x4]( p_dst_by, i_stride,
415                                                  p_src_by, i_stride );
416
417                 i_sad += res->i_lambda * (i_pred_mode == x264_mb_pred_mode4x4_fix[i_mode] ? 1 : 4);
418
419                 /* if i_score is lower it is better */
420                 if( i_best == -1 || i_best > i_sad )
421                 {
422                     res->i_predict4x4[x][y] = i_mode;
423                     i_best = i_sad;
424                 }
425             }
426             res->i_sad_i4x4 += i_best;
427
428             /* we need to encode this mb now (for next ones) */
429             h->predict_4x4[res->i_predict4x4[x][y]]( p_dst_by, i_stride );
430             x264_mb_encode_i4x4( h, idx, res->i_qp );
431
432             /* we need to store the 'fixed' version */
433             h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] =
434                 x264_mb_pred_mode4x4_fix[res->i_predict4x4[x][y]];
435         }
436         res->i_sad_i4x4 += res->i_lambda * 24;    /* from JVT (SATD0) */
437         if( h->sh.i_type == SLICE_TYPE_B )
438             res->i_sad_i4x4 += res->i_lambda * i_mb_b_cost_table[I_4x4];
439     }
440 }
441
442 static void x264_mb_analyse_intra_chroma( x264_t *h, x264_mb_analysis_t *res )
443 {
444     int i;
445
446     int i_max;
447     int predict_mode[9];
448
449     uint8_t *p_dstc[2], *p_srcc[2];
450     int      i_stride[2];
451
452     /* 8x8 prediction selection for chroma */
453     p_dstc[0] = h->mb.pic.p_fdec[1];
454     p_dstc[1] = h->mb.pic.p_fdec[2];
455     p_srcc[0] = h->mb.pic.p_fenc[1];
456     p_srcc[1] = h->mb.pic.p_fenc[2];
457
458     i_stride[0] = h->mb.pic.i_stride[1];
459     i_stride[1] = h->mb.pic.i_stride[2];
460
461     predict_8x8_mode_available( h->mb.i_neighbour, predict_mode, &i_max );
462     res->i_sad_i8x8 = -1;
463     for( i = 0; i < i_max; i++ )
464     {
465         int i_sad;
466         int i_mode;
467
468         i_mode = predict_mode[i];
469
470         /* we do the prediction */
471         h->predict_8x8[i_mode]( p_dstc[0], i_stride[0] );
472         h->predict_8x8[i_mode]( p_dstc[1], i_stride[1] );
473
474         /* we calculate the cost */
475         i_sad = h->pixf.satd[PIXEL_8x8]( p_dstc[0], i_stride[0],
476                                          p_srcc[0], i_stride[0] ) +
477                 h->pixf.satd[PIXEL_8x8]( p_dstc[1], i_stride[1],
478                                          p_srcc[1], i_stride[1] ) +
479                 res->i_lambda * bs_size_ue( x264_mb_pred_mode8x8_fix[i_mode] );
480
481         /* if i_score is lower it is better */
482         if( res->i_sad_i8x8 == -1 || res->i_sad_i8x8 > i_sad )
483         {
484             res->i_predict8x8 = i_mode;
485             res->i_sad_i8x8     = i_sad;
486         }
487     }
488 }
489
490 static void x264_mb_analyse_inter_p16x16( x264_t *h, x264_mb_analysis_t *a )
491 {
492     x264_me_t m;
493     int i_ref;
494     int mvc[4][2], i_mvc;
495     int i_fullpel_thresh = INT_MAX;
496     int *p_fullpel_thresh = h->i_ref0>1 ? &i_fullpel_thresh : NULL;
497
498     /* 16x16 Search on all ref frame */
499     m.i_pixel = PIXEL_16x16;
500     m.lm      = a->i_lambda;
501     m.p_fenc  = h->mb.pic.p_fenc[0];
502     m.i_stride= h->mb.pic.i_stride[0];
503     m.i_mv_range = a->i_mv_range;
504
505     a->l0.me16x16.cost = INT_MAX;
506     for( i_ref = 0; i_ref < h->i_ref0; i_ref++ )
507     {
508         const int i_ref_cost = m.lm * bs_size_te( h->sh.i_num_ref_idx_l0_active - 1, i_ref );
509         i_fullpel_thresh -= i_ref_cost;
510
511         /* search with ref */
512         m.p_fref = h->mb.pic.p_fref[0][i_ref][0];
513         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
514         x264_mb_predict_mv_ref16x16( h, 0, i_ref, mvc, &i_mvc );
515         x264_me_search_ref( h, &m, mvc, i_mvc, p_fullpel_thresh );
516
517         m.cost += i_ref_cost;
518         i_fullpel_thresh += i_ref_cost;
519
520         if( m.cost < a->l0.me16x16.cost )
521         {
522             a->l0.i_ref = i_ref;
523             a->l0.me16x16 = m;
524         }
525
526         /* save mv for predicting neighbors */
527         h->mb.mvr[0][i_ref][h->mb.i_mb_xy][0] = m.mv[0];
528         h->mb.mvr[0][i_ref][h->mb.i_mb_xy][1] = m.mv[1];
529     }
530
531     /* subtract ref cost, so we don't have to add it for the other P types */
532     a->l0.me16x16.cost -= m.lm * bs_size_te( h->sh.i_num_ref_idx_l0_active - 1, a->l0.i_ref );
533
534     /* Set global ref, needed for all others modes */
535     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
536 }
537
538 static void x264_mb_analyse_inter_p8x8( x264_t *h, x264_mb_analysis_t *a )
539 {
540     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
541     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
542     int mvc[5][2], i_mvc;
543     int i;
544
545     /* XXX Needed for x264_mb_predict_mv */
546     h->mb.i_partition = D_8x8;
547
548     i_mvc = 1;
549     mvc[0][0] = a->l0.me16x16.mv[0];
550     mvc[0][1] = a->l0.me16x16.mv[1];
551
552     for( i = 0; i < 4; i++ )
553     {
554         x264_me_t *m = &a->l0.me8x8[i];
555         const int x8 = i%2;
556         const int y8 = i/2;
557
558         m->i_pixel = PIXEL_8x8;
559         m->lm      = a->i_lambda;
560
561         m->p_fenc = &p_fenc[8*(y8*h->mb.pic.i_stride[0]+x8)];
562         m->p_fref = &p_fref[8*(y8*h->mb.pic.i_stride[0]+x8)];
563         m->i_stride= h->mb.pic.i_stride[0];
564         m->i_mv_range = a->i_mv_range;
565
566         x264_mb_predict_mv( h, 0, 4*i, 2, m->mvp );
567         x264_me_search( h, m, mvc, i_mvc );
568
569         x264_macroblock_cache_mv( h, 2*x8, 2*y8, 2, 2, 0, m->mv[0], m->mv[1] );
570
571         mvc[i_mvc][0] = m->mv[0];
572         mvc[i_mvc][1] = m->mv[1];
573         i_mvc++;
574
575         /* mb type cost */
576         m->cost += a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x8];
577     }
578
579     a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
580                    a->l0.me8x8[2].cost + a->l0.me8x8[3].cost;
581 }
582
583 static void x264_mb_analyse_inter_p16x8( x264_t *h, x264_mb_analysis_t *a )
584 {
585     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
586     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
587     int mvc[2][2];
588     int i;
589
590     /* XXX Needed for x264_mb_predict_mv */
591     h->mb.i_partition = D_16x8;
592
593     for( i = 0; i < 2; i++ )
594     {
595         x264_me_t *m = &a->l0.me16x8[i];
596
597         m->i_pixel = PIXEL_16x8;
598         m->lm      = a->i_lambda;
599
600         m->p_fenc = &p_fenc[8*i*h->mb.pic.i_stride[0]];
601         m->p_fref = &p_fref[8*i*h->mb.pic.i_stride[0]];
602         m->i_stride= h->mb.pic.i_stride[0];
603         m->i_mv_range = a->i_mv_range;
604
605         mvc[0][0] = a->l0.me8x8[2*i].mv[0];
606         mvc[0][1] = a->l0.me8x8[2*i].mv[1];
607         mvc[1][0] = a->l0.me8x8[2*i+1].mv[0];
608         mvc[1][1] = a->l0.me8x8[2*i+1].mv[1];
609
610         x264_mb_predict_mv( h, 0, 8*i, 4, m->mvp );
611         x264_me_search( h, m, mvc, 2 );
612
613         x264_macroblock_cache_mv( h, 0, 2*i, 4, 2, 0, m->mv[0], m->mv[1] );
614     }
615
616     a->l0.i_cost16x8 = a->l0.me16x8[0].cost + a->l0.me16x8[1].cost;
617 }
618
619 static void x264_mb_analyse_inter_p8x16( x264_t *h, x264_mb_analysis_t *a )
620 {
621     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
622     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
623     int mvc[2][2];
624     int i;
625
626     /* XXX Needed for x264_mb_predict_mv */
627     h->mb.i_partition = D_8x16;
628
629     for( i = 0; i < 2; i++ )
630     {
631         x264_me_t *m = &a->l0.me8x16[i];
632
633         m->i_pixel = PIXEL_8x16;
634         m->lm      = a->i_lambda;
635
636         m->p_fenc  = &p_fenc[8*i];
637         m->p_fref  = &p_fref[8*i];
638         m->i_stride= h->mb.pic.i_stride[0];
639         m->i_mv_range = a->i_mv_range;
640
641         mvc[0][0] = a->l0.me8x8[i].mv[0];
642         mvc[0][1] = a->l0.me8x8[i].mv[1];
643         mvc[1][0] = a->l0.me8x8[i+2].mv[0];
644         mvc[1][1] = a->l0.me8x8[i+2].mv[1];
645
646         x264_mb_predict_mv( h, 0, 4*i, 2, m->mvp );
647         x264_me_search( h, m, mvc, 2 );
648
649         x264_macroblock_cache_mv( h, 2*i, 0, 2, 4, 0, m->mv[0], m->mv[1] );
650     }
651
652     a->l0.i_cost8x16 = a->l0.me8x16[0].cost + a->l0.me8x16[1].cost;
653 }
654
655 static void x264_mb_analyse_inter_p4x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
656 {
657     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
658     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
659
660     int i4x4;
661
662     /* XXX Needed for x264_mb_predict_mv */
663     h->mb.i_partition = D_8x8;
664
665     for( i4x4 = 0; i4x4 < 4; i4x4++ )
666     {
667         const int idx = 4*i8x8 + i4x4;
668         const int x4 = block_idx_x[idx];
669         const int y4 = block_idx_y[idx];
670         const int i_mvc = (i4x4 == 0);
671
672         x264_me_t *m = &a->l0.me4x4[i8x8][i4x4];
673
674         m->i_pixel = PIXEL_4x4;
675         m->lm      = a->i_lambda;
676
677         m->p_fenc  = &p_fenc[4*(y4*h->mb.pic.i_stride[0]+x4)];
678         m->p_fref  = &p_fref[4*(y4*h->mb.pic.i_stride[0]+x4)];
679         m->i_stride= h->mb.pic.i_stride[0];
680         m->i_mv_range = a->i_mv_range;
681
682         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
683         x264_me_search( h, m, &a->l0.me8x8[i8x8].mv, i_mvc );
684
685         x264_macroblock_cache_mv( h, x4, y4, 1, 1, 0, m->mv[0], m->mv[1] );
686     }
687
688     a->l0.i_cost4x4[i8x8] = a->l0.me4x4[i8x8][0].cost +
689                          a->l0.me4x4[i8x8][1].cost +
690                          a->l0.me4x4[i8x8][2].cost +
691                          a->l0.me4x4[i8x8][3].cost +
692                          a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x4];
693 }
694
695 static void x264_mb_analyse_inter_p8x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
696 {
697     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
698     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
699
700     int i8x4;
701
702     /* XXX Needed for x264_mb_predict_mv */
703     h->mb.i_partition = D_8x8;
704
705     for( i8x4 = 0; i8x4 < 2; i8x4++ )
706     {
707         const int idx = 4*i8x8 + 2*i8x4;
708         const int x4 = block_idx_x[idx];
709         const int y4 = block_idx_y[idx];
710         const int i_mvc = (i8x4 == 0);
711
712         x264_me_t *m = &a->l0.me8x4[i8x8][i8x4];
713
714         m->i_pixel = PIXEL_8x4;
715         m->lm      = a->i_lambda;
716
717         m->p_fenc  = &p_fenc[4*(y4*h->mb.pic.i_stride[0]+x4)];
718         m->p_fref  = &p_fref[4*(y4*h->mb.pic.i_stride[0]+x4)];
719         m->i_stride= h->mb.pic.i_stride[0];
720         m->i_mv_range = a->i_mv_range;
721
722         x264_mb_predict_mv( h, 0, idx, 2, m->mvp );
723         x264_me_search( h, m, &a->l0.me4x4[i8x8][0].mv, i_mvc );
724
725         x264_macroblock_cache_mv( h, x4, y4, 2, 1, 0, m->mv[0], m->mv[1] );
726     }
727
728     a->l0.i_cost8x4[i8x8] = a->l0.me8x4[i8x8][0].cost + a->l0.me8x4[i8x8][1].cost +
729                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_8x4];
730 }
731
732 static void x264_mb_analyse_inter_p4x8( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
733 {
734     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
735     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
736
737     int i4x8;
738
739     /* XXX Needed for x264_mb_predict_mv */
740     h->mb.i_partition = D_8x8;
741
742     for( i4x8 = 0; i4x8 < 2; i4x8++ )
743     {
744         const int idx = 4*i8x8 + i4x8;
745         const int x4 = block_idx_x[idx];
746         const int y4 = block_idx_y[idx];
747         const int i_mvc = (i4x8 == 0);
748
749         x264_me_t *m = &a->l0.me4x8[i8x8][i4x8];
750
751         m->i_pixel = PIXEL_4x8;
752         m->lm      = a->i_lambda;
753
754         m->p_fenc  = &p_fenc[4*(y4*h->mb.pic.i_stride[0]+x4)];
755         m->p_fref  = &p_fref[4*(y4*h->mb.pic.i_stride[0]+x4)];
756         m->i_stride= h->mb.pic.i_stride[0];
757         m->i_mv_range = a->i_mv_range;
758
759         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
760         x264_me_search( h, m, &a->l0.me4x4[i8x8][0].mv, i_mvc );
761
762         x264_macroblock_cache_mv( h, x4, y4, 1, 2, 0, m->mv[0], m->mv[1] );
763     }
764
765     a->l0.i_cost4x8[i8x8] = a->l0.me4x8[i8x8][0].cost + a->l0.me4x8[i8x8][1].cost +
766                             a->i_lambda * i_sub_mb_p_cost_table[D_L0_4x8];
767 }
768
769 static void x264_mb_analyse_inter_direct( x264_t *h, x264_mb_analysis_t *a )
770 {
771     /* Assumes that fdec still contains the results of
772      * x264_mb_predict_mv_direct16x16 and x264_mb_mc */
773
774     uint8_t *p_fenc = h->mb.pic.p_fenc[0];
775     uint8_t *p_fdec = h->mb.pic.p_fdec[0];
776     int i_stride= h->mb.pic.i_stride[0];
777     int i;
778
779     a->i_cost16x16direct = 0;
780     for( i = 0; i < 4; i++ )
781     {
782         const int x8 = i%2;
783         const int y8 = i/2;
784         const int off = 8 * x8 + 8 * i_stride * y8;
785         a->i_cost16x16direct +=
786         a->i_cost8x8direct[i] =
787             h->pixf.satd[PIXEL_8x8]( &p_fenc[off], i_stride, &p_fdec[off], i_stride );
788
789         /* mb type cost */
790         a->i_cost8x8direct[i] += a->i_lambda * i_sub_mb_b_cost_table[D_DIRECT_8x8];
791     }
792
793     a->i_cost16x16direct += a->i_lambda * i_mb_b_cost_table[B_DIRECT];
794 }
795
796 static void x264_mb_analyse_inter_b16x16( x264_t *h, x264_mb_analysis_t *a )
797 {
798     uint8_t pix1[16*16], pix2[16*16];
799
800     x264_me_t m;
801     int i_ref;
802     int mvc[5][2], i_mvc;
803     int i_fullpel_thresh = INT_MAX;
804     int *p_fullpel_thresh = h->i_ref0>1 ? &i_fullpel_thresh : NULL;
805
806     /* 16x16 Search on all ref frame */
807     m.i_pixel = PIXEL_16x16;
808     m.lm      = a->i_lambda;
809     m.p_fenc  = h->mb.pic.p_fenc[0];
810     m.i_stride= h->mb.pic.i_stride[0];
811     m.i_mv_range = a->i_mv_range;
812
813     /* ME for List 0 */
814     a->l0.me16x16.cost = INT_MAX;
815     for( i_ref = 0; i_ref < h->i_ref0; i_ref++ )
816     {
817         /* search with ref */
818         m.p_fref = h->mb.pic.p_fref[0][i_ref][0];
819         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
820         x264_mb_predict_mv_ref16x16( h, 0, i_ref, mvc, &i_mvc );
821         x264_me_search_ref( h, &m, mvc, i_mvc, p_fullpel_thresh );
822
823         /* add ref cost */
824         m.cost += m.lm * bs_size_te( h->sh.i_num_ref_idx_l0_active - 1, i_ref );
825
826         if( m.cost < a->l0.me16x16.cost )
827         {
828             a->l0.i_ref = i_ref;
829             a->l0.me16x16 = m;
830         }
831
832         /* save mv for predicting neighbors */
833         h->mb.mvr[0][i_ref][h->mb.i_mb_xy][0] = m.mv[0];
834         h->mb.mvr[0][i_ref][h->mb.i_mb_xy][1] = m.mv[1];
835     }
836     /* subtract ref cost, so we don't have to add it for the other MB types */
837     a->l0.me16x16.cost -= m.lm * bs_size_te( h->sh.i_num_ref_idx_l0_active - 1, a->l0.i_ref );
838
839     /* ME for list 1 */
840     /* not using fullpel_thresh since we don't yet do more than 1 list 1 ref */
841     a->l1.me16x16.cost = INT_MAX;
842     for( i_ref = 0; i_ref < h->i_ref1; i_ref++ )
843     {
844         /* search with ref */
845         m.p_fref = h->mb.pic.p_fref[1][i_ref][0];
846         x264_mb_predict_mv_16x16( h, 1, i_ref, m.mvp );
847         x264_mb_predict_mv_ref16x16( h, 1, i_ref, mvc, &i_mvc );
848         x264_me_search( h, &m, mvc, i_mvc );
849
850         /* add ref cost */
851         m.cost += m.lm * bs_size_te( h->sh.i_num_ref_idx_l1_active - 1, i_ref );
852
853         if( m.cost < a->l1.me16x16.cost )
854         {
855             a->l1.i_ref = i_ref;
856             a->l1.me16x16 = m;
857         }
858
859         /* save mv for predicting neighbors */
860         h->mb.mvr[1][i_ref][h->mb.i_mb_xy][0] = m.mv[0];
861         h->mb.mvr[1][i_ref][h->mb.i_mb_xy][1] = m.mv[1];
862     }
863     /* subtract ref cost, so we don't have to add it for the other MB types */
864     a->l1.me16x16.cost -= m.lm * bs_size_te( h->sh.i_num_ref_idx_l1_active - 1, a->l1.i_ref );
865
866     /* Set global ref, needed for other modes? */
867     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
868     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.i_ref );
869
870     /* get cost of BI mode */
871     h->mc[MC_LUMA]( h->mb.pic.p_fref[0][a->l0.i_ref][0], h->mb.pic.i_stride[0],
872                     pix1, 16,
873                     a->l0.me16x16.mv[0], a->l0.me16x16.mv[1],
874                     16, 16 );
875     h->mc[MC_LUMA]( h->mb.pic.p_fref[1][a->l1.i_ref][0], h->mb.pic.i_stride[0],
876                     pix2, 16,
877                     a->l1.me16x16.mv[0], a->l1.me16x16.mv[1],
878                     16, 16 );
879     h->pixf.avg[PIXEL_16x16]( pix1, 16, pix2, 16 );
880
881     a->i_cost16x16bi = h->pixf.satd[PIXEL_16x16]( h->mb.pic.p_fenc[0], h->mb.pic.i_stride[0], pix1, 16 ) +
882                        a->i_lambda * ( bs_size_te( h->sh.i_num_ref_idx_l0_active - 1, a->l0.i_ref ) +
883                                        bs_size_te( h->sh.i_num_ref_idx_l1_active - 1, a->l1.i_ref ) +
884                                        bs_size_se( a->l0.me16x16.mv[0] - a->l0.me16x16.mvp[0] ) +
885                                        bs_size_se( a->l0.me16x16.mv[1] - a->l0.me16x16.mvp[1] ) +
886                                        bs_size_se( a->l1.me16x16.mv[0] - a->l1.me16x16.mvp[0] ) +
887                                        bs_size_se( a->l1.me16x16.mv[1] - a->l1.me16x16.mvp[1] ) );
888
889     /* mb type cost */
890     a->i_cost16x16bi   += a->i_lambda * i_mb_b_cost_table[B_BI_BI];
891     a->l0.me16x16.cost += a->i_lambda * i_mb_b_cost_table[B_L0_L0];
892     a->l1.me16x16.cost += a->i_lambda * i_mb_b_cost_table[B_L1_L1];
893 }
894
895 #define CACHE_MV_BI(x,y,dx,dy,me0,me1,part) \
896     if( x264_mb_partition_listX_table[0][part] ) \
897     { \
898         x264_macroblock_cache_ref( h, x,y,dx,dy, 0, a->l0.i_ref ); \
899         x264_macroblock_cache_mv(  h, x,y,dx,dy, 0, me0.mv[0], me0.mv[1] ); \
900     } \
901     else \
902     { \
903         x264_macroblock_cache_ref( h, x,y,dx,dy, 0, -1 ); \
904         x264_macroblock_cache_mv(  h, x,y,dx,dy, 0, 0, 0 ); \
905         if( b_mvd ) \
906             x264_macroblock_cache_mvd( h, x,y,dx,dy, 0, 0, 0 ); \
907     } \
908     if( x264_mb_partition_listX_table[1][part] ) \
909     { \
910         x264_macroblock_cache_ref( h, x,y,dx,dy, 1, a->l1.i_ref ); \
911         x264_macroblock_cache_mv(  h, x,y,dx,dy, 1, me1.mv[0], me1.mv[1] ); \
912     } \
913     else \
914     { \
915         x264_macroblock_cache_ref( h, x,y,dx,dy, 1, -1 ); \
916         x264_macroblock_cache_mv(  h, x,y,dx,dy, 1, 0, 0 ); \
917         if( b_mvd ) \
918             x264_macroblock_cache_mvd( h, x,y,dx,dy, 1, 0, 0 ); \
919     }
920
921 static inline void x264_mb_cache_mv_b8x8( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
922 {
923     int x = (i%2)*2;
924     int y = (i/2)*2;
925     if( h->mb.i_sub_partition[i] == D_DIRECT_8x8 )
926     {
927         x264_mb_load_mv_direct8x8( h, i );
928         if( b_mvd )
929         {
930             x264_macroblock_cache_mvd(  h, x, y, 2, 2, 0, 0, 0 );
931             x264_macroblock_cache_mvd(  h, x, y, 2, 2, 1, 0, 0 );
932             x264_macroblock_cache_skip( h, x, y, 2, 2, 1 );
933         }
934     }
935     else
936     {
937         CACHE_MV_BI( x, y, 2, 2, a->l0.me8x8[i], a->l1.me8x8[i], h->mb.i_sub_partition[i] );
938     }
939 }
940 static inline void x264_mb_cache_mv_b16x8( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
941 {
942     CACHE_MV_BI( 0, 2*i, 4, 2, a->l0.me16x8[i], a->l1.me16x8[i], a->i_mb_partition16x8[i] );
943 }
944 static inline void x264_mb_cache_mv_b8x16( x264_t *h, x264_mb_analysis_t *a, int i, int b_mvd )
945 {
946     CACHE_MV_BI( 2*i, 0, 2, 4, a->l0.me8x16[i], a->l1.me8x16[i], a->i_mb_partition8x16[i] );
947 }
948 #undef CACHE_MV_BI
949
950 static void x264_mb_analyse_inter_b8x8( x264_t *h, x264_mb_analysis_t *a )
951 {
952     uint8_t *p_fref[2] = { h->mb.pic.p_fref[0][a->l0.i_ref][0],
953                            h->mb.pic.p_fref[1][a->l1.i_ref][0] };
954     uint8_t *p_fenc = h->mb.pic.p_fenc[0];
955     uint8_t pix[2][8*8];
956     int i, l;
957
958     /* XXX Needed for x264_mb_predict_mv */
959     h->mb.i_partition = D_8x8;
960
961     a->i_cost8x8bi = 0;
962
963     for( i = 0; i < 4; i++ )
964     {
965         const int x8 = i%2;
966         const int y8 = i/2;
967         uint8_t *p_fenc_i = &p_fenc[8*(y8*h->mb.pic.i_stride[0]+x8)];
968         int i_part_cost;
969         int i_part_cost_bi = 0;
970
971         for( l = 0; l < 2; l++ )
972         {
973             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
974             x264_me_t *m = &lX->me8x8[i];
975
976             m->i_pixel = PIXEL_8x8;
977             m->lm      = a->i_lambda;
978
979             m->p_fenc = p_fenc_i;
980             m->p_fref = &p_fref[l][8*(y8*h->mb.pic.i_stride[0]+x8)];
981             m->i_stride = h->mb.pic.i_stride[0];
982             m->i_mv_range = a->i_mv_range;
983
984             x264_mb_predict_mv( h, l, 4*i, 2, m->mvp );
985             x264_me_search( h, m, &lX->me16x16.mv, 1 );
986
987             x264_macroblock_cache_mv( h, 2*x8, 2*y8, 2, 2, l, m->mv[0], m->mv[1] );
988             lX->i_cost8x8 += m->cost;
989
990             /* BI mode */
991             h->mc[MC_LUMA]( m->p_fref, m->i_stride, pix[l], 8,
992                             m->mv[0], m->mv[1], 8, 8 );
993             /* FIXME: ref cost */
994             i_part_cost_bi += a->i_lambda * ( bs_size_se( m->mv[0] - m->mvp[0] ) +
995                                               bs_size_se( m->mv[1] - m->mvp[1] ) +
996                                               i_sub_mb_b_cost_table[D_L0_8x8] );
997         }
998
999         h->pixf.avg[PIXEL_8x8]( pix[0], 8, pix[1], 8 );
1000         i_part_cost_bi += h->pixf.satd[PIXEL_8x8]( p_fenc_i, h->mb.pic.i_stride[0], pix[0], 8 )
1001                         + a->i_lambda * i_sub_mb_b_cost_table[D_BI_8x8];
1002
1003         i_part_cost = a->l0.me8x8[i].cost;
1004         h->mb.i_sub_partition[i] = D_L0_8x8;
1005         if( a->l1.me8x8[i].cost < i_part_cost )
1006         {
1007             i_part_cost = a->l1.me8x8[i].cost;
1008             h->mb.i_sub_partition[i] = D_L1_8x8;
1009         }
1010         if( i_part_cost_bi < i_part_cost )
1011         {
1012             i_part_cost = i_part_cost_bi;
1013             h->mb.i_sub_partition[i] = D_BI_8x8;
1014         }
1015         if( a->i_cost8x8direct[i] < i_part_cost && a->i_cost8x8direct[i] >= 0)
1016         {
1017             i_part_cost = a->i_cost8x8direct[i];
1018             h->mb.i_sub_partition[i] = D_DIRECT_8x8;
1019         }
1020         a->i_cost8x8bi += i_part_cost;
1021
1022         /* XXX Needed for x264_mb_predict_mv */
1023         x264_mb_cache_mv_b8x8( h, a, i, 0 );
1024     }
1025
1026     /* mb type cost */
1027     a->i_cost8x8bi += a->i_lambda * i_mb_b_cost_table[B_8x8];
1028 }
1029
1030 static void x264_mb_analyse_inter_b16x8( x264_t *h, x264_mb_analysis_t *a )
1031 {
1032     uint8_t *p_fref[2] = { h->mb.pic.p_fref[0][a->l0.i_ref][0],
1033                            h->mb.pic.p_fref[1][a->l1.i_ref][0] };
1034     uint8_t *p_fenc = h->mb.pic.p_fenc[0];
1035     uint8_t pix[2][8*8];
1036     int i_ref_stride = h->mb.pic.i_stride[0];
1037     int mvc[2][2];
1038     int i, l;
1039
1040     h->mb.i_partition = D_16x8;
1041     a->i_cost16x8bi = 0;
1042
1043     for( i = 0; i < 2; i++ )
1044     {
1045         uint8_t *p_fenc_i = &p_fenc[8*i*i_ref_stride];
1046         int i_part_cost;
1047         int i_part_cost_bi = 0;
1048
1049         /* TODO: check only the list(s) that were used in b8x8? */
1050         for( l = 0; l < 2; l++ )
1051         {
1052             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
1053             x264_me_t *m = &lX->me16x8[i];
1054
1055             m->i_pixel = PIXEL_16x8;
1056             m->lm      = a->i_lambda;
1057
1058             m->p_fenc  = p_fenc_i;
1059             m->i_stride= i_ref_stride;
1060             m->p_fref  = &p_fref[l][8*i*i_ref_stride];
1061             m->i_mv_range = a->i_mv_range;
1062
1063             mvc[0][0] = lX->me8x8[2*i].mv[0];
1064             mvc[0][1] = lX->me8x8[2*i].mv[1];
1065             mvc[1][0] = lX->me8x8[2*i+1].mv[0];
1066             mvc[1][1] = lX->me8x8[2*i+1].mv[1];
1067
1068             x264_mb_predict_mv( h, 0, 8*i, 2, m->mvp );
1069             x264_me_search( h, m, mvc, 2 );
1070
1071             /* BI mode */
1072             h->mc[MC_LUMA]( m->p_fref, m->i_stride, pix[l], 8,
1073                             m->mv[0], m->mv[1], 8, 8 );
1074             /* FIXME: ref cost */
1075             i_part_cost_bi += a->i_lambda * ( bs_size_se( m->mv[0] - m->mvp[0] ) +
1076                                               bs_size_se( m->mv[1] - m->mvp[1] ) );
1077         }
1078
1079         h->pixf.avg[PIXEL_16x8]( pix[0], 8, pix[1], 8 );
1080         i_part_cost_bi += h->pixf.satd[PIXEL_16x8]( p_fenc_i, h->mb.pic.i_stride[0], pix[0], 8 );
1081
1082         i_part_cost = a->l0.me16x8[i].cost;
1083         a->i_mb_partition16x8[i] = D_L0_8x8; /* not actually 8x8, only the L0 matters */
1084         if( a->l1.me16x8[i].cost < i_part_cost )
1085         {
1086             i_part_cost = a->l1.me16x8[i].cost;
1087             a->i_mb_partition16x8[i] = D_L1_8x8;
1088         }
1089         if( i_part_cost_bi + a->i_lambda * 1 < i_part_cost )
1090         {
1091             i_part_cost = i_part_cost_bi;
1092             a->i_mb_partition16x8[i] = D_BI_8x8;
1093         }
1094         a->i_cost16x8bi += i_part_cost;
1095
1096         if( i == 0 )
1097             x264_mb_cache_mv_b16x8( h, a, i, 0 );
1098     }
1099
1100     /* mb type cost */
1101     a->i_mb_type16x8 = B_L0_L0
1102         + (a->i_mb_partition16x8[0]>>2) * 3
1103         + (a->i_mb_partition16x8[1]>>2);
1104     a->i_cost16x8bi += a->i_lambda * i_mb_b16x8_cost_table[a->i_mb_type16x8];
1105 }
1106 static void x264_mb_analyse_inter_b8x16( x264_t *h, x264_mb_analysis_t *a )
1107 {
1108     uint8_t *p_fref[2] = { h->mb.pic.p_fref[0][a->l0.i_ref][0],
1109                            h->mb.pic.p_fref[1][a->l1.i_ref][0] };
1110     uint8_t *p_fenc = h->mb.pic.p_fenc[0];
1111     uint8_t pix[2][8*8];
1112     int i_ref_stride = h->mb.pic.i_stride[0];
1113     int mvc[2][2];
1114     int i, l;
1115
1116     h->mb.i_partition = D_8x16;
1117     a->i_cost8x16bi = 0;
1118
1119     for( i = 0; i < 2; i++ )
1120     {
1121         uint8_t *p_fenc_i = &p_fenc[8*i];
1122         int i_part_cost;
1123         int i_part_cost_bi = 0;
1124
1125         for( l = 0; l < 2; l++ )
1126         {
1127             x264_mb_analysis_list_t *lX = l ? &a->l1 : &a->l0;
1128             x264_me_t *m = &lX->me8x16[i];
1129
1130             m->i_pixel = PIXEL_8x16;
1131             m->lm      = a->i_lambda;
1132
1133             m->p_fenc  = p_fenc_i;
1134             m->p_fref  = &p_fref[l][8*i];
1135             m->i_stride= i_ref_stride;
1136             m->i_mv_range = a->i_mv_range;
1137
1138             mvc[0][0] = lX->me8x8[i].mv[0];
1139             mvc[0][1] = lX->me8x8[i].mv[1];
1140             mvc[1][0] = lX->me8x8[i+2].mv[0];
1141             mvc[1][1] = lX->me8x8[i+2].mv[1];
1142
1143             x264_mb_predict_mv( h, 0, 4*i, 2, m->mvp );
1144             x264_me_search( h, m, mvc, 2 );
1145
1146             /* BI mode */
1147             h->mc[MC_LUMA]( m->p_fref, m->i_stride, pix[l], 8,
1148                             m->mv[0], m->mv[1], 8, 8 );
1149             /* FIXME: ref cost */
1150             i_part_cost_bi += a->i_lambda * ( bs_size_se( m->mv[0] - m->mvp[0] ) +
1151                                               bs_size_se( m->mv[1] - m->mvp[1] ) );
1152         }
1153
1154         h->pixf.avg[PIXEL_8x16]( pix[0], 8, pix[1], 8 );
1155         i_part_cost_bi += h->pixf.satd[PIXEL_8x16]( p_fenc_i, h->mb.pic.i_stride[0], pix[0], 8 );
1156
1157         i_part_cost = a->l0.me8x16[i].cost;
1158         a->i_mb_partition8x16[i] = D_L0_8x8;
1159         if( a->l1.me8x16[i].cost < i_part_cost )
1160         {
1161             i_part_cost = a->l1.me8x16[i].cost;
1162             a->i_mb_partition8x16[i] = D_L1_8x8;
1163         }
1164         if( i_part_cost_bi + a->i_lambda * 1 < i_part_cost )
1165         {
1166             i_part_cost = i_part_cost_bi;
1167             a->i_mb_partition8x16[i] = D_BI_8x8;
1168         }
1169         a->i_cost8x16bi += i_part_cost;
1170
1171         if( i == 0 )
1172             x264_mb_cache_mv_b8x16( h, a, i, 0 );
1173     }
1174
1175     /* mb type cost */
1176     a->i_mb_type8x16 = B_L0_L0
1177         + (a->i_mb_partition8x16[0]>>2) * 3
1178         + (a->i_mb_partition8x16[1]>>2);
1179     a->i_cost8x16bi += a->i_lambda * i_mb_b16x8_cost_table[a->i_mb_type8x16];
1180 }
1181
1182 /*****************************************************************************
1183  * x264_macroblock_analyse:
1184  *****************************************************************************/
1185 void x264_macroblock_analyse( x264_t *h )
1186 {
1187     x264_mb_analysis_t analysis;
1188     int i;
1189
1190     h->mb.qp[h->mb.i_mb_xy] = x264_ratecontrol_qp(h);
1191
1192     /* FIXME check if it's 12 */
1193     if( h->mb.qp[h->mb.i_mb_xy] - h->mb.i_last_qp < -12 )
1194         h->mb.qp[h->mb.i_mb_xy] = h->mb.i_last_qp - 12;
1195     else if( h->mb.qp[h->mb.i_mb_xy] - h->mb.i_last_qp > 12 )
1196         h->mb.qp[h->mb.i_mb_xy] = h->mb.i_last_qp + 12;
1197
1198     /* init analysis */
1199     x264_mb_analyse_init( h, &analysis, h->mb.qp[h->mb.i_mb_xy] );
1200
1201     /*--------------------------- Do the analysis ---------------------------*/
1202     if( h->sh.i_type == SLICE_TYPE_I )
1203     {
1204         x264_mb_analyse_intra( h, &analysis );
1205
1206         if( analysis.i_sad_i4x4 >= 0 &&  analysis.i_sad_i4x4 < analysis.i_sad_i16x16 )
1207             h->mb.i_type = I_4x4;
1208         else
1209             h->mb.i_type = I_16x16;
1210     }
1211     else if( h->sh.i_type == SLICE_TYPE_P )
1212     {
1213         const unsigned int i_neighbour = h->mb.i_neighbour;
1214
1215         int b_skip = 0;
1216         int i_cost;
1217         int i_intra_cost, i_intra_type;
1218
1219         /* Fast P_SKIP detection */
1220         if( ( (i_neighbour&MB_LEFT) && h->mb.type[h->mb.i_mb_xy - 1] == P_SKIP ) ||
1221             ( (i_neighbour&MB_TOP) && h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride] == P_SKIP ) ||
1222             ( ((i_neighbour&(MB_TOP|MB_LEFT)) == (MB_TOP|MB_LEFT) ) && h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride-1 ] == P_SKIP ) ||
1223             ( (i_neighbour&MB_TOPRIGHT) && h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride+1 ] == P_SKIP ) )
1224         {
1225             b_skip = x264_macroblock_probe_pskip( h );
1226         }
1227
1228         if( b_skip )
1229         {
1230             h->mb.i_type = P_SKIP;
1231             h->mb.i_partition = D_16x16;
1232         }
1233         else
1234         {
1235             const unsigned int flags = h->param.analyse.inter;
1236             int i_type;
1237             int i_partition;
1238
1239             x264_mb_analyse_inter_p16x16( h, &analysis );
1240             if( flags & X264_ANALYSE_PSUB16x16 )
1241                 x264_mb_analyse_inter_p8x8( h, &analysis );
1242
1243             /* Select best inter mode */
1244             i_type = P_L0;
1245             i_partition = D_16x16;
1246             i_cost = analysis.l0.me16x16.cost;
1247
1248             if( ( flags & X264_ANALYSE_PSUB16x16 ) &&
1249                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost )
1250             {
1251                 int i;
1252
1253                 i_type = P_8x8;
1254                 i_partition = D_8x8;
1255                 h->mb.i_sub_partition[0] = D_L0_8x8;
1256                 h->mb.i_sub_partition[1] = D_L0_8x8;
1257                 h->mb.i_sub_partition[2] = D_L0_8x8;
1258                 h->mb.i_sub_partition[3] = D_L0_8x8;
1259
1260                 i_cost = analysis.l0.i_cost8x8;
1261
1262                 /* Do sub 8x8 */
1263                 if( flags & X264_ANALYSE_PSUB8x8 )
1264                 {
1265                     for( i = 0; i < 4; i++ )
1266                     {
1267                         x264_mb_analyse_inter_p4x4( h, &analysis, i );
1268                         if( analysis.l0.i_cost4x4[i] < analysis.l0.me8x8[i].cost )
1269                         {
1270                             int i_cost8x8;
1271
1272                             h->mb.i_sub_partition[i] = D_L0_4x4;
1273                             i_cost8x8 = analysis.l0.i_cost4x4[i];
1274
1275                             x264_mb_analyse_inter_p8x4( h, &analysis, i );
1276                             if( analysis.l0.i_cost8x4[i] < analysis.l0.i_cost4x4[i] )
1277                             {
1278                                 h->mb.i_sub_partition[i] = D_L0_8x4;
1279                                 i_cost8x8 = analysis.l0.i_cost8x4[i];
1280                             }
1281
1282                             x264_mb_analyse_inter_p4x8( h, &analysis, i );
1283                             if( analysis.l0.i_cost4x8[i] < analysis.l0.i_cost4x4[i] )
1284                             {
1285                                 h->mb.i_sub_partition[i] = D_L0_4x8;
1286                                 i_cost8x8 = analysis.l0.i_cost4x8[i];
1287                             }
1288
1289                             i_cost += i_cost8x8 - analysis.l0.me8x8[i].cost;
1290                         }
1291                     }
1292                 }
1293
1294                 /* Now do sub 16x8/8x16 */
1295                 x264_mb_analyse_inter_p16x8( h, &analysis );
1296                 if( analysis.l0.i_cost16x8 < i_cost )
1297                 {
1298                     i_type = P_L0;
1299                     i_partition = D_16x8;
1300                     i_cost = analysis.l0.i_cost16x8;
1301                 }
1302
1303                 x264_mb_analyse_inter_p8x16( h, &analysis );
1304                 if( analysis.l0.i_cost8x16 < i_cost )
1305                 {
1306                     i_type = P_L0;
1307                     i_partition = D_8x16;
1308                     i_cost = analysis.l0.i_cost8x16;
1309                 }
1310             }
1311
1312             h->mb.i_type = i_type;
1313             h->mb.i_partition = i_partition;
1314
1315             /* refine qpel */
1316             if( h->mb.i_partition == D_16x16 )
1317             {
1318                 x264_me_refine_qpel( h, &analysis.l0.me16x16 );
1319                 i_cost = analysis.l0.me16x16.cost;
1320             }
1321             else if( h->mb.i_partition == D_16x8 )
1322             {
1323                 x264_me_refine_qpel( h, &analysis.l0.me16x8[0] );
1324                 x264_me_refine_qpel( h, &analysis.l0.me16x8[1] );
1325                 i_cost = analysis.l0.me16x8[0].cost + analysis.l0.me16x8[1].cost;
1326             }
1327             else if( h->mb.i_partition == D_8x16 )
1328             {
1329                 x264_me_refine_qpel( h, &analysis.l0.me8x16[0] );
1330                 x264_me_refine_qpel( h, &analysis.l0.me8x16[1] );
1331                 i_cost = analysis.l0.me8x16[0].cost + analysis.l0.me8x16[1].cost;
1332             }
1333             else if( h->mb.i_partition == D_8x8 )
1334             {
1335                 int i8x8;
1336                 i_cost = 0;
1337                 for( i8x8 = 0; i8x8 < 4; i8x8++ )
1338                 {
1339                     switch( h->mb.i_sub_partition[i8x8] )
1340                     {
1341                         case D_L0_8x8:
1342                             x264_me_refine_qpel( h, &analysis.l0.me8x8[i8x8] );
1343                             i_cost += analysis.l0.me8x8[i8x8].cost;
1344                             break;
1345                         case D_L0_8x4:
1346                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][0] );
1347                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][1] );
1348                             i_cost += analysis.l0.me8x4[i8x8][0].cost +
1349                                       analysis.l0.me8x4[i8x8][1].cost;
1350                             break;
1351                         case D_L0_4x8:
1352                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][0] );
1353                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][1] );
1354                             i_cost += analysis.l0.me4x8[i8x8][0].cost +
1355                                       analysis.l0.me4x8[i8x8][1].cost;
1356                             break;
1357
1358                         case D_L0_4x4:
1359                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][0] );
1360                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][1] );
1361                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][2] );
1362                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][3] );
1363                             i_cost += analysis.l0.me4x4[i8x8][0].cost +
1364                                       analysis.l0.me4x4[i8x8][1].cost +
1365                                       analysis.l0.me4x4[i8x8][2].cost +
1366                                       analysis.l0.me4x4[i8x8][3].cost;
1367                             break;
1368                         default:
1369                             fprintf( stderr, "internal error (!8x8 && !4x4)" );
1370                             break;
1371                     }
1372                 }
1373             }
1374
1375             x264_mb_analyse_intra( h, &analysis );
1376             i_intra_type = I_16x16;
1377             i_intra_cost = analysis.i_sad_i16x16;
1378
1379             if( analysis.i_sad_i4x4 >=0 && analysis.i_sad_i4x4 < i_intra_cost )
1380             {
1381                 i_intra_type = I_4x4;
1382                 i_intra_cost = analysis.i_sad_i4x4;
1383             }
1384
1385             if( i_intra_cost >= 0 && i_intra_cost < i_cost )
1386             {
1387                 h->mb.i_type = i_intra_type;
1388                 i_cost = i_intra_cost;
1389             }
1390
1391             h->stat.frame.i_intra_cost += i_intra_cost;
1392             h->stat.frame.i_inter_cost += i_cost;
1393         }
1394     }
1395     else if( h->sh.i_type == SLICE_TYPE_B )
1396     {
1397         int b_skip = 0;
1398
1399         analysis.b_direct_available = x264_mb_predict_mv_direct16x16( h );
1400         if( analysis.b_direct_available )
1401         {
1402             h->mb.i_type = B_SKIP;
1403             x264_mb_mc( h );
1404
1405             /* Conditioning the probe on neighboring block types
1406              * doesn't seem to help speed or quality. */
1407             b_skip = x264_macroblock_probe_bskip( h );
1408         }
1409
1410         if( !b_skip )
1411         {
1412             const unsigned int flags = h->param.analyse.inter;
1413             int i_partition;
1414             int i_cost;
1415
1416             /* select best inter mode */
1417             /* direct must be first */
1418             if( analysis.b_direct_available )
1419                 x264_mb_analyse_inter_direct( h, &analysis );
1420
1421             x264_mb_analyse_inter_b16x16( h, &analysis );
1422
1423             h->mb.i_type = B_L0_L0;
1424             i_partition = D_16x16;
1425             i_cost = analysis.l0.me16x16.cost;
1426             if( analysis.l1.me16x16.cost < i_cost )
1427             {
1428                 h->mb.i_type = B_L1_L1;
1429                 i_cost = analysis.l1.me16x16.cost;
1430             }
1431             if( analysis.i_cost16x16bi < i_cost )
1432             {
1433                 h->mb.i_type = B_BI_BI;
1434                 i_cost = analysis.i_cost16x16bi;
1435             }
1436             if( analysis.i_cost16x16direct < i_cost && analysis.i_cost16x16direct >= 0 )
1437             {
1438                 h->mb.i_type = B_DIRECT;
1439                 i_cost = analysis.i_cost16x16direct;
1440             }
1441             
1442             if( flags & X264_ANALYSE_BSUB16x16 )
1443             {
1444                 x264_mb_analyse_inter_b8x8( h, &analysis );
1445                 if( analysis.i_cost8x8bi < i_cost )
1446                 {
1447                     h->mb.i_type = B_8x8;
1448                     i_partition = D_8x8;
1449                     i_cost = analysis.i_cost8x8bi;
1450
1451                     if( h->mb.i_sub_partition[0] == h->mb.i_sub_partition[1] ||
1452                         h->mb.i_sub_partition[2] == h->mb.i_sub_partition[3] )
1453                     {
1454                         x264_mb_analyse_inter_b16x8( h, &analysis );
1455                         if( analysis.i_cost16x8bi < i_cost )
1456                         {
1457                             i_partition = D_16x8;
1458                             i_cost = analysis.i_cost16x8bi;
1459                             h->mb.i_type = analysis.i_mb_type16x8;
1460                         }
1461                     }
1462                     if( h->mb.i_sub_partition[0] == h->mb.i_sub_partition[2] ||
1463                         h->mb.i_sub_partition[1] == h->mb.i_sub_partition[3] )
1464                     {
1465                         x264_mb_analyse_inter_b8x16( h, &analysis );
1466                         if( analysis.i_cost8x16bi < i_cost )
1467                         {
1468                             i_partition = D_8x16;
1469                             i_cost = analysis.i_cost8x16bi;
1470                             h->mb.i_type = analysis.i_mb_type8x16;
1471                         }
1472                     }
1473                 }
1474             }
1475
1476             h->mb.i_partition = i_partition;
1477
1478             /* refine qpel */
1479             if( i_partition == D_16x16 )
1480             {
1481                 if( h->mb.i_type == B_L0_L0 )
1482                 {
1483                     analysis.l0.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
1484                     x264_me_refine_qpel( h, &analysis.l0.me16x16 );
1485                     analysis.l0.me16x16.cost += analysis.i_lambda * i_mb_b_cost_table[B_L0_L0];
1486                     i_cost = analysis.l0.me16x16.cost;
1487                 }
1488                 else if( h->mb.i_type == B_L1_L1 )
1489                 {
1490                     analysis.l1.me16x16.cost -= analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
1491                     x264_me_refine_qpel( h, &analysis.l1.me16x16 );
1492                     analysis.l1.me16x16.cost += analysis.i_lambda * i_mb_b_cost_table[B_L1_L1];
1493                     i_cost = analysis.l1.me16x16.cost;
1494                 }
1495             }
1496             /* TODO: refine bidir, 8x8 */
1497
1498             /* best intra mode */
1499             x264_mb_analyse_intra( h, &analysis );
1500
1501             if( analysis.i_sad_i16x16 >= 0 && analysis.i_sad_i16x16 < i_cost )
1502             {
1503                 h->mb.i_type = I_16x16;
1504                 i_cost = analysis.i_sad_i16x16;
1505             }
1506             if( analysis.i_sad_i4x4 >=0 && analysis.i_sad_i4x4 < i_cost )
1507             {
1508                 h->mb.i_type = I_4x4;
1509                 i_cost = analysis.i_sad_i4x4;
1510             }
1511         }
1512     }
1513
1514     /*-------------------- Update MB from the analysis ----------------------*/
1515     h->mb.type[h->mb.i_mb_xy] = h->mb.i_type;
1516     switch( h->mb.i_type )
1517     {
1518         case I_4x4:
1519             for( i = 0; i < 16; i++ )
1520             {
1521                 h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] =
1522                     analysis.i_predict4x4[block_idx_x[i]][block_idx_y[i]];
1523             }
1524
1525             x264_mb_analyse_intra_chroma( h, &analysis );
1526             h->mb.i_chroma_pred_mode = analysis.i_predict8x8;
1527             break;
1528         case I_16x16:
1529             h->mb.i_intra16x16_pred_mode = analysis.i_predict16x16;
1530
1531             x264_mb_analyse_intra_chroma( h, &analysis );
1532             h->mb.i_chroma_pred_mode = analysis.i_predict8x8;
1533             break;
1534
1535         case P_L0:
1536             x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.i_ref );
1537             switch( h->mb.i_partition )
1538             {
1539                 case D_16x16:
1540                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.mv[0], analysis.l0.me16x16.mv[1] );
1541                     break;
1542
1543                 case D_16x8:
1544                     x264_macroblock_cache_mv ( h, 0, 0, 4, 2, 0, analysis.l0.me16x8[0].mv[0], analysis.l0.me16x8[0].mv[1] );
1545                     x264_macroblock_cache_mv ( h, 0, 2, 4, 2, 0, analysis.l0.me16x8[1].mv[0], analysis.l0.me16x8[1].mv[1] );
1546                     break;
1547
1548                 case D_8x16:
1549                     x264_macroblock_cache_mv ( h, 0, 0, 2, 4, 0, analysis.l0.me8x16[0].mv[0], analysis.l0.me8x16[0].mv[1] );
1550                     x264_macroblock_cache_mv ( h, 2, 0, 2, 4, 0, analysis.l0.me8x16[1].mv[0], analysis.l0.me8x16[1].mv[1] );
1551                     break;
1552
1553                 default:
1554                     fprintf( stderr, "internal error P_L0 and partition=%d\n", h->mb.i_partition );
1555                     break;
1556             }
1557             break;
1558
1559         case P_8x8:
1560             x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.i_ref );
1561             for( i = 0; i < 4; i++ )
1562             {
1563                 const int x = 2*(i%2);
1564                 const int y = 2*(i/2);
1565
1566                 switch( h->mb.i_sub_partition[i] )
1567                 {
1568                     case D_L0_8x8:
1569                         x264_macroblock_cache_mv( h, x, y, 2, 2, 0, analysis.l0.me8x8[i].mv[0], analysis.l0.me8x8[i].mv[1] );
1570                         break;
1571                     case D_L0_8x4:
1572                         x264_macroblock_cache_mv( h, x, y+0, 2, 1, 0, analysis.l0.me8x4[i][0].mv[0], analysis.l0.me8x4[i][0].mv[1] );
1573                         x264_macroblock_cache_mv( h, x, y+1, 2, 1, 0, analysis.l0.me8x4[i][1].mv[0], analysis.l0.me8x4[i][1].mv[1] );
1574                         break;
1575                     case D_L0_4x8:
1576                         x264_macroblock_cache_mv( h, x+0, y, 1, 2, 0, analysis.l0.me4x8[i][0].mv[0], analysis.l0.me4x8[i][0].mv[1] );
1577                         x264_macroblock_cache_mv( h, x+1, y, 1, 2, 0, analysis.l0.me4x8[i][1].mv[0], analysis.l0.me4x8[i][1].mv[1] );
1578                         break;
1579                     case D_L0_4x4:
1580                         x264_macroblock_cache_mv( h, x+0, y+0, 1, 1, 0, analysis.l0.me4x4[i][0].mv[0], analysis.l0.me4x4[i][0].mv[1] );
1581                         x264_macroblock_cache_mv( h, x+1, y+0, 1, 1, 0, analysis.l0.me4x4[i][1].mv[0], analysis.l0.me4x4[i][1].mv[1] );
1582                         x264_macroblock_cache_mv( h, x+0, y+1, 1, 1, 0, analysis.l0.me4x4[i][2].mv[0], analysis.l0.me4x4[i][2].mv[1] );
1583                         x264_macroblock_cache_mv( h, x+1, y+1, 1, 1, 0, analysis.l0.me4x4[i][3].mv[0], analysis.l0.me4x4[i][3].mv[1] );
1584                         break;
1585                     default:
1586                         fprintf( stderr, "internal error\n" );
1587                         break;
1588                 }
1589             }
1590             break;
1591
1592         case P_SKIP:
1593         {
1594             int mvp[2];
1595             x264_mb_predict_mv_pskip( h, mvp );
1596             /* */
1597             h->mb.i_partition = D_16x16;
1598             x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, 0 );
1599             x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, mvp[0], mvp[1] );
1600             break;
1601         }
1602
1603         case B_SKIP:
1604             /* nothing has changed since x264_macroblock_probe_bskip */
1605             break;
1606         case B_DIRECT:
1607             x264_mb_load_mv_direct8x8( h, 0 );
1608             x264_mb_load_mv_direct8x8( h, 1 );
1609             x264_mb_load_mv_direct8x8( h, 2 );
1610             x264_mb_load_mv_direct8x8( h, 3 );
1611             break;
1612
1613         case B_8x8:
1614             /* optimize: cache might not need to be rewritten */
1615             for( i = 0; i < 4; i++ )
1616                 x264_mb_cache_mv_b8x8( h, &analysis, i, 1 );
1617             break;
1618
1619         default: /* the rest of the B types */
1620             switch( h->mb.i_partition )
1621             {
1622             case D_16x16:
1623                 switch( h->mb.i_type )
1624                 {
1625                 case B_L0_L0:
1626                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.i_ref );
1627                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.mv[0], analysis.l0.me16x16.mv[1] );
1628
1629                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, -1 );
1630                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 1,  0, 0 );
1631                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 1,  0, 0 );
1632                     break;
1633                 case B_L1_L1:
1634                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, -1 );
1635                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0,  0, 0 );
1636                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 0,  0, 0 );
1637
1638                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, analysis.l1.i_ref );
1639                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 1, analysis.l1.me16x16.mv[0], analysis.l1.me16x16.mv[1] );
1640                     break;
1641                 case B_BI_BI:
1642                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.i_ref );
1643                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.mv[0], analysis.l0.me16x16.mv[1] );
1644
1645                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, analysis.l1.i_ref );
1646                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 1, analysis.l1.me16x16.mv[0], analysis.l1.me16x16.mv[1] );
1647                     break;
1648                 }
1649                 break;
1650             case D_16x8:
1651                 x264_mb_cache_mv_b16x8( h, &analysis, 0, 1 );
1652                 x264_mb_cache_mv_b16x8( h, &analysis, 1, 1 );
1653                 break;
1654             case D_8x16:
1655                 x264_mb_cache_mv_b8x16( h, &analysis, 0, 1 );
1656                 x264_mb_cache_mv_b8x16( h, &analysis, 1, 1 );
1657                 break;
1658             default:
1659                 fprintf( stderr, "internal error (invalid MB type)\n" );
1660                 break;
1661             }
1662     }
1663 }
1664