Bump dates to 2014
[x262.git] / common / mvpred.c
1 /*****************************************************************************
2  * mvpred.c: motion vector prediction
3  *****************************************************************************
4  * Copyright (C) 2003-2014 x264 project
5  *
6  * Authors: Loren Merritt <lorenm@u.washington.edu>
7  *          Jason Garrett-Glaser <darkshikari@gmail.com>
8  *          Laurent Aimar <fenrir@via.ecp.fr>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
23  *
24  * This program is also available under a commercial proprietary license.
25  * For more information, contact us at licensing@x264.com.
26  *****************************************************************************/
27
28 #include "common.h"
29
30 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int16_t mvp[2] )
31 {
32     const int i8 = x264_scan8[idx];
33     const int i_ref= h->mb.cache.ref[i_list][i8];
34     int     i_refa = h->mb.cache.ref[i_list][i8 - 1];
35     int16_t *mv_a  = h->mb.cache.mv[i_list][i8 - 1];
36     int     i_refb = h->mb.cache.ref[i_list][i8 - 8];
37     int16_t *mv_b  = h->mb.cache.mv[i_list][i8 - 8];
38     int     i_refc = h->mb.cache.ref[i_list][i8 - 8 + i_width];
39     int16_t *mv_c  = h->mb.cache.mv[i_list][i8 - 8 + i_width];
40
41     // Partitions not yet reached in scan order are unavailable.
42     if( (idx&3) >= 2 + (i_width&1) || i_refc == -2 )
43     {
44         i_refc = h->mb.cache.ref[i_list][i8 - 8 - 1];
45         mv_c   = h->mb.cache.mv[i_list][i8 - 8 - 1];
46
47         if( SLICE_MBAFF
48             && h->mb.cache.ref[i_list][x264_scan8[0]-1] != -2
49             && MB_INTERLACED != h->mb.field[h->mb.i_mb_left_xy[0]] )
50         {
51             if( idx == 2 )
52             {
53                 mv_c = h->mb.cache.topright_mv[i_list][0];
54                 i_refc = h->mb.cache.topright_ref[i_list][0];
55             }
56             else if( idx == 8 )
57             {
58                 mv_c = h->mb.cache.topright_mv[i_list][1];
59                 i_refc = h->mb.cache.topright_ref[i_list][1];
60             }
61             else if( idx == 10 )
62             {
63                 mv_c = h->mb.cache.topright_mv[i_list][2];
64                 i_refc = h->mb.cache.topright_ref[i_list][2];
65             }
66         }
67     }
68     if( h->mb.i_partition == D_16x8 )
69     {
70         if( idx == 0 )
71         {
72             if( i_refb == i_ref )
73             {
74                 CP32( mvp, mv_b );
75                 return;
76             }
77         }
78         else
79         {
80             if( i_refa == i_ref )
81             {
82                 CP32( mvp, mv_a );
83                 return;
84             }
85         }
86     }
87     else if( h->mb.i_partition == D_8x16 )
88     {
89         if( idx == 0 )
90         {
91             if( i_refa == i_ref )
92             {
93                 CP32( mvp, mv_a );
94                 return;
95             }
96         }
97         else
98         {
99             if( i_refc == i_ref )
100             {
101                 CP32( mvp, mv_c );
102                 return;
103             }
104         }
105     }
106
107     int i_count = (i_refa == i_ref) + (i_refb == i_ref) + (i_refc == i_ref);
108
109     if( i_count > 1 )
110     {
111 median:
112         x264_median_mv( mvp, mv_a, mv_b, mv_c );
113     }
114     else if( i_count == 1 )
115     {
116         if( i_refa == i_ref )
117             CP32( mvp, mv_a );
118         else if( i_refb == i_ref )
119             CP32( mvp, mv_b );
120         else
121             CP32( mvp, mv_c );
122     }
123     else if( i_refb == -2 && i_refc == -2 && i_refa != -2 )
124         CP32( mvp, mv_a );
125     else
126         goto median;
127 }
128
129 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int16_t mvp[2] )
130 {
131     int     i_refa = h->mb.cache.ref[i_list][X264_SCAN8_0 - 1];
132     int16_t *mv_a  = h->mb.cache.mv[i_list][X264_SCAN8_0 - 1];
133     int     i_refb = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8];
134     int16_t *mv_b  = h->mb.cache.mv[i_list][X264_SCAN8_0 - 8];
135     int     i_refc = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8 + 4];
136     int16_t *mv_c  = h->mb.cache.mv[i_list][X264_SCAN8_0 - 8 + 4];
137     if( i_refc == -2 )
138     {
139         i_refc = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8 - 1];
140         mv_c   = h->mb.cache.mv[i_list][X264_SCAN8_0 - 8 - 1];
141     }
142
143     int i_count = (i_refa == i_ref) + (i_refb == i_ref) + (i_refc == i_ref);
144
145     if( i_count > 1 )
146     {
147 median:
148         x264_median_mv( mvp, mv_a, mv_b, mv_c );
149     }
150     else if( i_count == 1 )
151     {
152         if( i_refa == i_ref )
153             CP32( mvp, mv_a );
154         else if( i_refb == i_ref )
155             CP32( mvp, mv_b );
156         else
157             CP32( mvp, mv_c );
158     }
159     else if( i_refb == -2 && i_refc == -2 && i_refa != -2 )
160         CP32( mvp, mv_a );
161     else
162         goto median;
163 }
164
165
166 void x264_mb_predict_mv_pskip( x264_t *h, int16_t mv[2] )
167 {
168     int     i_refa = h->mb.cache.ref[0][X264_SCAN8_0 - 1];
169     int     i_refb = h->mb.cache.ref[0][X264_SCAN8_0 - 8];
170     int16_t *mv_a  = h->mb.cache.mv[0][X264_SCAN8_0 - 1];
171     int16_t *mv_b  = h->mb.cache.mv[0][X264_SCAN8_0 - 8];
172
173     if( i_refa == -2 || i_refb == -2 ||
174         !( i_refa | M32( mv_a ) ) ||
175         !( i_refb | M32( mv_b ) ) )
176     {
177         M32( mv ) = 0;
178     }
179     else
180         x264_mb_predict_mv_16x16( h, 0, 0, mv );
181 }
182
183 static int x264_mb_predict_mv_direct16x16_temporal( x264_t *h )
184 {
185     int mb_x = h->mb.i_mb_x;
186     int mb_y = h->mb.i_mb_y;
187     int mb_xy = h->mb.i_mb_xy;
188     int type_col[2] = { h->fref[1][0]->mb_type[mb_xy], h->fref[1][0]->mb_type[mb_xy] };
189     int partition_col[2] = { h->fref[1][0]->mb_partition[mb_xy], h->fref[1][0]->mb_partition[mb_xy] };
190     int preshift = MB_INTERLACED;
191     int postshift = MB_INTERLACED;
192     int offset = 1;
193     int yshift = 1;
194     h->mb.i_partition = partition_col[0];
195     if( PARAM_INTERLACED && h->fref[1][0]->field[mb_xy] != MB_INTERLACED )
196     {
197         if( MB_INTERLACED )
198         {
199             mb_y = h->mb.i_mb_y&~1;
200             mb_xy = mb_x + h->mb.i_mb_stride * mb_y;
201             type_col[0] = h->fref[1][0]->mb_type[mb_xy];
202             type_col[1] = h->fref[1][0]->mb_type[mb_xy + h->mb.i_mb_stride];
203             partition_col[0] = h->fref[1][0]->mb_partition[mb_xy];
204             partition_col[1] = h->fref[1][0]->mb_partition[mb_xy + h->mb.i_mb_stride];
205             preshift = 0;
206             yshift = 0;
207
208             if( (IS_INTRA(type_col[0]) || partition_col[0] == D_16x16) &&
209                 (IS_INTRA(type_col[1]) || partition_col[1] == D_16x16) &&
210                 partition_col[0] != D_8x8 )
211                 h->mb.i_partition = D_16x8;
212             else
213                 h->mb.i_partition = D_8x8;
214         }
215         else
216         {
217             int cur_poc = h->fdec->i_poc + h->fdec->i_delta_poc[MB_INTERLACED&h->mb.i_mb_y&1];
218             int col_parity = abs(h->fref[1][0]->i_poc + h->fref[1][0]->i_delta_poc[0] - cur_poc)
219                           >= abs(h->fref[1][0]->i_poc + h->fref[1][0]->i_delta_poc[1] - cur_poc);
220             mb_y = (h->mb.i_mb_y&~1) + col_parity;
221             mb_xy = mb_x + h->mb.i_mb_stride * mb_y;
222             type_col[0] = type_col[1] = h->fref[1][0]->mb_type[mb_xy];
223             partition_col[0] = partition_col[1] = h->fref[1][0]->mb_partition[mb_xy];
224             preshift = 1;
225             yshift = 2;
226             h->mb.i_partition = partition_col[0];
227         }
228         offset = 0;
229     }
230     int i_mb_4x4 = 16 * h->mb.i_mb_stride * mb_y + 4 * mb_x;
231     int i_mb_8x8 =  4 * h->mb.i_mb_stride * mb_y + 2 * mb_x;
232
233     x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, 0 );
234
235     /* Don't do any checks other than the ones we have to, based
236      * on the size of the colocated partitions.
237      * Depends on the enum order: D_8x8, D_16x8, D_8x16, D_16x16 */
238     int max_i8 = (D_16x16 - h->mb.i_partition) + 1;
239     int step = (h->mb.i_partition == D_16x8) + 1;
240     int width = 4 >> ((D_16x16 - h->mb.i_partition)&1);
241     int height = 4 >> ((D_16x16 - h->mb.i_partition)>>1);
242     for( int i8 = 0; i8 < max_i8; i8 += step )
243     {
244         int x8 = i8&1;
245         int y8 = i8>>1;
246         int ypart = (SLICE_MBAFF && h->fref[1][0]->field[mb_xy] != MB_INTERLACED) ?
247                     MB_INTERLACED ? y8*6 : 2*(h->mb.i_mb_y&1) + y8 :
248                     3*y8;
249
250         if( IS_INTRA( type_col[y8] ) )
251         {
252             x264_macroblock_cache_ref( h, 2*x8, 2*y8, width, height, 0, 0 );
253             x264_macroblock_cache_mv(  h, 2*x8, 2*y8, width, height, 0, 0 );
254             x264_macroblock_cache_mv(  h, 2*x8, 2*y8, width, height, 1, 0 );
255             continue;
256         }
257
258         int i_part_8x8 = i_mb_8x8 + x8 + (ypart>>1) * h->mb.i_b8_stride;
259         int i_ref1_ref = h->fref[1][0]->ref[0][i_part_8x8];
260         int i_ref = (map_col_to_list0(i_ref1_ref>>preshift) << postshift) + (offset&i_ref1_ref&MB_INTERLACED);
261
262         if( i_ref >= 0 )
263         {
264             int dist_scale_factor = h->mb.dist_scale_factor[i_ref][0];
265             int16_t *mv_col = h->fref[1][0]->mv[0][i_mb_4x4 + 3*x8 + ypart * h->mb.i_b4_stride];
266             int16_t mv_y = (mv_col[1]<<yshift)/2;
267             int l0x = ( dist_scale_factor * mv_col[0] + 128 ) >> 8;
268             int l0y = ( dist_scale_factor * mv_y + 128 ) >> 8;
269             if( h->param.i_threads > 1 && (l0y > h->mb.mv_max_spel[1] || l0y-mv_y > h->mb.mv_max_spel[1]) )
270                 return 0;
271             x264_macroblock_cache_ref( h, 2*x8, 2*y8, width, height, 0, i_ref );
272             x264_macroblock_cache_mv( h, 2*x8, 2*y8, width, height, 0, pack16to32_mask(l0x, l0y) );
273             x264_macroblock_cache_mv( h, 2*x8, 2*y8, width, height, 1, pack16to32_mask(l0x-mv_col[0], l0y-mv_y) );
274         }
275         else
276         {
277             /* the collocated ref isn't in the current list0 */
278             /* FIXME: we might still be able to use direct_8x8 on some partitions */
279             /* FIXME: with B-pyramid + extensive ref list reordering
280              *   (not currently used), we would also have to check
281              *   l1mv1 like in spatial mode */
282             return 0;
283         }
284     }
285
286     return 1;
287 }
288
289 static ALWAYS_INLINE int x264_mb_predict_mv_direct16x16_spatial( x264_t *h, int b_interlaced )
290 {
291     int8_t ref[2];
292     ALIGNED_ARRAY_8( int16_t, mv,[2],[2] );
293     for( int i_list = 0; i_list < 2; i_list++ )
294     {
295         int     i_refa = h->mb.cache.ref[i_list][X264_SCAN8_0 - 1];
296         int16_t *mv_a  = h->mb.cache.mv[i_list][X264_SCAN8_0 - 1];
297         int     i_refb = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8];
298         int16_t *mv_b  = h->mb.cache.mv[i_list][X264_SCAN8_0 - 8];
299         int     i_refc = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8 + 4];
300         int16_t *mv_c  = h->mb.cache.mv[i_list][X264_SCAN8_0 - 8 + 4];
301         if( i_refc == -2 )
302         {
303             i_refc = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8 - 1];
304             mv_c   = h->mb.cache.mv[i_list][X264_SCAN8_0 - 8 - 1];
305         }
306
307         int i_ref = X264_MIN3( (unsigned)i_refa, (unsigned)i_refb, (unsigned)i_refc );
308         if( i_ref < 0 )
309         {
310             i_ref = -1;
311             M32( mv[i_list] ) = 0;
312         }
313         else
314         {
315             /* Same as x264_mb_predict_mv_16x16, but simplified to eliminate cases
316              * not relevant to spatial direct. */
317             int i_count = (i_refa == i_ref) + (i_refb == i_ref) + (i_refc == i_ref);
318
319             if( i_count > 1 )
320                 x264_median_mv( mv[i_list], mv_a, mv_b, mv_c );
321             else
322             {
323                 if( i_refa == i_ref )
324                     CP32( mv[i_list], mv_a );
325                 else if( i_refb == i_ref )
326                     CP32( mv[i_list], mv_b );
327                 else
328                     CP32( mv[i_list], mv_c );
329             }
330         }
331
332         x264_macroblock_cache_ref( h, 0, 0, 4, 4, i_list, i_ref );
333         x264_macroblock_cache_mv_ptr( h, 0, 0, 4, 4, i_list, mv[i_list] );
334         ref[i_list] = i_ref;
335     }
336
337     int mb_x = h->mb.i_mb_x;
338     int mb_y = h->mb.i_mb_y;
339     int mb_xy = h->mb.i_mb_xy;
340     int type_col[2] = { h->fref[1][0]->mb_type[mb_xy], h->fref[1][0]->mb_type[mb_xy] };
341     int partition_col[2] = { h->fref[1][0]->mb_partition[mb_xy], h->fref[1][0]->mb_partition[mb_xy] };
342     h->mb.i_partition = partition_col[0];
343     if( b_interlaced && h->fref[1][0]->field[mb_xy] != MB_INTERLACED )
344     {
345         if( MB_INTERLACED )
346         {
347             mb_y = h->mb.i_mb_y&~1;
348             mb_xy = mb_x + h->mb.i_mb_stride * mb_y;
349             type_col[0] = h->fref[1][0]->mb_type[mb_xy];
350             type_col[1] = h->fref[1][0]->mb_type[mb_xy + h->mb.i_mb_stride];
351             partition_col[0] = h->fref[1][0]->mb_partition[mb_xy];
352             partition_col[1] = h->fref[1][0]->mb_partition[mb_xy + h->mb.i_mb_stride];
353
354             if( (IS_INTRA(type_col[0]) || partition_col[0] == D_16x16) &&
355                 (IS_INTRA(type_col[1]) || partition_col[1] == D_16x16) &&
356                 partition_col[0] != D_8x8 )
357                 h->mb.i_partition = D_16x8;
358             else
359                 h->mb.i_partition = D_8x8;
360         }
361         else
362         {
363             int cur_poc = h->fdec->i_poc + h->fdec->i_delta_poc[MB_INTERLACED&h->mb.i_mb_y&1];
364             int col_parity = abs(h->fref[1][0]->i_poc + h->fref[1][0]->i_delta_poc[0] - cur_poc)
365                           >= abs(h->fref[1][0]->i_poc + h->fref[1][0]->i_delta_poc[1] - cur_poc);
366             mb_y = (h->mb.i_mb_y&~1) + col_parity;
367             mb_xy = mb_x + h->mb.i_mb_stride * mb_y;
368             type_col[0] = type_col[1] = h->fref[1][0]->mb_type[mb_xy];
369             partition_col[0] = partition_col[1] = h->fref[1][0]->mb_partition[mb_xy];
370             h->mb.i_partition = partition_col[0];
371         }
372     }
373     int i_mb_4x4 = b_interlaced ? 4 * (h->mb.i_b4_stride*mb_y + mb_x) : h->mb.i_b4_xy ;
374     int i_mb_8x8 = b_interlaced ? 2 * (h->mb.i_b8_stride*mb_y + mb_x) : h->mb.i_b8_xy ;
375
376     int8_t *l1ref0 = &h->fref[1][0]->ref[0][i_mb_8x8];
377     int8_t *l1ref1 = &h->fref[1][0]->ref[1][i_mb_8x8];
378     int16_t (*l1mv[2])[2] = { (int16_t (*)[2]) &h->fref[1][0]->mv[0][i_mb_4x4],
379                               (int16_t (*)[2]) &h->fref[1][0]->mv[1][i_mb_4x4] };
380
381     if( (M16( ref ) & 0x8080) == 0x8080 ) /* if( ref[0] < 0 && ref[1] < 0 ) */
382     {
383         x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, 0 );
384         x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, 0 );
385         return 1;
386     }
387
388     if( h->param.i_threads > 1
389         && ( mv[0][1] > h->mb.mv_max_spel[1]
390           || mv[1][1] > h->mb.mv_max_spel[1] ) )
391     {
392 #if 0
393         fprintf(stderr, "direct_spatial: (%d,%d) (%d,%d) > %d \n",
394                 mv[0][0], mv[0][1], mv[1][0], mv[1][1],
395                 h->mb.mv_max_spel[1]);
396 #endif
397         return 0;
398     }
399
400     if( !M64( mv ) || (!b_interlaced && IS_INTRA( type_col[0] )) || (ref[0]&&ref[1]) )
401         return 1;
402
403     /* Don't do any checks other than the ones we have to, based
404      * on the size of the colocated partitions.
405      * Depends on the enum order: D_8x8, D_16x8, D_8x16, D_16x16 */
406     int max_i8 = (D_16x16 - h->mb.i_partition) + 1;
407     int step = (h->mb.i_partition == D_16x8) + 1;
408     int width = 4 >> ((D_16x16 - h->mb.i_partition)&1);
409     int height = 4 >> ((D_16x16 - h->mb.i_partition)>>1);
410
411     /* col_zero_flag */
412     for( int i8 = 0; i8 < max_i8; i8 += step )
413     {
414         const int x8 = i8&1;
415         const int y8 = i8>>1;
416         int ypart = (b_interlaced && h->fref[1][0]->field[mb_xy] != MB_INTERLACED) ?
417                     MB_INTERLACED ? y8*6 : 2*(h->mb.i_mb_y&1) + y8 :
418                     3*y8;
419         int o8 = x8 + (ypart>>1) * h->mb.i_b8_stride;
420         int o4 = 3*x8 + ypart * h->mb.i_b4_stride;
421
422         if( b_interlaced && IS_INTRA( type_col[y8] ) )
423             continue;
424
425         int idx;
426         if( l1ref0[o8] == 0 )
427             idx = 0;
428         else if( l1ref0[o8] < 0 && l1ref1[o8] == 0 )
429             idx = 1;
430         else
431             continue;
432
433         if( abs( l1mv[idx][o4][0] ) <= 1 && abs( l1mv[idx][o4][1] ) <= 1 )
434         {
435             if( ref[0] == 0 ) x264_macroblock_cache_mv( h, 2*x8, 2*y8, width, height, 0, 0 );
436             if( ref[1] == 0 ) x264_macroblock_cache_mv( h, 2*x8, 2*y8, width, height, 1, 0 );
437         }
438     }
439
440     return 1;
441 }
442
443
444 static int x264_mb_predict_mv_direct16x16_spatial_interlaced( x264_t *h )
445 {
446     return x264_mb_predict_mv_direct16x16_spatial( h, 1 );
447 }
448
449 static int x264_mb_predict_mv_direct16x16_spatial_progressive( x264_t *h )
450 {
451     return x264_mb_predict_mv_direct16x16_spatial( h, 0 );
452 }
453
454 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed )
455 {
456     int b_available;
457     if( h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_NONE )
458         return 0;
459     else if( h->sh.b_direct_spatial_mv_pred )
460     {
461         if( SLICE_MBAFF )
462             b_available = x264_mb_predict_mv_direct16x16_spatial_interlaced( h );
463         else
464             b_available = x264_mb_predict_mv_direct16x16_spatial_progressive( h );
465     }
466     else
467         b_available = x264_mb_predict_mv_direct16x16_temporal( h );
468
469     if( b_changed != NULL && b_available )
470     {
471         int changed;
472
473         changed  = M32( h->mb.cache.direct_mv[0][0] ) ^ M32( h->mb.cache.mv[0][x264_scan8[0]] );
474         changed |= M32( h->mb.cache.direct_mv[1][0] ) ^ M32( h->mb.cache.mv[1][x264_scan8[0]] );
475         changed |= h->mb.cache.direct_ref[0][0] ^ h->mb.cache.ref[0][x264_scan8[0]];
476         changed |= h->mb.cache.direct_ref[1][0] ^ h->mb.cache.ref[1][x264_scan8[0]];
477         if( !changed && h->mb.i_partition != D_16x16 )
478         {
479             changed |= M32( h->mb.cache.direct_mv[0][3] ) ^ M32( h->mb.cache.mv[0][x264_scan8[12]] );
480             changed |= M32( h->mb.cache.direct_mv[1][3] ) ^ M32( h->mb.cache.mv[1][x264_scan8[12]] );
481             changed |= h->mb.cache.direct_ref[0][3] ^ h->mb.cache.ref[0][x264_scan8[12]];
482             changed |= h->mb.cache.direct_ref[1][3] ^ h->mb.cache.ref[1][x264_scan8[12]];
483         }
484         if( !changed && h->mb.i_partition == D_8x8 )
485         {
486             changed |= M32( h->mb.cache.direct_mv[0][1] ) ^ M32( h->mb.cache.mv[0][x264_scan8[4]] );
487             changed |= M32( h->mb.cache.direct_mv[1][1] ) ^ M32( h->mb.cache.mv[1][x264_scan8[4]] );
488             changed |= M32( h->mb.cache.direct_mv[0][2] ) ^ M32( h->mb.cache.mv[0][x264_scan8[8]] );
489             changed |= M32( h->mb.cache.direct_mv[1][2] ) ^ M32( h->mb.cache.mv[1][x264_scan8[8]] );
490             changed |= h->mb.cache.direct_ref[0][1] ^ h->mb.cache.ref[0][x264_scan8[4]];
491             changed |= h->mb.cache.direct_ref[1][1] ^ h->mb.cache.ref[1][x264_scan8[4]];
492             changed |= h->mb.cache.direct_ref[0][2] ^ h->mb.cache.ref[0][x264_scan8[8]];
493             changed |= h->mb.cache.direct_ref[1][2] ^ h->mb.cache.ref[1][x264_scan8[8]];
494         }
495         *b_changed = changed;
496         if( !changed )
497             return b_available;
498     }
499
500     /* cache ref & mv */
501     if( b_available )
502         for( int l = 0; l < 2; l++ )
503         {
504             CP32( h->mb.cache.direct_mv[l][0], h->mb.cache.mv[l][x264_scan8[ 0]] );
505             CP32( h->mb.cache.direct_mv[l][1], h->mb.cache.mv[l][x264_scan8[ 4]] );
506             CP32( h->mb.cache.direct_mv[l][2], h->mb.cache.mv[l][x264_scan8[ 8]] );
507             CP32( h->mb.cache.direct_mv[l][3], h->mb.cache.mv[l][x264_scan8[12]] );
508             h->mb.cache.direct_ref[l][0] = h->mb.cache.ref[l][x264_scan8[ 0]];
509             h->mb.cache.direct_ref[l][1] = h->mb.cache.ref[l][x264_scan8[ 4]];
510             h->mb.cache.direct_ref[l][2] = h->mb.cache.ref[l][x264_scan8[ 8]];
511             h->mb.cache.direct_ref[l][3] = h->mb.cache.ref[l][x264_scan8[12]];
512             h->mb.cache.direct_partition = h->mb.i_partition;
513         }
514
515     return b_available;
516 }
517
518 /* This just improves encoder performance, it's not part of the spec */
519 void x264_mb_predict_mv_ref16x16( x264_t *h, int i_list, int i_ref, int16_t mvc[9][2], int *i_mvc )
520 {
521     int16_t (*mvr)[2] = h->mb.mvr[i_list][i_ref];
522     int i = 0;
523
524 #define SET_MVP(mvp) \
525     { \
526         CP32( mvc[i], mvp ); \
527         i++; \
528     }
529
530 #define SET_IMVP(xy) \
531     if( xy >= 0 ) \
532     { \
533         int shift = 1 + MB_INTERLACED - h->mb.field[xy]; \
534         int16_t *mvp = h->mb.mvr[i_list][i_ref<<1>>shift][xy]; \
535         mvc[i][0] = mvp[0]; \
536         mvc[i][1] = mvp[1]<<1>>shift; \
537         i++; \
538     }
539
540     /* b_direct */
541     if( h->sh.i_type == SLICE_TYPE_B
542         && h->mb.cache.ref[i_list][x264_scan8[12]] == i_ref )
543     {
544         SET_MVP( h->mb.cache.mv[i_list][x264_scan8[12]] );
545     }
546
547     if( i_ref == 0 && h->frames.b_have_lowres )
548     {
549         int idx = i_list ? h->fref[1][0]->i_frame-h->fenc->i_frame-1
550                          : h->fenc->i_frame-h->fref[0][0]->i_frame-1;
551         if( idx <= h->param.i_bframe )
552         {
553             int16_t (*lowres_mv)[2] = h->fenc->lowres_mvs[i_list][idx];
554             if( lowres_mv[0][0] != 0x7fff )
555             {
556                 M32( mvc[i] ) = (M32( lowres_mv[h->mb.i_mb_xy] )*2)&0xfffeffff;
557                 i++;
558             }
559         }
560     }
561
562     /* spatial predictors */
563     if( SLICE_MBAFF )
564     {
565         SET_IMVP( h->mb.i_mb_left_xy[0] );
566         SET_IMVP( h->mb.i_mb_top_xy );
567         SET_IMVP( h->mb.i_mb_topleft_xy );
568         SET_IMVP( h->mb.i_mb_topright_xy );
569     }
570     else
571     {
572         SET_MVP( mvr[h->mb.i_mb_left_xy[0]] );
573         SET_MVP( mvr[h->mb.i_mb_top_xy] );
574         SET_MVP( mvr[h->mb.i_mb_topleft_xy] );
575         SET_MVP( mvr[h->mb.i_mb_topright_xy] );
576     }
577 #undef SET_IMVP
578 #undef SET_MVP
579
580     /* temporal predictors */
581     if( h->fref[0][0]->i_ref[0] > 0 )
582     {
583         x264_frame_t *l0 = h->fref[0][0];
584         int field = h->mb.i_mb_y&1;
585         int curpoc = h->fdec->i_poc + h->fdec->i_delta_poc[field];
586         int refpoc = h->fref[i_list][i_ref>>SLICE_MBAFF]->i_poc;
587         refpoc += l0->i_delta_poc[field^(i_ref&1)];
588
589 #define SET_TMVP( dx, dy ) \
590         { \
591             int mb_index = h->mb.i_mb_xy + dx + dy*h->mb.i_mb_stride; \
592             int scale = (curpoc - refpoc) * l0->inv_ref_poc[MB_INTERLACED&field]; \
593             mvc[i][0] = (l0->mv16x16[mb_index][0]*scale + 128) >> 8; \
594             mvc[i][1] = (l0->mv16x16[mb_index][1]*scale + 128) >> 8; \
595             i++; \
596         }
597
598         SET_TMVP(0,0);
599         if( h->mb.i_mb_x < h->mb.i_mb_width-1 )
600             SET_TMVP(1,0);
601         if( h->mb.i_mb_y < h->mb.i_mb_height-1 )
602             SET_TMVP(0,1);
603 #undef SET_TMVP
604     }
605
606     *i_mvc = i;
607 }