git.sesse.net Git - ffmpeg/blob - libavcodec/vc1_pred.c

   1 /*
   2  * VC-1 and WMV3 decoder
   3  * Copyright (c) 2011 Mashiat Sarker Shakkhar
   4  * Copyright (c) 2006-2007 Konstantin Shishkov
   5  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
   6  *
   7  * This file is part of FFmpeg.
   8  *
   9  * FFmpeg is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * FFmpeg 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 GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with FFmpeg; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 /**
  25  * @file
  26  * VC-1 and WMV3 block decoding routines
  27  */
  28
  29 #include "mathops.h"
  30 #include "mpegutils.h"
  31 #include "mpegvideo.h"
  32 #include "vc1.h"
  33 #include "vc1_pred.h"
  34 #include "vc1data.h"
  35
  36 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
  37 {
  38     int scaledvalue, refdist;
  39     int scalesame1, scalesame2;
  40     int scalezone1_x, zone1offset_x;
  41     int table_index = dir ^ v->second_field;
  42
  43     if (v->s.pict_type != AV_PICTURE_TYPE_B)
  44         refdist = v->refdist;
  45     else
  46         refdist = dir ? v->brfd : v->frfd;
  47     if (refdist > 3)
  48         refdist = 3;
  49     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
  50     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
  51     scalezone1_x  = ff_vc1_field_mvpred_scales[table_index][3][refdist];
  52     zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
  53
  54     if (FFABS(n) > 255)
  55         scaledvalue = n;
  56     else {
  57         if (FFABS(n) < scalezone1_x)
  58             scaledvalue = (n * scalesame1) >> 8;
  59         else {
  60             if (n < 0)
  61                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
  62             else
  63                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
  64         }
  65     }
  66     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
  67 }
  68
  69 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
  70 {
  71     int scaledvalue, refdist;
  72     int scalesame1, scalesame2;
  73     int scalezone1_y, zone1offset_y;
  74     int table_index = dir ^ v->second_field;
  75
  76     if (v->s.pict_type != AV_PICTURE_TYPE_B)
  77         refdist = v->refdist;
  78     else
  79         refdist = dir ? v->brfd : v->frfd;
  80     if (refdist > 3)
  81         refdist = 3;
  82     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
  83     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
  84     scalezone1_y  = ff_vc1_field_mvpred_scales[table_index][4][refdist];
  85     zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
  86
  87     if (FFABS(n) > 63)
  88         scaledvalue = n;
  89     else {
  90         if (FFABS(n) < scalezone1_y)
  91             scaledvalue = (n * scalesame1) >> 8;
  92         else {
  93             if (n < 0)
  94                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
  95             else
  96                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
  97         }
  98     }
  99
 100     if (v->cur_field_type && !v->ref_field_type[dir])
 101         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
 102     else
 103         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
 104 }
 105
 106 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
 107 {
 108     int scalezone1_x, zone1offset_x;
 109     int scaleopp1, scaleopp2, brfd;
 110     int scaledvalue;
 111
 112     brfd = FFMIN(v->brfd, 3);
 113     scalezone1_x  = ff_vc1_b_field_mvpred_scales[3][brfd];
 114     zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
 115     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
 116     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
 117
 118     if (FFABS(n) > 255)
 119         scaledvalue = n;
 120     else {
 121         if (FFABS(n) < scalezone1_x)
 122             scaledvalue = (n * scaleopp1) >> 8;
 123         else {
 124             if (n < 0)
 125                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
 126             else
 127                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
 128         }
 129     }
 130     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
 131 }
 132
 133 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
 134 {
 135     int scalezone1_y, zone1offset_y;
 136     int scaleopp1, scaleopp2, brfd;
 137     int scaledvalue;
 138
 139     brfd = FFMIN(v->brfd, 3);
 140     scalezone1_y  = ff_vc1_b_field_mvpred_scales[4][brfd];
 141     zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
 142     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
 143     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
 144
 145     if (FFABS(n) > 63)
 146         scaledvalue = n;
 147     else {
 148         if (FFABS(n) < scalezone1_y)
 149             scaledvalue = (n * scaleopp1) >> 8;
 150         else {
 151             if (n < 0)
 152                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
 153             else
 154                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
 155         }
 156     }
 157     if (v->cur_field_type && !v->ref_field_type[dir]) {
 158         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
 159     } else {
 160         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
 161     }
 162 }
 163
 164 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
 165                                          int dim, int dir)
 166 {
 167     int brfd, scalesame;
 168     int hpel = 1 - v->s.quarter_sample;
 169
 170     n >>= hpel;
 171     if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
 172         if (dim)
 173             n = scaleforsame_y(v, i, n, dir) << hpel;
 174         else
 175             n = scaleforsame_x(v, n, dir) << hpel;
 176         return n;
 177     }
 178     brfd      = FFMIN(v->brfd, 3);
 179     scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
 180
 181     n = (n * scalesame >> 8) << hpel;
 182     return n;
 183 }
 184
 185 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
 186                                         int dim, int dir)
 187 {
 188     int refdist, scaleopp;
 189     int hpel = 1 - v->s.quarter_sample;
 190
 191     n >>= hpel;
 192     if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
 193         if (dim)
 194             n = scaleforopp_y(v, n, dir) << hpel;
 195         else
 196             n = scaleforopp_x(v, n) << hpel;
 197         return n;
 198     }
 199     if (v->s.pict_type != AV_PICTURE_TYPE_B)
 200         refdist = FFMIN(v->refdist, 3);
 201     else
 202         refdist = dir ? v->brfd : v->frfd;
 203     scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
 204
 205     n = (n * scaleopp >> 8) << hpel;
 206     return n;
 207 }
 208
 209 /** Predict and set motion vector
 210  */
 211 void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
 212                     int mv1, int r_x, int r_y, uint8_t* is_intra,
 213                     int pred_flag, int dir)
 214 {
 215     MpegEncContext *s = &v->s;
 216     int xy, wrap, off = 0;
 217     int16_t *A, *B, *C;
 218     int px, py;
 219     int sum;
 220     int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
 221     int opposite, a_f, b_f, c_f;
 222     int16_t field_predA[2];
 223     int16_t field_predB[2];
 224     int16_t field_predC[2];
 225     int a_valid, b_valid, c_valid;
 226     int hybridmv_thresh, y_bias = 0;
 227
 228     if (v->mv_mode == MV_PMODE_MIXED_MV ||
 229         ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
 230         mixedmv_pic = 1;
 231     else
 232         mixedmv_pic = 0;
 233     /* scale MV difference to be quad-pel */
 234     dmv_x <<= 1 - s->quarter_sample;
 235     dmv_y <<= 1 - s->quarter_sample;
 236
 237     wrap = s->b8_stride;
 238     xy   = s->block_index[n];
 239
 240     if (s->mb_intra) {
 241         s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
 242         s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
 243         s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
 244         s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
 245         if (mv1) { /* duplicate motion data for 1-MV block */
 246             s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0]        = 0;
 247             s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1]        = 0;
 248             s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0]     = 0;
 249             s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1]     = 0;
 250             s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
 251             s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
 252             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
 253             s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0]        = 0;
 254             s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1]        = 0;
 255             s->current_picture.motion_val[1][xy + wrap][0]                     = 0;
 256             s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1]     = 0;
 257             s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
 258             s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
 259         }
 260         return;
 261     }
 262
 263     C = s->current_picture.motion_val[dir][xy -    1 + v->blocks_off];
 264     A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
 265     if (mv1) {
 266         if (v->field_mode && mixedmv_pic)
 267             off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
 268         else
 269             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
 270     } else {
 271         //in 4-MV mode different blocks have different B predictor position
 272         switch (n) {
 273         case 0:
 274             off = (s->mb_x > 0) ? -1 : 1;
 275             break;
 276         case 1:
 277             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
 278             break;
 279         case 2:
 280             off = 1;
 281             break;
 282         case 3:
 283             off = -1;
 284         }
 285     }
 286     B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
 287
 288     a_valid = !s->first_slice_line || (n == 2 || n == 3);
 289     b_valid = a_valid && (s->mb_width > 1);
 290     c_valid = s->mb_x || (n == 1 || n == 3);
 291     if (v->field_mode) {
 292         a_valid = a_valid && !is_intra[xy - wrap];
 293         b_valid = b_valid && !is_intra[xy - wrap + off];
 294         c_valid = c_valid && !is_intra[xy - 1];
 295     }
 296
 297     if (a_valid) {
 298         a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
 299         num_oppfield  += a_f;
 300         num_samefield += 1 - a_f;
 301         field_predA[0] = A[0];
 302         field_predA[1] = A[1];
 303     } else {
 304         field_predA[0] = field_predA[1] = 0;
 305         a_f = 0;
 306     }
 307     if (b_valid) {
 308         b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
 309         num_oppfield  += b_f;
 310         num_samefield += 1 - b_f;
 311         field_predB[0] = B[0];
 312         field_predB[1] = B[1];
 313     } else {
 314         field_predB[0] = field_predB[1] = 0;
 315         b_f = 0;
 316     }
 317     if (c_valid) {
 318         c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
 319         num_oppfield  += c_f;
 320         num_samefield += 1 - c_f;
 321         field_predC[0] = C[0];
 322         field_predC[1] = C[1];
 323     } else {
 324         field_predC[0] = field_predC[1] = 0;
 325         c_f = 0;
 326     }
 327
 328     if (v->field_mode) {
 329         if (!v->numref)
 330             // REFFIELD determines if the last field or the second-last field is
 331             // to be used as reference
 332             opposite = 1 - v->reffield;
 333         else {
 334             if (num_samefield <= num_oppfield)
 335                 opposite = 1 - pred_flag;
 336             else
 337                 opposite = pred_flag;
 338         }
 339     } else
 340         opposite = 0;
 341     if (opposite) {
 342         if (a_valid && !a_f) {
 343             field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
 344             field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
 345         }
 346         if (b_valid && !b_f) {
 347             field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
 348             field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
 349         }
 350         if (c_valid && !c_f) {
 351             field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
 352             field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
 353         }
 354         v->mv_f[dir][xy + v->blocks_off] = 1;
 355         v->ref_field_type[dir] = !v->cur_field_type;
 356     } else {
 357         if (a_valid && a_f) {
 358             field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
 359             field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
 360         }
 361         if (b_valid && b_f) {
 362             field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
 363             field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
 364         }
 365         if (c_valid && c_f) {
 366             field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
 367             field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
 368         }
 369         v->mv_f[dir][xy + v->blocks_off] = 0;
 370         v->ref_field_type[dir] = v->cur_field_type;
 371     }
 372
 373     if (a_valid) {
 374         px = field_predA[0];
 375         py = field_predA[1];
 376     } else if (c_valid) {
 377         px = field_predC[0];
 378         py = field_predC[1];
 379     } else if (b_valid) {
 380         px = field_predB[0];
 381         py = field_predB[1];
 382     } else {
 383         px = 0;
 384         py = 0;
 385     }
 386
 387     if (num_samefield + num_oppfield > 1) {
 388         px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
 389         py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
 390     }
 391
 392     /* Pullback MV as specified in 8.3.5.3.4 */
 393     if (!v->field_mode) {
 394         int qx, qy, X, Y;
 395         qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
 396         qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
 397         X  = (s->mb_width  << 6) - 4;
 398         Y  = (s->mb_height << 6) - 4;
 399         if (mv1) {
 400             if (qx + px < -60) px = -60 - qx;
 401             if (qy + py < -60) py = -60 - qy;
 402         } else {
 403             if (qx + px < -28) px = -28 - qx;
 404             if (qy + py < -28) py = -28 - qy;
 405         }
 406         if (qx + px > X) px = X - qx;
 407         if (qy + py > Y) py = Y - qy;
 408     }
 409
 410     if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
 411         /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
 412         hybridmv_thresh = 32;
 413         if (a_valid && c_valid) {
 414             if (is_intra[xy - wrap])
 415                 sum = FFABS(px) + FFABS(py);
 416             else
 417                 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
 418             if (sum > hybridmv_thresh) {
 419                 if (get_bits1(&s->gb)) {     // read HYBRIDPRED bit
 420                     px = field_predA[0];
 421                     py = field_predA[1];
 422                 } else {
 423                     px = field_predC[0];
 424                     py = field_predC[1];
 425                 }
 426             } else {
 427                 if (is_intra[xy - 1])
 428                     sum = FFABS(px) + FFABS(py);
 429                 else
 430                     sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
 431                 if (sum > hybridmv_thresh) {
 432                     if (get_bits1(&s->gb)) {
 433                         px = field_predA[0];
 434                         py = field_predA[1];
 435                     } else {
 436                         px = field_predC[0];
 437                         py = field_predC[1];
 438                     }
 439                 }
 440             }
 441         }
 442     }
 443
 444     if (v->field_mode && v->numref)
 445         r_y >>= 1;
 446     if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
 447         y_bias = 1;
 448     /* store MV using signed modulus of MV range defined in 4.11 */
 449     s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
 450     s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
 451     if (mv1) { /* duplicate motion data for 1-MV block */
 452         s->current_picture.motion_val[dir][xy +    1 +     v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
 453         s->current_picture.motion_val[dir][xy +    1 +     v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
 454         s->current_picture.motion_val[dir][xy + wrap +     v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
 455         s->current_picture.motion_val[dir][xy + wrap +     v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
 456         s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
 457         s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
 458         v->mv_f[dir][xy +    1 + v->blocks_off] = v->mv_f[dir][xy +            v->blocks_off];
 459         v->mv_f[dir][xy + wrap + v->blocks_off] = v->mv_f[dir][xy + wrap + 1 + v->blocks_off] = v->mv_f[dir][xy + v->blocks_off];
 460     }
 461 }
 462
 463 /** Predict and set motion vector for interlaced frame picture MBs
 464  */
 465 void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
 466                           int mvn, int r_x, int r_y, uint8_t* is_intra, int dir)
 467 {
 468     MpegEncContext *s = &v->s;
 469     int xy, wrap, off = 0;
 470     int A[2], B[2], C[2];
 471     int px = 0, py = 0;
 472     int a_valid = 0, b_valid = 0, c_valid = 0;
 473     int field_a, field_b, field_c; // 0: same, 1: opposit
 474     int total_valid, num_samefield, num_oppfield;
 475     int pos_c, pos_b, n_adj;
 476
 477     wrap = s->b8_stride;
 478     xy = s->block_index[n];
 479
 480     if (s->mb_intra) {
 481         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
 482         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
 483         s->current_picture.motion_val[1][xy][0] = 0;
 484         s->current_picture.motion_val[1][xy][1] = 0;
 485         if (mvn == 1) { /* duplicate motion data for 1-MV block */
 486             s->current_picture.motion_val[0][xy + 1][0]        = 0;
 487             s->current_picture.motion_val[0][xy + 1][1]        = 0;
 488             s->current_picture.motion_val[0][xy + wrap][0]     = 0;
 489             s->current_picture.motion_val[0][xy + wrap][1]     = 0;
 490             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
 491             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
 492             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
 493             s->current_picture.motion_val[1][xy + 1][0]        = 0;
 494             s->current_picture.motion_val[1][xy + 1][1]        = 0;
 495             s->current_picture.motion_val[1][xy + wrap][0]     = 0;
 496             s->current_picture.motion_val[1][xy + wrap][1]     = 0;
 497             s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
 498             s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
 499         }
 500         return;
 501     }
 502
 503     off = ((n == 0) || (n == 1)) ? 1 : -1;
 504     /* predict A */
 505     if (s->mb_x || (n == 1) || (n == 3)) {
 506         if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
 507             || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
 508             A[0] = s->current_picture.motion_val[dir][xy - 1][0];
 509             A[1] = s->current_picture.motion_val[dir][xy - 1][1];
 510             a_valid = 1;
 511         } else { // current block has frame mv and cand. has field MV (so average)
 512             A[0] = (s->current_picture.motion_val[dir][xy - 1][0]
 513                     + s->current_picture.motion_val[dir][xy - 1 + off * wrap][0] + 1) >> 1;
 514             A[1] = (s->current_picture.motion_val[dir][xy - 1][1]
 515                     + s->current_picture.motion_val[dir][xy - 1 + off * wrap][1] + 1) >> 1;
 516             a_valid = 1;
 517         }
 518         if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
 519             a_valid = 0;
 520             A[0] = A[1] = 0;
 521         }
 522     } else
 523         A[0] = A[1] = 0;
 524     /* Predict B and C */
 525     B[0] = B[1] = C[0] = C[1] = 0;
 526     if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
 527         if (!s->first_slice_line) {
 528             if (!v->is_intra[s->mb_x - s->mb_stride]) {
 529                 b_valid = 1;
 530                 n_adj   = n | 2;
 531                 pos_b   = s->block_index[n_adj] - 2 * wrap;
 532                 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
 533                     n_adj = (n & 2) | (n & 1);
 534                 }
 535                 B[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][0];
 536                 B[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][1];
 537                 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
 538                     B[0] = (B[0] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
 539                     B[1] = (B[1] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
 540                 }
 541             }
 542             if (s->mb_width > 1) {
 543                 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
 544                     c_valid = 1;
 545                     n_adj   = 2;
 546                     pos_c   = s->block_index[2] - 2 * wrap + 2;
 547                     if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
 548                         n_adj = n & 2;
 549                     }
 550                     C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][0];
 551                     C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][1];
 552                     if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
 553                         C[0] = (1 + C[0] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
 554                         C[1] = (1 + C[1] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
 555                     }
 556                     if (s->mb_x == s->mb_width - 1) {
 557                         if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
 558                             c_valid = 1;
 559                             n_adj   = 3;
 560                             pos_c   = s->block_index[3] - 2 * wrap - 2;
 561                             if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
 562                                 n_adj = n | 1;
 563                             }
 564                             C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][0];
 565                             C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][1];
 566                             if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
 567                                 C[0] = (1 + C[0] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
 568                                 C[1] = (1 + C[1] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
 569                             }
 570                         } else
 571                             c_valid = 0;
 572                     }
 573                 }
 574             }
 575         }
 576     } else {
 577         pos_b   = s->block_index[1];
 578         b_valid = 1;
 579         B[0]    = s->current_picture.motion_val[dir][pos_b][0];
 580         B[1]    = s->current_picture.motion_val[dir][pos_b][1];
 581         pos_c   = s->block_index[0];
 582         c_valid = 1;
 583         C[0]    = s->current_picture.motion_val[dir][pos_c][0];
 584         C[1]    = s->current_picture.motion_val[dir][pos_c][1];
 585     }
 586
 587     total_valid = a_valid + b_valid + c_valid;
 588     // check if predictor A is out of bounds
 589     if (!s->mb_x && !(n == 1 || n == 3)) {
 590         A[0] = A[1] = 0;
 591     }
 592     // check if predictor B is out of bounds
 593     if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
 594         B[0] = B[1] = C[0] = C[1] = 0;
 595     }
 596     if (!v->blk_mv_type[xy]) {
 597         if (s->mb_width == 1) {
 598             px = B[0];
 599             py = B[1];
 600         } else {
 601             if (total_valid >= 2) {
 602                 px = mid_pred(A[0], B[0], C[0]);
 603                 py = mid_pred(A[1], B[1], C[1]);
 604             } else if (total_valid) {
 605                 if      (a_valid) { px = A[0]; py = A[1]; }
 606                 else if (b_valid) { px = B[0]; py = B[1]; }
 607                 else              { px = C[0]; py = C[1]; }
 608             }
 609         }
 610     } else {
 611         if (a_valid)
 612             field_a = (A[1] & 4) ? 1 : 0;
 613         else
 614             field_a = 0;
 615         if (b_valid)
 616             field_b = (B[1] & 4) ? 1 : 0;
 617         else
 618             field_b = 0;
 619         if (c_valid)
 620             field_c = (C[1] & 4) ? 1 : 0;
 621         else
 622             field_c = 0;
 623
 624         num_oppfield  = field_a + field_b + field_c;
 625         num_samefield = total_valid - num_oppfield;
 626         if (total_valid == 3) {
 627             if ((num_samefield == 3) || (num_oppfield == 3)) {
 628                 px = mid_pred(A[0], B[0], C[0]);
 629                 py = mid_pred(A[1], B[1], C[1]);
 630             } else if (num_samefield >= num_oppfield) {
 631                 /* take one MV from same field set depending on priority
 632                 the check for B may not be necessary */
 633                 px = !field_a ? A[0] : B[0];
 634                 py = !field_a ? A[1] : B[1];
 635             } else {
 636                 px =  field_a ? A[0] : B[0];
 637                 py =  field_a ? A[1] : B[1];
 638             }
 639         } else if (total_valid == 2) {
 640             if (num_samefield >= num_oppfield) {
 641                 if (!field_a && a_valid) {
 642                     px = A[0];
 643                     py = A[1];
 644                 } else if (!field_b && b_valid) {
 645                     px = B[0];
 646                     py = B[1];
 647                 } else /*if (c_valid)*/ {
 648                     av_assert1(c_valid);
 649                     px = C[0];
 650                     py = C[1];
 651                 } /*else px = py = 0;*/
 652             } else {
 653                 if (field_a && a_valid) {
 654                     px = A[0];
 655                     py = A[1];
 656                 } else /*if (field_b && b_valid)*/ {
 657                     av_assert1(field_b && b_valid);
 658                     px = B[0];
 659                     py = B[1];
 660                 } /*else if (c_valid) {
 661                     px = C[0];
 662                     py = C[1];
 663                 }*/
 664             }
 665         } else if (total_valid == 1) {
 666             px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
 667             py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
 668         }
 669     }
 670
 671     /* store MV using signed modulus of MV range defined in 4.11 */
 672     s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
 673     s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
 674     if (mvn == 1) { /* duplicate motion data for 1-MV block */
 675         s->current_picture.motion_val[dir][xy +    1    ][0] = s->current_picture.motion_val[dir][xy][0];
 676         s->current_picture.motion_val[dir][xy +    1    ][1] = s->current_picture.motion_val[dir][xy][1];
 677         s->current_picture.motion_val[dir][xy + wrap    ][0] = s->current_picture.motion_val[dir][xy][0];
 678         s->current_picture.motion_val[dir][xy + wrap    ][1] = s->current_picture.motion_val[dir][xy][1];
 679         s->current_picture.motion_val[dir][xy + wrap + 1][0] = s->current_picture.motion_val[dir][xy][0];
 680         s->current_picture.motion_val[dir][xy + wrap + 1][1] = s->current_picture.motion_val[dir][xy][1];
 681     } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
 682         s->current_picture.motion_val[dir][xy + 1][0] = s->current_picture.motion_val[dir][xy][0];
 683         s->current_picture.motion_val[dir][xy + 1][1] = s->current_picture.motion_val[dir][xy][1];
 684         s->mv[dir][n + 1][0] = s->mv[dir][n][0];
 685         s->mv[dir][n + 1][1] = s->mv[dir][n][1];
 686     }
 687 }
 688
 689 void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
 690                       int direct, int mvtype)
 691 {
 692     MpegEncContext *s = &v->s;
 693     int xy, wrap, off = 0;
 694     int16_t *A, *B, *C;
 695     int px, py;
 696     int sum;
 697     int r_x, r_y;
 698     const uint8_t *is_intra = v->mb_type[0];
 699
 700     av_assert0(!v->field_mode);
 701
 702     r_x = v->range_x;
 703     r_y = v->range_y;
 704     /* scale MV difference to be quad-pel */
 705     dmv_x[0] <<= 1 - s->quarter_sample;
 706     dmv_y[0] <<= 1 - s->quarter_sample;
 707     dmv_x[1] <<= 1 - s->quarter_sample;
 708     dmv_y[1] <<= 1 - s->quarter_sample;
 709
 710     wrap = s->b8_stride;
 711     xy = s->block_index[0];
 712
 713     if (s->mb_intra) {
 714         s->current_picture.motion_val[0][xy][0] =
 715         s->current_picture.motion_val[0][xy][1] =
 716         s->current_picture.motion_val[1][xy][0] =
 717         s->current_picture.motion_val[1][xy][1] = 0;
 718         return;
 719     }
 720         if (direct && s->next_picture_ptr->field_picture)
 721             av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n");
 722
 723         s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
 724         s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
 725         s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
 726         s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
 727
 728         /* Pullback predicted motion vectors as specified in 8.4.5.4 */
 729         s->mv[0][0][0] = av_clip(s->mv[0][0][0], -60 - (s->mb_x << 6), (s->mb_width  << 6) - 4 - (s->mb_x << 6));
 730         s->mv[0][0][1] = av_clip(s->mv[0][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
 731         s->mv[1][0][0] = av_clip(s->mv[1][0][0], -60 - (s->mb_x << 6), (s->mb_width  << 6) - 4 - (s->mb_x << 6));
 732         s->mv[1][0][1] = av_clip(s->mv[1][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
 733     if (direct) {
 734         s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
 735         s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
 736         s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
 737         s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
 738         return;
 739     }
 740
 741     if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
 742         C   = s->current_picture.motion_val[0][xy - 2];
 743         A   = s->current_picture.motion_val[0][xy - wrap * 2];
 744         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
 745         B   = s->current_picture.motion_val[0][xy - wrap * 2 + off];
 746
 747         if (!s->mb_x) C[0] = C[1] = 0;
 748         if (!s->first_slice_line) { // predictor A is not out of bounds
 749             if (s->mb_width == 1) {
 750                 px = A[0];
 751                 py = A[1];
 752             } else {
 753                 px = mid_pred(A[0], B[0], C[0]);
 754                 py = mid_pred(A[1], B[1], C[1]);
 755             }
 756         } else if (s->mb_x) { // predictor C is not out of bounds
 757             px = C[0];
 758             py = C[1];
 759         } else {
 760             px = py = 0;
 761         }
 762         /* Pullback MV as specified in 8.3.5.3.4 */
 763         {
 764             int qx, qy, X, Y;
 765             if (v->profile < PROFILE_ADVANCED) {
 766                 qx = (s->mb_x << 5);
 767                 qy = (s->mb_y << 5);
 768                 X  = (s->mb_width  << 5) - 4;
 769                 Y  = (s->mb_height << 5) - 4;
 770                 if (qx + px < -28) px = -28 - qx;
 771                 if (qy + py < -28) py = -28 - qy;
 772                 if (qx + px > X) px = X - qx;
 773                 if (qy + py > Y) py = Y - qy;
 774             } else {
 775                 qx = (s->mb_x << 6);
 776                 qy = (s->mb_y << 6);
 777                 X  = (s->mb_width  << 6) - 4;
 778                 Y  = (s->mb_height << 6) - 4;
 779                 if (qx + px < -60) px = -60 - qx;
 780                 if (qy + py < -60) py = -60 - qy;
 781                 if (qx + px > X) px = X - qx;
 782                 if (qy + py > Y) py = Y - qy;
 783             }
 784         }
 785         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
 786         if (0 && !s->first_slice_line && s->mb_x) {
 787             if (is_intra[xy - wrap])
 788                 sum = FFABS(px) + FFABS(py);
 789             else
 790                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
 791             if (sum > 32) {
 792                 if (get_bits1(&s->gb)) {
 793                     px = A[0];
 794                     py = A[1];
 795                 } else {
 796                     px = C[0];
 797                     py = C[1];
 798                 }
 799             } else {
 800                 if (is_intra[xy - 2])
 801                     sum = FFABS(px) + FFABS(py);
 802                 else
 803                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
 804                 if (sum > 32) {
 805                     if (get_bits1(&s->gb)) {
 806                         px = A[0];
 807                         py = A[1];
 808                     } else {
 809                         px = C[0];
 810                         py = C[1];
 811                     }
 812                 }
 813             }
 814         }
 815         /* store MV using signed modulus of MV range defined in 4.11 */
 816         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
 817         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
 818     }
 819     if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
 820         C   = s->current_picture.motion_val[1][xy - 2];
 821         A   = s->current_picture.motion_val[1][xy - wrap * 2];
 822         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
 823         B   = s->current_picture.motion_val[1][xy - wrap * 2 + off];
 824
 825         if (!s->mb_x)
 826             C[0] = C[1] = 0;
 827         if (!s->first_slice_line) { // predictor A is not out of bounds
 828             if (s->mb_width == 1) {
 829                 px = A[0];
 830                 py = A[1];
 831             } else {
 832                 px = mid_pred(A[0], B[0], C[0]);
 833                 py = mid_pred(A[1], B[1], C[1]);
 834             }
 835         } else if (s->mb_x) { // predictor C is not out of bounds
 836             px = C[0];
 837             py = C[1];
 838         } else {
 839             px = py = 0;
 840         }
 841         /* Pullback MV as specified in 8.3.5.3.4 */
 842         {
 843             int qx, qy, X, Y;
 844             if (v->profile < PROFILE_ADVANCED) {
 845                 qx = (s->mb_x << 5);
 846                 qy = (s->mb_y << 5);
 847                 X  = (s->mb_width  << 5) - 4;
 848                 Y  = (s->mb_height << 5) - 4;
 849                 if (qx + px < -28) px = -28 - qx;
 850                 if (qy + py < -28) py = -28 - qy;
 851                 if (qx + px > X) px = X - qx;
 852                 if (qy + py > Y) py = Y - qy;
 853             } else {
 854                 qx = (s->mb_x << 6);
 855                 qy = (s->mb_y << 6);
 856                 X  = (s->mb_width  << 6) - 4;
 857                 Y  = (s->mb_height << 6) - 4;
 858                 if (qx + px < -60) px = -60 - qx;
 859                 if (qy + py < -60) py = -60 - qy;
 860                 if (qx + px > X) px = X - qx;
 861                 if (qy + py > Y) py = Y - qy;
 862             }
 863         }
 864         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
 865         if (0 && !s->first_slice_line && s->mb_x) {
 866             if (is_intra[xy - wrap])
 867                 sum = FFABS(px) + FFABS(py);
 868             else
 869                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
 870             if (sum > 32) {
 871                 if (get_bits1(&s->gb)) {
 872                     px = A[0];
 873                     py = A[1];
 874                 } else {
 875                     px = C[0];
 876                     py = C[1];
 877                 }
 878             } else {
 879                 if (is_intra[xy - 2])
 880                     sum = FFABS(px) + FFABS(py);
 881                 else
 882                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
 883                 if (sum > 32) {
 884                     if (get_bits1(&s->gb)) {
 885                         px = A[0];
 886                         py = A[1];
 887                     } else {
 888                         px = C[0];
 889                         py = C[1];
 890                     }
 891                 }
 892             }
 893         }
 894         /* store MV using signed modulus of MV range defined in 4.11 */
 895
 896         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
 897         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
 898     }
 899     s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
 900     s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
 901     s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
 902     s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
 903 }
 904
 905 void ff_vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y,
 906                             int mv1, int *pred_flag)
 907 {
 908     int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
 909     MpegEncContext *s = &v->s;
 910     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
 911
 912     if (v->bmvtype == BMV_TYPE_DIRECT) {
 913         int total_opp, k, f;
 914         if (s->next_picture.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
 915             s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
 916                                       v->bfraction, 0, s->quarter_sample);
 917             s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
 918                                       v->bfraction, 0, s->quarter_sample);
 919             s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][0],
 920                                       v->bfraction, 1, s->quarter_sample);
 921             s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][s->block_index[0] + v->blocks_off][1],
 922                                       v->bfraction, 1, s->quarter_sample);
 923
 924             total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
 925                       + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
 926                       + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
 927                       + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
 928             f = (total_opp > 2) ? 1 : 0;
 929         } else {
 930             s->mv[0][0][0] = s->mv[0][0][1] = 0;
 931             s->mv[1][0][0] = s->mv[1][0][1] = 0;
 932             f = 0;
 933         }
 934         v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
 935         for (k = 0; k < 4; k++) {
 936             s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
 937             s->current_picture.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
 938             s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
 939             s->current_picture.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
 940             v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
 941             v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
 942         }
 943         return;
 944     }
 945     if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
 946         ff_vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0],   1, v->range_x, v->range_y, v->mb_type[0], pred_flag[0], 0);
 947         ff_vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1],   1, v->range_x, v->range_y, v->mb_type[0], pred_flag[1], 1);
 948         return;
 949     }
 950     if (dir) { // backward
 951         ff_vc1_pred_mv(v, n, dmv_x[1], dmv_y[1], mv1, v->range_x, v->range_y, v->mb_type[0], pred_flag[1], 1);
 952         if (n == 3 || mv1) {
 953             ff_vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0],   1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
 954         }
 955     } else { // forward
 956         ff_vc1_pred_mv(v, n, dmv_x[0], dmv_y[0], mv1, v->range_x, v->range_y, v->mb_type[0], pred_flag[0], 0);
 957         if (n == 3 || mv1) {
 958             ff_vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1],   1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
 959         }
 960     }
 961 }