1 /*****************************************************************************
2 * mvpred.c: motion vector prediction
3 *****************************************************************************
4 * Copyright (C) 2003-2016 x264 project
6 * Authors: Loren Merritt <lorenm@u.washington.edu>
7 * Fiona Glaser <fiona@x264.com>
8 * Laurent Aimar <fenrir@via.ecp.fr>
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.
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.
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.
24 * This program is also available under a commercial proprietary license.
25 * For more information, contact us at licensing@x264.com.
26 *****************************************************************************/
30 void x264_mb_predict_mv( x264_t *h, int i_list, int idx, int i_width, int16_t mvp[2] )
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];
41 // Partitions not yet reached in scan order are unavailable.
42 if( (idx&3) >= 2 + (i_width&1) || i_refc == -2 )
44 i_refc = h->mb.cache.ref[i_list][i8 - 8 - 1];
45 mv_c = h->mb.cache.mv[i_list][i8 - 8 - 1];
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]] )
53 mv_c = h->mb.cache.topright_mv[i_list][0];
54 i_refc = h->mb.cache.topright_ref[i_list][0];
58 mv_c = h->mb.cache.topright_mv[i_list][1];
59 i_refc = h->mb.cache.topright_ref[i_list][1];
63 mv_c = h->mb.cache.topright_mv[i_list][2];
64 i_refc = h->mb.cache.topright_ref[i_list][2];
68 if( h->mb.i_partition == D_16x8 )
87 else if( h->mb.i_partition == D_8x16 )
107 int i_count = (i_refa == i_ref) + (i_refb == i_ref) + (i_refc == i_ref);
112 x264_median_mv( mvp, mv_a, mv_b, mv_c );
114 else if( i_count == 1 )
116 if( i_refa == i_ref )
118 else if( i_refb == i_ref )
123 else if( i_refb == -2 && i_refc == -2 && i_refa != -2 )
129 void x264_mb_predict_mv_16x16( x264_t *h, int i_list, int i_ref, int16_t mvp[2] )
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];
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];
143 int i_count = (i_refa == i_ref) + (i_refb == i_ref) + (i_refc == i_ref);
148 x264_median_mv( mvp, mv_a, mv_b, mv_c );
150 else if( i_count == 1 )
152 if( i_refa == i_ref )
154 else if( i_refb == i_ref )
159 else if( i_refb == -2 && i_refc == -2 && i_refa != -2 )
166 void x264_mb_predict_mv_pskip( x264_t *h, int16_t mv[2] )
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];
173 if( i_refa == -2 || i_refb == -2 ||
174 !( i_refa | M32( mv_a ) ) ||
175 !( i_refb | M32( mv_b ) ) )
180 x264_mb_predict_mv_16x16( h, 0, 0, mv );
183 static int x264_mb_predict_mv_direct16x16_temporal( x264_t *h )
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;
194 h->mb.i_partition = partition_col[0];
195 if( PARAM_INTERLACED && h->fref[1][0]->field[mb_xy] != MB_INTERLACED )
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];
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;
213 h->mb.i_partition = D_8x8;
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];
226 h->mb.i_partition = partition_col[0];
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;
233 x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, 0 );
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 )
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 :
250 if( IS_INTRA( type_col[y8] ) )
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 );
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);
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]) )
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) );
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 */
289 static ALWAYS_INLINE int x264_mb_predict_mv_direct16x16_spatial( x264_t *h, int b_interlaced )
292 ALIGNED_ARRAY_8( int16_t, mv,[2],[2] );
293 for( int i_list = 0; i_list < 2; i_list++ )
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];
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];
307 int i_ref = X264_MIN3( (unsigned)i_refa, (unsigned)i_refb, (unsigned)i_refc );
311 M32( mv[i_list] ) = 0;
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);
320 x264_median_mv( mv[i_list], mv_a, mv_b, mv_c );
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 );
328 CP32( mv[i_list], mv_c );
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] );
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 )
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];
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;
359 h->mb.i_partition = D_8x8;
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];
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 ;
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] };
381 if( (M16( ref ) & 0x8080) == 0x8080 ) /* if( ref[0] < 0 && ref[1] < 0 ) */
383 x264_macroblock_cache_ref( h, 0, 0, 4, 4, 0, 0 );
384 x264_macroblock_cache_ref( h, 0, 0, 4, 4, 1, 0 );
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] ) )
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]);
400 if( !M64( mv ) || (!b_interlaced && IS_INTRA( type_col[0] )) || (ref[0]&&ref[1]) )
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);
412 for( int i8 = 0; i8 < max_i8; i8 += step )
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 :
419 int o8 = x8 + (ypart>>1) * h->mb.i_b8_stride;
420 int o4 = 3*x8 + ypart * h->mb.i_b4_stride;
422 if( b_interlaced && IS_INTRA( type_col[y8] ) )
426 if( l1ref0[o8] == 0 )
428 else if( l1ref0[o8] < 0 && l1ref1[o8] == 0 )
433 if( abs( l1mv[idx][o4][0] ) <= 1 && abs( l1mv[idx][o4][1] ) <= 1 )
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 );
444 static int x264_mb_predict_mv_direct16x16_spatial_interlaced( x264_t *h )
446 return x264_mb_predict_mv_direct16x16_spatial( h, 1 );
449 static int x264_mb_predict_mv_direct16x16_spatial_progressive( x264_t *h )
451 return x264_mb_predict_mv_direct16x16_spatial( h, 0 );
454 int x264_mb_predict_mv_direct16x16( x264_t *h, int *b_changed )
457 if( h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_NONE )
459 else if( h->sh.b_direct_spatial_mv_pred )
462 b_available = x264_mb_predict_mv_direct16x16_spatial_interlaced( h );
464 b_available = x264_mb_predict_mv_direct16x16_spatial_progressive( h );
467 b_available = x264_mb_predict_mv_direct16x16_temporal( h );
469 if( b_changed != NULL && b_available )
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 )
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]];
484 if( !changed && h->mb.i_partition == D_8x8 )
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]];
495 *b_changed = changed;
502 for( int l = 0; l < 2; l++ )
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;
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 )
521 int16_t (*mvr)[2] = h->mb.mvr[i_list][i_ref];
524 #define SET_MVP(mvp) \
526 CP32( mvc[i], mvp ); \
530 #define SET_IMVP(xy) \
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; \
541 if( h->sh.i_type == SLICE_TYPE_B
542 && h->mb.cache.ref[i_list][x264_scan8[12]] == i_ref )
544 SET_MVP( h->mb.cache.mv[i_list][x264_scan8[12]] );
547 if( i_ref == 0 && h->frames.b_have_lowres )
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 )
553 int16_t (*lowres_mv)[2] = h->fenc->lowres_mvs[i_list][idx];
554 if( lowres_mv[0][0] != 0x7fff )
556 M32( mvc[i] ) = (M32( lowres_mv[h->mb.i_mb_xy] )*2)&0xfffeffff;
562 /* spatial predictors */
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 );
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] );
580 /* temporal predictors */
581 if( h->fref[0][0]->i_ref[0] > 0 )
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)];
589 #define SET_TMVP( dx, dy ) \
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; \
599 if( h->mb.i_mb_x < h->mb.i_mb_width-1 )
601 if( h->mb.i_mb_y < h->mb.i_mb_height-1 )