* all: Patches by Loren Merritt:
[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 "../core/common.h"
31 #include "../core/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
95 } x264_mb_analysis_t;
96
97 static const int i_qp0_cost_table[52] = {
98    1, 1, 1, 1, 1, 1, 1, 1,  /*  0-7 */
99    1, 1, 1, 1,              /*  8-11 */
100    1, 1, 1, 1, 2, 2, 2, 2,  /* 12-19 */
101    3, 3, 3, 4, 4, 4, 5, 6,  /* 20-27 */
102    6, 7, 8, 9,10,11,13,14,  /* 28-35 */
103   16,18,20,23,25,29,32,36,  /* 36-43 */
104   40,45,51,57,64,72,81,91   /* 44-51 */
105 };
106
107 static const uint8_t block_idx_x[16] = {
108     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
109 };
110 static const uint8_t block_idx_y[16] = {
111     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
112 };
113
114 static void x264_mb_analyse_init( x264_t *h, x264_mb_analysis_t *a, int i_qp )
115 {
116     memset( a, 0, sizeof( x264_mb_analysis_t ) );
117
118     /* conduct the analysis using this lamda and QP */
119     a->i_qp = i_qp;
120     a->i_lambda = i_qp0_cost_table[i_qp];
121
122     /* I: Intra part */
123     a->i_sad_i16x16 = -1;
124     a->i_sad_i4x4   = -1;
125     a->i_sad_i8x8   = -1;
126
127     /* II: Inter part P/B frame */
128     if( h->sh.i_type != SLICE_TYPE_I )
129     {
130         int dmb;
131         int i;
132
133         /* Calculate max start MV range */
134         dmb = h->mb.i_mb_x;
135         if( h->mb.i_mb_y < dmb )
136             dmb = h->mb.i_mb_y;
137         if( h->sps->i_mb_width - h->mb.i_mb_x < dmb )
138             dmb = h->sps->i_mb_width - h->mb.i_mb_x;
139         if( h->sps->i_mb_height - h->mb.i_mb_y < dmb )
140             dmb = h->sps->i_mb_height - h->mb.i_mb_y;
141
142         a->i_mv_range = 16*dmb + 8;
143
144         a->l0.me16x16.cost = -1;
145         a->l0.i_cost8x8    = -1;
146
147         for( i = 0; i < 4; i++ )
148         {
149             a->l0.i_cost4x4[i] = -1;
150             a->l0.i_cost8x4[i] = -1;
151             a->l0.i_cost4x8[i] = -1;
152         }
153
154         a->l0.i_cost16x8   = -1;
155         a->l0.i_cost8x16   = -1;
156         if( h->sh.i_type == SLICE_TYPE_B )
157         {
158             a->l1.me16x16.cost = -1;
159             a->l1.i_cost8x8    = -1;
160
161             for( i = 0; i < 4; i++ )
162             {
163                 a->l1.i_cost4x4[i] = -1;
164                 a->l1.i_cost8x4[i] = -1;
165                 a->l1.i_cost4x8[i] = -1;
166             }
167
168             a->l1.i_cost16x8   = -1;
169             a->l1.i_cost8x16   = -1;
170
171             a->i_cost16x16bi   = -1;
172         }
173     }
174 }
175
176
177
178 /*
179  * Handle intra mb
180  */
181 /* Max = 4 */
182 static void predict_16x16_mode_available( unsigned int i_neighbour, int *mode, int *pi_count )
183 {
184     if( ( i_neighbour & (MB_LEFT|MB_TOP) ) == (MB_LEFT|MB_TOP) )
185     {
186         /* top and left avaible */
187         *mode++ = I_PRED_16x16_V;
188         *mode++ = I_PRED_16x16_H;
189         *mode++ = I_PRED_16x16_DC;
190         *mode++ = I_PRED_16x16_P;
191         *pi_count = 4;
192     }
193     else if( ( i_neighbour & MB_LEFT ) )
194     {
195         /* left available*/
196         *mode++ = I_PRED_16x16_DC_LEFT;
197         *mode++ = I_PRED_16x16_H;
198         *pi_count = 2;
199     }
200     else if( ( i_neighbour & MB_TOP ) )
201     {
202         /* top available*/
203         *mode++ = I_PRED_16x16_DC_TOP;
204         *mode++ = I_PRED_16x16_V;
205         *pi_count = 2;
206     }
207     else
208     {
209         /* none avaible */
210         *mode = I_PRED_16x16_DC_128;
211         *pi_count = 1;
212     }
213 }
214
215 /* Max = 4 */
216 static void predict_8x8_mode_available( unsigned int i_neighbour, int *mode, int *pi_count )
217 {
218     if( ( i_neighbour & (MB_LEFT|MB_TOP) ) == (MB_LEFT|MB_TOP) )
219     {
220         /* top and left avaible */
221         *mode++ = I_PRED_CHROMA_V;
222         *mode++ = I_PRED_CHROMA_H;
223         *mode++ = I_PRED_CHROMA_DC;
224         *mode++ = I_PRED_CHROMA_P;
225         *pi_count = 4;
226     }
227     else if( ( i_neighbour & MB_LEFT ) )
228     {
229         /* left available*/
230         *mode++ = I_PRED_CHROMA_DC_LEFT;
231         *mode++ = I_PRED_CHROMA_H;
232         *pi_count = 2;
233     }
234     else if( ( i_neighbour & MB_TOP ) )
235     {
236         /* top available*/
237         *mode++ = I_PRED_CHROMA_DC_TOP;
238         *mode++ = I_PRED_CHROMA_V;
239         *pi_count = 2;
240     }
241     else
242     {
243         /* none avaible */
244         *mode = I_PRED_CHROMA_DC_128;
245         *pi_count = 1;
246     }
247 }
248
249 /* MAX = 8 */
250 static void predict_4x4_mode_available( unsigned int i_neighbour, int idx, int *mode, int *pi_count )
251 {
252     int b_a, b_b, b_c;
253     static const unsigned int needmb[16] =
254     {
255         MB_LEFT|MB_TOP, MB_TOP,
256         MB_LEFT,        MB_PRIVATE,
257         MB_TOP,         MB_TOP|MB_TOPRIGHT,
258         0,              MB_PRIVATE,
259         MB_LEFT,        0,
260         MB_LEFT,        MB_PRIVATE,
261         0,              MB_PRIVATE,
262         0,              MB_PRIVATE
263     };
264
265     /* FIXME even when b_c == 0 there is some case where missing pixels
266      * are emulated and thus more mode are available TODO
267      * analysis and encode should be fixed too */
268     b_a = (needmb[idx]&i_neighbour&MB_LEFT) == (needmb[idx]&MB_LEFT);
269     b_b = (needmb[idx]&i_neighbour&MB_TOP) == (needmb[idx]&MB_TOP);
270     b_c = (needmb[idx]&i_neighbour&(MB_TOPRIGHT|MB_PRIVATE)) == (needmb[idx]&(MB_TOPRIGHT|MB_PRIVATE));
271
272     if( b_a && b_b )
273     {
274         *mode++ = I_PRED_4x4_DC;
275         *mode++ = I_PRED_4x4_H;
276         *mode++ = I_PRED_4x4_V;
277         *mode++ = I_PRED_4x4_DDR;
278         *mode++ = I_PRED_4x4_VR;
279         *mode++ = I_PRED_4x4_HD;
280         *mode++ = I_PRED_4x4_HU;
281
282         *pi_count = 7;
283
284         if( b_c )
285         {
286             *mode++ = I_PRED_4x4_DDL;
287             *mode++ = I_PRED_4x4_VL;
288             (*pi_count) += 2;
289         }
290     }
291     else if( b_a && !b_b )
292     {
293         *mode++ = I_PRED_4x4_DC_LEFT;
294         *mode++ = I_PRED_4x4_H;
295         *pi_count = 2;
296     }
297     else if( !b_a && b_b )
298     {
299         *mode++ = I_PRED_4x4_DC_TOP;
300         *mode++ = I_PRED_4x4_V;
301         *pi_count = 2;
302     }
303     else
304     {
305         *mode++ = I_PRED_4x4_DC_128;
306         *pi_count = 1;
307     }
308 }
309
310 static void x264_mb_analyse_intra( x264_t *h, x264_mb_analysis_t *res )
311 {
312     const unsigned int flags = h->sh.i_type == SLICE_TYPE_I ? h->param.analyse.intra : h->param.analyse.inter;
313     const int i_stride = h->mb.pic.i_stride[0];
314     uint8_t  *p_src = h->mb.pic.p_fenc[0];
315     uint8_t  *p_dst = h->mb.pic.p_fdec[0];
316
317     int i, idx;
318
319     int i_max;
320     int predict_mode[9];
321
322     /*---------------- Try all mode and calculate their score ---------------*/
323
324     /* 16x16 prediction selection */
325     predict_16x16_mode_available( h->mb.i_neighbour, predict_mode, &i_max );
326     for( i = 0; i < i_max; i++ )
327     {
328         int i_sad;
329         int i_mode;
330
331         i_mode = predict_mode[i];
332
333         /* we do the prediction */
334         h->predict_16x16[i_mode]( p_dst, i_stride );
335
336         /* we calculate the diff and get the square sum of the diff */
337         i_sad = h->pixf.satd[PIXEL_16x16]( p_dst, i_stride, p_src, i_stride ) +
338                 res->i_lambda * bs_size_ue( x264_mb_pred_mode16x16_fix[i_mode] );
339         /* if i_score is lower it is better */
340         if( res->i_sad_i16x16 == -1 || res->i_sad_i16x16 > i_sad )
341         {
342             res->i_predict16x16 = i_mode;
343             res->i_sad_i16x16     = i_sad;
344         }
345     }
346
347     /* 4x4 prediction selection */
348     if( flags & X264_ANALYSE_I4x4 )
349     {
350         res->i_sad_i4x4 = 0;
351         for( idx = 0; idx < 16; idx++ )
352         {
353             uint8_t *p_src_by;
354             uint8_t *p_dst_by;
355             int     i_best;
356             int x, y;
357             int i_pred_mode;
358
359             i_pred_mode= x264_mb_predict_intra4x4_mode( h, idx );
360             x = block_idx_x[idx];
361             y = block_idx_y[idx];
362
363             p_src_by = p_src + 4 * x + 4 * y * i_stride;
364             p_dst_by = p_dst + 4 * x + 4 * y * i_stride;
365
366             i_best = -1;
367             predict_4x4_mode_available( h->mb.i_neighbour, idx, predict_mode, &i_max );
368             for( i = 0; i < i_max; i++ )
369             {
370                 int i_sad;
371                 int i_mode;
372
373                 i_mode = predict_mode[i];
374
375                 /* we do the prediction */
376                 h->predict_4x4[i_mode]( p_dst_by, i_stride );
377
378                 /* we calculate diff and get the square sum of the diff */
379                 i_sad = h->pixf.satd[PIXEL_4x4]( p_dst_by, i_stride,
380                                                  p_src_by, i_stride );
381
382                 i_sad += res->i_lambda * (i_pred_mode == x264_mb_pred_mode4x4_fix[i_mode] ? 1 : 4);
383
384                 /* if i_score is lower it is better */
385                 if( i_best == -1 || i_best > i_sad )
386                 {
387                     res->i_predict4x4[x][y] = i_mode;
388                     i_best = i_sad;
389                 }
390             }
391             res->i_sad_i4x4 += i_best;
392
393             /* we need to encode this mb now (for next ones) */
394             h->predict_4x4[res->i_predict4x4[x][y]]( p_dst_by, i_stride );
395             x264_mb_encode_i4x4( h, idx, res->i_qp );
396
397             /* we need to store the 'fixed' version */
398             h->mb.cache.intra4x4_pred_mode[x264_scan8[idx]] =
399                 x264_mb_pred_mode4x4_fix[res->i_predict4x4[x][y]];
400         }
401         res->i_sad_i4x4 += res->i_lambda * 24;    /* from JVT (SATD0) */
402     }
403 }
404
405 static void x264_mb_analyse_intra_chroma( x264_t *h, x264_mb_analysis_t *res )
406 {
407     int i;
408
409     int i_max;
410     int predict_mode[9];
411
412     uint8_t *p_dstc[2], *p_srcc[2];
413     int      i_stride[2];
414
415     /* 8x8 prediction selection for chroma */
416     p_dstc[0] = h->mb.pic.p_fdec[1];
417     p_dstc[1] = h->mb.pic.p_fdec[2];
418     p_srcc[0] = h->mb.pic.p_fenc[1];
419     p_srcc[1] = h->mb.pic.p_fenc[2];
420
421     i_stride[0] = h->mb.pic.i_stride[1];
422     i_stride[1] = h->mb.pic.i_stride[2];
423
424     predict_8x8_mode_available( h->mb.i_neighbour, predict_mode, &i_max );
425     res->i_sad_i8x8 = -1;
426     for( i = 0; i < i_max; i++ )
427     {
428         int i_sad;
429         int i_mode;
430
431         i_mode = predict_mode[i];
432
433         /* we do the prediction */
434         h->predict_8x8[i_mode]( p_dstc[0], i_stride[0] );
435         h->predict_8x8[i_mode]( p_dstc[1], i_stride[1] );
436
437         /* we calculate the cost */
438         i_sad = h->pixf.satd[PIXEL_8x8]( p_dstc[0], i_stride[0],
439                                          p_srcc[0], i_stride[0] ) +
440                 h->pixf.satd[PIXEL_8x8]( p_dstc[1], i_stride[1],
441                                          p_srcc[1], i_stride[1] ) +
442                 res->i_lambda * bs_size_ue( x264_mb_pred_mode8x8_fix[i_mode] );
443
444         /* if i_score is lower it is better */
445         if( res->i_sad_i8x8 == -1 || res->i_sad_i8x8 > i_sad )
446         {
447             res->i_predict8x8 = i_mode;
448             res->i_sad_i8x8     = i_sad;
449         }
450     }
451 }
452
453 static void x264_mb_analyse_inter_p16x16( x264_t *h, x264_mb_analysis_t *a )
454 {
455     x264_me_t m;
456     int i_ref;
457
458     /* 16x16 Search on all ref frame */
459     m.i_pixel = PIXEL_16x16;
460     m.lm      = a->i_lambda;
461     m.p_fenc  = h->mb.pic.p_fenc[0];
462     m.i_stride= h->mb.pic.i_stride[0];
463     m.i_mv_range = a->i_mv_range;
464     m.b_mvc   = 0;
465 //    m.mvc[0]  = 0;
466 //    m.mvc[1]  = 0;
467
468     a->l0.me16x16.cost = INT_MAX;
469     for( i_ref = 0; i_ref < h->i_ref0; i_ref++ )
470     {
471         /* search with ref */
472         m.p_fref = h->mb.pic.p_fref[0][i_ref][0];
473         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
474         x264_me_search( h, &m );
475
476         /* add ref cost */
477         m.cost += m.lm * bs_size_te( h->sh.i_num_ref_idx_l0_active - 1, i_ref );
478
479         if( m.cost < a->l0.me16x16.cost )
480         {
481             a->l0.i_ref = i_ref;
482             a->l0.me16x16 = m;
483         }
484     }
485
486     /* subtract ref cost, so we don't have to add it for the other P types */
487     a->l0.me16x16.cost -= m.lm * bs_size_te( h->sh.i_num_ref_idx_l0_active - 1, a->l0.i_ref );
488
489     /* Set global ref, needed for all others modes */
490     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
491 }
492
493 static void x264_mb_analyse_inter_p8x8( x264_t *h, x264_mb_analysis_t *a )
494 {
495     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
496     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
497
498     int i;
499
500     /* XXX Needed for x264_mb_predict_mv */
501     h->mb.i_partition = D_8x8;
502
503     for( i = 0; i < 4; i++ )
504     {
505         x264_me_t *m = &a->l0.me8x8[i];
506         const int x8 = i%2;
507         const int y8 = i/2;
508
509         m->i_pixel = PIXEL_8x8;
510         m->lm      = a->i_lambda;
511
512         m->p_fenc = &p_fenc[8*(y8*h->mb.pic.i_stride[0]+x8)];
513         m->p_fref = &p_fref[8*(y8*h->mb.pic.i_stride[0]+x8)];
514         m->i_stride= h->mb.pic.i_stride[0];
515         m->i_mv_range = a->i_mv_range;
516
517         if( i == 0 )
518         {
519             m->b_mvc   = 1;
520             m->mvc[0] = a->l0.me16x16.mv[0];
521             m->mvc[1] = a->l0.me16x16.mv[1];
522         }
523         else
524         {
525             m->b_mvc   = 0;
526         }
527
528         x264_mb_predict_mv( h, 0, 4*i, 2, m->mvp );
529         x264_me_search( h, m );
530
531         x264_macroblock_cache_mv( h, 2*x8, 2*y8, 2, 2, 0, m->mv[0], m->mv[1] );
532     }
533
534     a->l0.i_cost8x8 = a->l0.me8x8[0].cost + a->l0.me8x8[1].cost +
535                    a->l0.me8x8[2].cost + a->l0.me8x8[3].cost;
536 }
537
538 static void x264_mb_analyse_inter_p16x8( 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
543     int i;
544
545     /* XXX Needed for x264_mb_predict_mv */
546     h->mb.i_partition = D_16x8;
547
548     for( i = 0; i < 2; i++ )
549     {
550         x264_me_t *m = &a->l0.me16x8[i];
551
552         m->i_pixel = PIXEL_16x8;
553         m->lm      = a->i_lambda;
554
555         m->p_fenc = &p_fenc[8*i*h->mb.pic.i_stride[0]];
556         m->p_fref = &p_fref[8*i*h->mb.pic.i_stride[0]];
557         m->i_stride= h->mb.pic.i_stride[0];
558         m->i_mv_range = a->i_mv_range;
559
560         m->b_mvc   = 1;
561         m->mvc[0] = a->l0.me8x8[2*i].mv[0];
562         m->mvc[1] = a->l0.me8x8[2*i].mv[1];
563
564         x264_mb_predict_mv( h, 0, 8*i, 4, m->mvp );
565         x264_me_search( h, m );
566
567         x264_macroblock_cache_mv( h, 0, 2*i, 4, 2, 0, m->mv[0], m->mv[1] );
568     }
569
570     a->l0.i_cost16x8 = a->l0.me16x8[0].cost + a->l0.me16x8[1].cost;
571 }
572
573 static void x264_mb_analyse_inter_p8x16( x264_t *h, x264_mb_analysis_t *a )
574 {
575     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
576     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
577
578     int i;
579
580     /* XXX Needed for x264_mb_predict_mv */
581     h->mb.i_partition = D_8x16;
582
583     for( i = 0; i < 2; i++ )
584     {
585         x264_me_t *m = &a->l0.me8x16[i];
586
587         m->i_pixel = PIXEL_8x16;
588         m->lm      = a->i_lambda;
589
590         m->p_fenc  = &p_fenc[8*i];
591         m->p_fref  = &p_fref[8*i];
592         m->i_stride= h->mb.pic.i_stride[0];
593         m->i_mv_range = a->i_mv_range;
594
595         m->b_mvc   = 1;
596         m->mvc[0] = a->l0.me8x8[i].mv[0];
597         m->mvc[1] = a->l0.me8x8[i].mv[1];
598
599         x264_mb_predict_mv( h, 0, 4*i, 2, m->mvp );
600         x264_me_search( h, m );
601
602         x264_macroblock_cache_mv( h, 2*i, 0, 2, 4, 0, m->mv[0], m->mv[1] );
603     }
604
605     a->l0.i_cost8x16 = a->l0.me8x16[0].cost + a->l0.me8x16[1].cost;
606 }
607
608 static void x264_mb_analyse_inter_p4x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
609 {
610     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
611     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
612
613     int i4x4;
614
615     /* XXX Needed for x264_mb_predict_mv */
616     h->mb.i_partition = D_8x8;
617
618     for( i4x4 = 0; i4x4 < 4; i4x4++ )
619     {
620         const int idx = 4*i8x8 + i4x4;
621         const int x4 = block_idx_x[idx];
622         const int y4 = block_idx_y[idx];
623
624         x264_me_t *m = &a->l0.me4x4[i8x8][i4x4];
625
626         m->i_pixel = PIXEL_4x4;
627         m->lm      = a->i_lambda;
628
629         m->p_fenc  = &p_fenc[4*(y4*h->mb.pic.i_stride[0]+x4)];
630         m->p_fref  = &p_fref[4*(y4*h->mb.pic.i_stride[0]+x4)];
631         m->i_stride= h->mb.pic.i_stride[0];
632         m->i_mv_range = a->i_mv_range;
633
634         if( i4x4 == 0 )
635         {
636             m->b_mvc   = 1;
637             m->mvc[0] = a->l0.me8x8[i8x8].mv[0];
638             m->mvc[1] = a->l0.me8x8[i8x8].mv[1];
639         }
640         else
641         {
642             m->b_mvc   = 0;
643         }
644
645         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
646         x264_me_search( h, m );
647
648         x264_macroblock_cache_mv( h, x4, y4, 1, 1, 0, m->mv[0], m->mv[1] );
649     }
650
651     a->l0.i_cost4x4[i8x8] = a->l0.me4x4[i8x8][0].cost +
652                          a->l0.me4x4[i8x8][1].cost +
653                          a->l0.me4x4[i8x8][2].cost +
654                          a->l0.me4x4[i8x8][3].cost;
655 }
656
657 static void x264_mb_analyse_inter_p8x4( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
658 {
659     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
660     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
661
662     int i8x4;
663
664     /* XXX Needed for x264_mb_predict_mv */
665     h->mb.i_partition = D_8x8;
666
667     for( i8x4 = 0; i8x4 < 2; i8x4++ )
668     {
669         const int idx = 4*i8x8 + 2*i8x4;
670         const int x4 = block_idx_x[idx];
671         const int y4 = block_idx_y[idx];
672
673         x264_me_t *m = &a->l0.me8x4[i8x8][i8x4];
674
675         m->i_pixel = PIXEL_8x4;
676         m->lm      = a->i_lambda;
677
678         m->p_fenc  = &p_fenc[4*(y4*h->mb.pic.i_stride[0]+x4)];
679         m->p_fref  = &p_fref[4*(y4*h->mb.pic.i_stride[0]+x4)];
680         m->i_stride= h->mb.pic.i_stride[0];
681         m->i_mv_range = a->i_mv_range;
682
683         if( i8x4 == 0 )
684         {
685             m->b_mvc   = 1;
686             m->mvc[0] = a->l0.me4x4[i8x8][0].mv[0];
687             m->mvc[1] = a->l0.me4x4[i8x8][0].mv[1];
688         }
689         else
690         {
691             m->b_mvc   = 0;
692         }
693
694         x264_mb_predict_mv( h, 0, idx, 2, m->mvp );
695         x264_me_search( h, m );
696
697         x264_macroblock_cache_mv( h, x4, y4, 2, 1, 0, m->mv[0], m->mv[1] );
698     }
699
700     a->l0.i_cost8x4[i8x8] = a->l0.me8x4[i8x8][0].cost + a->l0.me8x4[i8x8][1].cost;
701 }
702
703 static void x264_mb_analyse_inter_p4x8( x264_t *h, x264_mb_analysis_t *a, int i8x8 )
704 {
705     uint8_t  *p_fref = h->mb.pic.p_fref[0][a->l0.i_ref][0];
706     uint8_t  *p_fenc = h->mb.pic.p_fenc[0];
707
708     int i4x8;
709
710     /* XXX Needed for x264_mb_predict_mv */
711     h->mb.i_partition = D_8x8;
712
713     for( i4x8 = 0; i4x8 < 2; i4x8++ )
714     {
715         const int idx = 4*i8x8 + i4x8;
716         const int x4 = block_idx_x[idx];
717         const int y4 = block_idx_y[idx];
718
719         x264_me_t *m = &a->l0.me4x8[i8x8][i4x8];
720
721         m->i_pixel = PIXEL_4x8;
722         m->lm      = a->i_lambda;
723
724         m->p_fenc  = &p_fenc[4*(y4*h->mb.pic.i_stride[0]+x4)];
725         m->p_fref  = &p_fref[4*(y4*h->mb.pic.i_stride[0]+x4)];
726         m->i_stride= h->mb.pic.i_stride[0];
727         m->i_mv_range = a->i_mv_range;
728
729         if( i4x8 == 0 )
730         {
731             m->b_mvc   = 1;
732             m->mvc[0] = a->l0.me4x4[i8x8][0].mv[0];
733             m->mvc[1] = a->l0.me4x4[i8x8][0].mv[1];
734         }
735         else
736         {
737             m->b_mvc   = 0;
738         }
739
740         x264_mb_predict_mv( h, 0, idx, 1, m->mvp );
741         x264_me_search( h, m );
742
743         x264_macroblock_cache_mv( h, x4, y4, 1, 2, 0, m->mv[0], m->mv[1] );
744     }
745
746     a->l0.i_cost4x8[i8x8] = a->l0.me4x8[i8x8][0].cost + a->l0.me4x8[i8x8][1].cost;
747 }
748
749
750 static void x264_mb_analyse_inter_b16x16( x264_t *h, x264_mb_analysis_t *a )
751 {
752     uint8_t pix1[16*16], pix2[16*16];
753
754     x264_me_t m;
755     int i_ref;
756
757     /* 16x16 Search on all ref frame */
758     m.i_pixel = PIXEL_16x16;
759     m.lm      = a->i_lambda;
760     m.p_fenc  = h->mb.pic.p_fenc[0];
761     m.i_stride= h->mb.pic.i_stride[0];
762     m.b_mvc   = 0;
763     m.i_mv_range = a->i_mv_range;
764
765     /* ME for List 0 */
766     a->l0.me16x16.cost = INT_MAX;
767     for( i_ref = 0; i_ref < h->i_ref0; i_ref++ )
768     {
769         /* search with ref */
770         m.p_fref = h->mb.pic.p_fref[0][i_ref][0];
771         x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );
772         x264_me_search( h, &m );
773
774         /* add ref cost */
775         m.cost += m.lm * bs_size_te( h->sh.i_num_ref_idx_l0_active - 1, i_ref );
776
777         if( m.cost < a->l0.me16x16.cost )
778         {
779             a->l0.i_ref = i_ref;
780             a->l0.me16x16 = m;
781         }
782     }
783
784     /* ME for list 1 */
785     a->l1.me16x16.cost = INT_MAX;
786     for( i_ref = 0; i_ref < h->i_ref1; i_ref++ )
787     {
788         /* search with ref */
789         m.p_fref = h->mb.pic.p_fref[1][i_ref][0];
790         x264_mb_predict_mv_16x16( h, 1, i_ref, m.mvp );
791         x264_me_search( h, &m );
792
793         /* add ref cost */
794         m.cost += m.lm * bs_size_te( h->sh.i_num_ref_idx_l1_active - 1, i_ref );
795
796         if( m.cost < a->l1.me16x16.cost )
797         {
798             a->l1.i_ref = i_ref;
799             a->l1.me16x16 = m;
800         }
801     }
802
803     /* Set global ref, needed for all others modes FIXME some work for mixed block mode */
804     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, a->l0.i_ref );
805     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, a->l1.i_ref );
806
807     /* get cost of BI mode */
808     h->mc[MC_LUMA]( h->mb.pic.p_fref[0][a->l0.i_ref][0], h->mb.pic.i_stride[0],
809                     pix1, 16,
810                     a->l0.me16x16.mv[0], a->l0.me16x16.mv[1],
811                     16, 16 );
812     h->mc[MC_LUMA]( h->mb.pic.p_fref[1][a->l1.i_ref][0], h->mb.pic.i_stride[0],
813                     pix2, 16,
814                     a->l1.me16x16.mv[0], a->l1.me16x16.mv[1],
815                     16, 16 );
816     h->pixf.avg[PIXEL_16x16]( pix1, 16, pix2, 16 );
817
818     a->i_cost16x16bi = h->pixf.satd[PIXEL_16x16]( h->mb.pic.p_fenc[0], h->mb.pic.i_stride[0], pix1, 16 ) +
819                        a->i_lambda * ( bs_size_te( h->sh.i_num_ref_idx_l0_active - 1, a->l0.i_ref ) +
820                                        bs_size_te( h->sh.i_num_ref_idx_l1_active - 1, a->l1.i_ref ) +
821                                        bs_size_se( a->l0.me16x16.mv[0] - a->l0.me16x16.mvp[0] ) +
822                                        bs_size_se( a->l0.me16x16.mv[1] - a->l0.me16x16.mvp[1] ) +
823                                        bs_size_se( a->l1.me16x16.mv[0] - a->l1.me16x16.mvp[0] ) +
824                                        bs_size_se( a->l1.me16x16.mv[1] - a->l1.me16x16.mvp[1] ) );
825 }
826
827 /*****************************************************************************
828  * x264_macroblock_analyse:
829  *****************************************************************************/
830 void x264_macroblock_analyse( x264_t *h )
831 {
832     x264_mb_analysis_t analysis;
833     int i;
834
835     h->mb.qp[h->mb.i_mb_xy] = x264_ratecontrol_qp(h);
836
837     /* FIXME check if it's 12 */
838     if( h->mb.qp[h->mb.i_mb_xy] - h->mb.i_last_qp < -12 )
839         h->mb.qp[h->mb.i_mb_xy] = h->mb.i_last_qp - 12;
840     else if( h->mb.qp[h->mb.i_mb_xy] - h->mb.i_last_qp > 12 )
841         h->mb.qp[h->mb.i_mb_xy] = h->mb.i_last_qp + 12;
842
843     /* init analysis */
844     x264_mb_analyse_init( h, &analysis, h->mb.qp[h->mb.i_mb_xy] );
845
846     /*--------------------------- Do the analysis ---------------------------*/
847     if( h->sh.i_type == SLICE_TYPE_I )
848     {
849         x264_mb_analyse_intra( h, &analysis );
850
851         if( analysis.i_sad_i4x4 >= 0 &&  analysis.i_sad_i4x4 < analysis.i_sad_i16x16 )
852             h->mb.i_type = I_4x4;
853         else
854             h->mb.i_type = I_16x16;
855     }
856     else if( h->sh.i_type == SLICE_TYPE_P )
857     {
858         const unsigned int i_neighbour = h->mb.i_neighbour;
859
860         int b_skip = 0;
861         int i_cost;
862
863         /* Fast P_SKIP detection */
864         if( ( (i_neighbour&MB_LEFT) && h->mb.type[h->mb.i_mb_xy - 1] == P_SKIP ) ||
865             ( (i_neighbour&MB_TOP) && h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride] == P_SKIP ) ||
866             ( ((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 ) ||
867             ( (i_neighbour&MB_TOPRIGHT) && h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride+1 ] == P_SKIP ) )
868         {
869             b_skip = x264_macroblock_probe_pskip( h );
870         }
871
872         if( b_skip )
873         {
874             h->mb.i_type = P_SKIP;
875             h->mb.i_partition = D_16x16;
876         }
877         else
878         {
879             const unsigned int flags = h->param.analyse.inter;
880             int i_type;
881             int i_partition;
882
883             x264_mb_analyse_inter_p16x16( h, &analysis );
884             if( flags & X264_ANALYSE_PSUB16x16 )
885                 x264_mb_analyse_inter_p8x8( h, &analysis );
886
887             /* Select best inter mode */
888             i_type = P_L0;
889             i_partition = D_16x16;
890             i_cost = analysis.l0.me16x16.cost;
891
892             if( ( flags & X264_ANALYSE_PSUB16x16 ) &&
893                 analysis.l0.i_cost8x8 < analysis.l0.me16x16.cost )
894             {
895                 int i;
896
897                 i_type = P_8x8;
898                 i_partition = D_8x8;
899                 h->mb.i_sub_partition[0] = D_L0_8x8;
900                 h->mb.i_sub_partition[1] = D_L0_8x8;
901                 h->mb.i_sub_partition[2] = D_L0_8x8;
902                 h->mb.i_sub_partition[3] = D_L0_8x8;
903
904                 i_cost = analysis.l0.i_cost8x8;
905
906                 /* Do sub 8x8 */
907                 if( flags & X264_ANALYSE_PSUB8x8 )
908                 {
909                     for( i = 0; i < 4; i++ )
910                     {
911                         x264_mb_analyse_inter_p4x4( h, &analysis, i );
912                         if( analysis.l0.i_cost4x4[i] < analysis.l0.me8x8[i].cost )
913                         {
914                             int i_cost8x8;
915
916                             h->mb.i_sub_partition[i] = D_L0_4x4;
917                             i_cost8x8 = analysis.l0.i_cost4x4[i];
918
919                             x264_mb_analyse_inter_p8x4( h, &analysis, i );
920                             if( analysis.l0.i_cost8x4[i] < analysis.l0.i_cost4x4[i] )
921                             {
922                                 h->mb.i_sub_partition[i] = D_L0_8x4;
923                                 i_cost8x8 = analysis.l0.i_cost8x4[i];
924                             }
925
926                             x264_mb_analyse_inter_p4x8( h, &analysis, i );
927                             if( analysis.l0.i_cost4x8[i] < analysis.l0.i_cost4x4[i] )
928                             {
929                                 h->mb.i_sub_partition[i] = D_L0_4x8;
930                                 i_cost8x8 = analysis.l0.i_cost4x8[i];
931                             }
932
933                             i_cost += i_cost8x8 - analysis.l0.me8x8[i].cost;
934                         }
935                     }
936                 }
937
938                 /* Now do sub 16x8/8x16 */
939                 x264_mb_analyse_inter_p16x8( h, &analysis );
940                 if( analysis.l0.i_cost16x8 < i_cost )
941                 {
942                     i_type = P_L0;
943                     i_partition = D_16x8;
944                     i_cost = analysis.l0.i_cost16x8;
945                 }
946
947                 x264_mb_analyse_inter_p8x16( h, &analysis );
948                 if( analysis.l0.i_cost8x16 < i_cost )
949                 {
950                     i_type = P_L0;
951                     i_partition = D_8x16;
952                     i_cost = analysis.l0.i_cost8x16;
953                 }
954             }
955
956             h->mb.i_type = i_type;
957             h->mb.i_partition = i_partition;
958
959             /* refine qpel */
960             if( h->mb.i_partition == D_16x16 )
961             {
962                 x264_me_refine_qpel( h, &analysis.l0.me16x16 );
963                 i_cost = analysis.l0.me16x16.cost;
964             }
965             else if( h->mb.i_partition == D_16x8 )
966             {
967                 x264_me_refine_qpel( h, &analysis.l0.me16x8[0] );
968                 x264_me_refine_qpel( h, &analysis.l0.me16x8[1] );
969                 i_cost = analysis.l0.me16x8[0].cost + analysis.l0.me16x8[1].cost;
970             }
971             else if( h->mb.i_partition == D_8x16 )
972             {
973                 x264_me_refine_qpel( h, &analysis.l0.me8x16[0] );
974                 x264_me_refine_qpel( h, &analysis.l0.me8x16[1] );
975                 i_cost = analysis.l0.me8x16[0].cost + analysis.l0.me8x16[1].cost;
976             }
977             else if( h->mb.i_partition == D_8x8 )
978             {
979                 int i8x8;
980                 i_cost = 0;
981                 for( i8x8 = 0; i8x8 < 4; i8x8++ )
982                 {
983                     switch( h->mb.i_sub_partition[i8x8] )
984                     {
985                         case D_L0_8x8:
986                             x264_me_refine_qpel( h, &analysis.l0.me8x8[i8x8] );
987                             i_cost += analysis.l0.me8x8[i8x8].cost;
988                             break;
989                         case D_L0_8x4:
990                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][0] );
991                             x264_me_refine_qpel( h, &analysis.l0.me8x4[i8x8][1] );
992                             i_cost += analysis.l0.me8x4[i8x8][0].cost +
993                                       analysis.l0.me8x4[i8x8][1].cost;
994                             break;
995                         case D_L0_4x8:
996                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][0] );
997                             x264_me_refine_qpel( h, &analysis.l0.me4x8[i8x8][1] );
998                             i_cost += analysis.l0.me4x8[i8x8][0].cost +
999                                       analysis.l0.me4x8[i8x8][1].cost;
1000                             break;
1001
1002                         case D_L0_4x4:
1003                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][0] );
1004                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][1] );
1005                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][2] );
1006                             x264_me_refine_qpel( h, &analysis.l0.me4x4[i8x8][3] );
1007                             i_cost += analysis.l0.me4x4[i8x8][0].cost +
1008                                       analysis.l0.me4x4[i8x8][1].cost +
1009                                       analysis.l0.me4x4[i8x8][2].cost +
1010                                       analysis.l0.me4x4[i8x8][3].cost;
1011                             break;
1012                         default:
1013                             fprintf( stderr, "internal error (!8x8 && !4x4)" );
1014                             break;
1015                     }
1016                 }
1017             }
1018
1019             x264_mb_analyse_intra( h, &analysis );
1020             if( analysis.i_sad_i16x16 >= 0 && analysis.i_sad_i16x16 < i_cost )
1021             {
1022                 h->mb.i_type = I_16x16;
1023                 i_cost = analysis.i_sad_i16x16;
1024             }
1025
1026             if( analysis.i_sad_i4x4 >=0 && analysis.i_sad_i4x4 < i_cost )
1027             {
1028                 h->mb.i_type = I_4x4;
1029                 i_cost = analysis.i_sad_i4x4;
1030             }
1031         }
1032     }
1033     else if( h->sh.i_type == SLICE_TYPE_B )
1034     {
1035         int i_cost;
1036
1037         /* best inter mode */
1038         x264_mb_analyse_inter_b16x16( h, &analysis );
1039         h->mb.i_type = B_L0_L0;
1040         h->mb.i_partition = D_16x16;
1041         i_cost = analysis.l0.me16x16.cost;
1042
1043         if( analysis.l1.me16x16.cost < i_cost )
1044         {
1045             h->mb.i_type = B_L1_L1;
1046             i_cost = analysis.l1.me16x16.cost;
1047         }
1048         if( analysis.i_cost16x16bi < i_cost )
1049         {
1050             h->mb.i_type = B_BI_BI;
1051             i_cost = analysis.i_cost16x16bi;
1052         }
1053
1054         /* best intra mode */
1055         x264_mb_analyse_intra( h, &analysis );
1056         if( analysis.i_sad_i16x16 >= 0 && analysis.i_sad_i16x16 < i_cost )
1057         {
1058             h->mb.i_type = I_16x16;
1059             i_cost = analysis.i_sad_i16x16;
1060         }
1061         if( analysis.i_sad_i4x4 >=0 && analysis.i_sad_i4x4 < i_cost )
1062         {
1063             h->mb.i_type = I_4x4;
1064             i_cost = analysis.i_sad_i4x4;
1065         }
1066     }
1067 #undef BEST_TYPE
1068
1069     /*-------------------- Update MB from the analysis ----------------------*/
1070     h->mb.type[h->mb.i_mb_xy] = h->mb.i_type;
1071     switch( h->mb.i_type )
1072     {
1073         case I_4x4:
1074             for( i = 0; i < 16; i++ )
1075             {
1076                 h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] =
1077                     analysis.i_predict4x4[block_idx_x[i]][block_idx_y[i]];
1078             }
1079
1080             x264_mb_analyse_intra_chroma( h, &analysis );
1081             h->mb.i_chroma_pred_mode = analysis.i_predict8x8;
1082             break;
1083         case I_16x16:
1084             h->mb.i_intra16x16_pred_mode = analysis.i_predict16x16;
1085
1086             x264_mb_analyse_intra_chroma( h, &analysis );
1087             h->mb.i_chroma_pred_mode = analysis.i_predict8x8;
1088             break;
1089
1090         case P_L0:
1091             x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.i_ref );
1092             switch( h->mb.i_partition )
1093             {
1094                 case D_16x16:
1095                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.mv[0], analysis.l0.me16x16.mv[1] );
1096                     break;
1097
1098                 case D_16x8:
1099                     x264_macroblock_cache_mv ( h, 0, 0, 4, 2, 0, analysis.l0.me16x8[0].mv[0], analysis.l0.me16x8[0].mv[1] );
1100                     x264_macroblock_cache_mv ( h, 0, 2, 4, 2, 0, analysis.l0.me16x8[1].mv[0], analysis.l0.me16x8[1].mv[1] );
1101                     break;
1102
1103                 case D_8x16:
1104                     x264_macroblock_cache_mv ( h, 0, 0, 2, 4, 0, analysis.l0.me8x16[0].mv[0], analysis.l0.me8x16[0].mv[1] );
1105                     x264_macroblock_cache_mv ( h, 2, 0, 2, 4, 0, analysis.l0.me8x16[1].mv[0], analysis.l0.me8x16[1].mv[1] );
1106                     break;
1107
1108                 default:
1109                     fprintf( stderr, "internal error P_L0 and partition=%d\n", h->mb.i_partition );
1110                     break;
1111             }
1112             break;
1113
1114         case P_8x8:
1115             x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.i_ref );
1116             for( i = 0; i < 4; i++ )
1117             {
1118                 const int x = 2*(i%2);
1119                 const int y = 2*(i/2);
1120
1121                 switch( h->mb.i_sub_partition[i] )
1122                 {
1123                     case D_L0_8x8:
1124                         x264_macroblock_cache_mv( h, x, y, 2, 2, 0, analysis.l0.me8x8[i].mv[0], analysis.l0.me8x8[i].mv[1] );
1125                         break;
1126                     case D_L0_8x4:
1127                         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] );
1128                         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] );
1129                         break;
1130                     case D_L0_4x8:
1131                         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] );
1132                         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] );
1133                         break;
1134                     case D_L0_4x4:
1135                         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] );
1136                         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] );
1137                         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] );
1138                         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] );
1139                         break;
1140                     default:
1141                         fprintf( stderr, "internal error\n" );
1142                         break;
1143                 }
1144             }
1145             break;
1146
1147         case P_SKIP:
1148         {
1149             int mvp[2];
1150             x264_mb_predict_mv_pskip( h, mvp );
1151             /* */
1152             h->mb.i_partition = D_16x16;
1153             x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, 0 );
1154             x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, mvp[0], mvp[1] );
1155             break;
1156         }
1157
1158         case B_L0_L0:
1159             switch( h->mb.i_partition )
1160             {
1161                 case D_16x16:
1162                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.i_ref );
1163                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.mv[0], analysis.l0.me16x16.mv[1] );
1164
1165                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, -1 );
1166                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 1,  0, 0 );
1167                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 1,  0, 0 );
1168                     break;
1169                 default:
1170                     fprintf( stderr, "internal error\n" );
1171                     break;
1172             }
1173             break;
1174         case B_L1_L1:
1175             switch( h->mb.i_partition )
1176             {
1177                 case D_16x16:
1178                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, -1 );
1179                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0,  0, 0 );
1180                     x264_macroblock_cache_mvd( h, 0, 0, 4, 4, 0,  0, 0 );
1181
1182                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, analysis.l1.i_ref );
1183                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 1, analysis.l1.me16x16.mv[0], analysis.l1.me16x16.mv[1] );
1184                     break;
1185
1186                 default:
1187                     fprintf( stderr, "internal error\n" );
1188                     break;
1189             }
1190             break;
1191         case B_BI_BI:
1192             switch( h->mb.i_partition )
1193             {
1194                 case D_16x16:
1195                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, analysis.l0.i_ref );
1196                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 0, analysis.l0.me16x16.mv[0], analysis.l0.me16x16.mv[1] );
1197
1198                     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, analysis.l1.i_ref );
1199                     x264_macroblock_cache_mv ( h, 0, 0, 4, 4, 1, analysis.l1.me16x16.mv[0], analysis.l1.me16x16.mv[1] );
1200                     break;
1201
1202                 default:
1203                     fprintf( stderr, "internal error\n" );
1204                     break;
1205             }
1206             break;
1207
1208         default:
1209             fprintf( stderr, "internal error (invalid MB type)\n" );
1210             break;
1211     }
1212 }
1213