git.sesse.net Git - ffmpeg/blob - libavcodec/vc1dec.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 Libav.
   8  *
   9  * Libav 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  * Libav 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 Libav; 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 decoder
  27  */
  28
  29 #include "internal.h"
  30 #include "dsputil.h"
  31 #include "avcodec.h"
  32 #include "mpegvideo.h"
  33 #include "h263.h"
  34 #include "vc1.h"
  35 #include "vc1data.h"
  36 #include "vc1acdata.h"
  37 #include "msmpeg4data.h"
  38 #include "unary.h"
  39 #include "mathops.h"
  40 #include "vdpau_internal.h"
  41
  42 #undef NDEBUG
  43 #include <assert.h>
  44
  45 #define MB_INTRA_VLC_BITS 9
  46 #define DC_VLC_BITS 9
  47
  48
  49 // offset tables for interlaced picture MVDATA decoding
  50 static const int offset_table1[9] = {  0,  1,  2,  4,  8, 16, 32,  64, 128 };
  51 static const int offset_table2[9] = {  0,  1,  3,  7, 15, 31, 63, 127, 255 };
  52
  53 /***********************************************************************/
  54 /**
  55  * @name VC-1 Bitplane decoding
  56  * @see 8.7, p56
  57  * @{
  58  */
  59
  60 /**
  61  * Imode types
  62  * @{
  63  */
  64 enum Imode {
  65     IMODE_RAW,
  66     IMODE_NORM2,
  67     IMODE_DIFF2,
  68     IMODE_NORM6,
  69     IMODE_DIFF6,
  70     IMODE_ROWSKIP,
  71     IMODE_COLSKIP
  72 };
  73 /** @} */ //imode defines
  74
  75
  76 /** @} */ //Bitplane group
  77
  78 static void vc1_put_signed_blocks_clamped(VC1Context *v)
  79 {
  80     MpegEncContext *s = &v->s;
  81     int topleft_mb_pos, top_mb_pos;
  82     int stride_y, fieldtx;
  83     int v_dist;
  84
  85     /* The put pixels loop is always one MB row behind the decoding loop,
  86      * because we can only put pixels when overlap filtering is done, and
  87      * for filtering of the bottom edge of a MB, we need the next MB row
  88      * present as well.
  89      * Within the row, the put pixels loop is also one MB col behind the
  90      * decoding loop. The reason for this is again, because for filtering
  91      * of the right MB edge, we need the next MB present. */
  92     if (!s->first_slice_line) {
  93         if (s->mb_x) {
  94             topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
  95             fieldtx        = v->fieldtx_plane[topleft_mb_pos];
  96             stride_y       = s->linesize << fieldtx;
  97             v_dist         = (16 - fieldtx) >> (fieldtx == 0);
  98             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
  99                                              s->dest[0] - 16 * s->linesize - 16,
 100                                              stride_y);
 101             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
 102                                              s->dest[0] - 16 * s->linesize - 8,
 103                                              stride_y);
 104             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
 105                                              s->dest[0] - v_dist * s->linesize - 16,
 106                                              stride_y);
 107             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
 108                                              s->dest[0] - v_dist * s->linesize - 8,
 109                                              stride_y);
 110             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
 111                                              s->dest[1] - 8 * s->uvlinesize - 8,
 112                                              s->uvlinesize);
 113             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
 114                                              s->dest[2] - 8 * s->uvlinesize - 8,
 115                                              s->uvlinesize);
 116         }
 117         if (s->mb_x == s->mb_width - 1) {
 118             top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
 119             fieldtx    = v->fieldtx_plane[top_mb_pos];
 120             stride_y   = s->linesize << fieldtx;
 121             v_dist     = fieldtx ? 15 : 8;
 122             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
 123                                              s->dest[0] - 16 * s->linesize,
 124                                              stride_y);
 125             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
 126                                              s->dest[0] - 16 * s->linesize + 8,
 127                                              stride_y);
 128             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
 129                                              s->dest[0] - v_dist * s->linesize,
 130                                              stride_y);
 131             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
 132                                              s->dest[0] - v_dist * s->linesize + 8,
 133                                              stride_y);
 134             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
 135                                              s->dest[1] - 8 * s->uvlinesize,
 136                                              s->uvlinesize);
 137             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
 138                                              s->dest[2] - 8 * s->uvlinesize,
 139                                              s->uvlinesize);
 140         }
 141     }
 142
 143 #define inc_blk_idx(idx) do { \
 144         idx++; \
 145         if (idx >= v->n_allocated_blks) \
 146             idx = 0; \
 147     } while (0)
 148
 149     inc_blk_idx(v->topleft_blk_idx);
 150     inc_blk_idx(v->top_blk_idx);
 151     inc_blk_idx(v->left_blk_idx);
 152     inc_blk_idx(v->cur_blk_idx);
 153 }
 154
 155 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
 156 {
 157     MpegEncContext *s = &v->s;
 158     int j;
 159     if (!s->first_slice_line) {
 160         v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
 161         if (s->mb_x)
 162             v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
 163         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
 164         for (j = 0; j < 2; j++) {
 165             v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
 166             if (s->mb_x)
 167                 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
 168         }
 169     }
 170     v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
 171
 172     if (s->mb_y == s->end_mb_y - 1) {
 173         if (s->mb_x) {
 174             v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
 175             v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
 176             v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
 177         }
 178         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
 179     }
 180 }
 181
 182 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
 183 {
 184     MpegEncContext *s = &v->s;
 185     int j;
 186
 187     /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
 188      * means it runs two rows/cols behind the decoding loop. */
 189     if (!s->first_slice_line) {
 190         if (s->mb_x) {
 191             if (s->mb_y >= s->start_mb_y + 2) {
 192                 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
 193
 194                 if (s->mb_x >= 2)
 195                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
 196                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
 197                 for (j = 0; j < 2; j++) {
 198                     v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
 199                     if (s->mb_x >= 2) {
 200                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
 201                     }
 202                 }
 203             }
 204             v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
 205         }
 206
 207         if (s->mb_x == s->mb_width - 1) {
 208             if (s->mb_y >= s->start_mb_y + 2) {
 209                 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
 210
 211                 if (s->mb_x)
 212                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
 213                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
 214                 for (j = 0; j < 2; j++) {
 215                     v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
 216                     if (s->mb_x >= 2) {
 217                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
 218                     }
 219                 }
 220             }
 221             v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
 222         }
 223
 224         if (s->mb_y == s->end_mb_y) {
 225             if (s->mb_x) {
 226                 if (s->mb_x >= 2)
 227                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
 228                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
 229                 if (s->mb_x >= 2) {
 230                     for (j = 0; j < 2; j++) {
 231                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
 232                     }
 233                 }
 234             }
 235
 236             if (s->mb_x == s->mb_width - 1) {
 237                 if (s->mb_x)
 238                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
 239                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
 240                 if (s->mb_x) {
 241                     for (j = 0; j < 2; j++) {
 242                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
 243                     }
 244                 }
 245             }
 246         }
 247     }
 248 }
 249
 250 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
 251 {
 252     MpegEncContext *s = &v->s;
 253     int mb_pos;
 254
 255     if (v->condover == CONDOVER_NONE)
 256         return;
 257
 258     mb_pos = s->mb_x + s->mb_y * s->mb_stride;
 259
 260     /* Within a MB, the horizontal overlap always runs before the vertical.
 261      * To accomplish that, we run the H on left and internal borders of the
 262      * currently decoded MB. Then, we wait for the next overlap iteration
 263      * to do H overlap on the right edge of this MB, before moving over and
 264      * running the V overlap. Therefore, the V overlap makes us trail by one
 265      * MB col and the H overlap filter makes us trail by one MB row. This
 266      * is reflected in the time at which we run the put_pixels loop. */
 267     if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
 268         if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
 269                         v->over_flags_plane[mb_pos - 1])) {
 270             v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
 271                                       v->block[v->cur_blk_idx][0]);
 272             v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
 273                                       v->block[v->cur_blk_idx][2]);
 274             if (!(s->flags & CODEC_FLAG_GRAY)) {
 275                 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
 276                                           v->block[v->cur_blk_idx][4]);
 277                 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
 278                                           v->block[v->cur_blk_idx][5]);
 279             }
 280         }
 281         v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
 282                                   v->block[v->cur_blk_idx][1]);
 283         v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
 284                                   v->block[v->cur_blk_idx][3]);
 285
 286         if (s->mb_x == s->mb_width - 1) {
 287             if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
 288                                          v->over_flags_plane[mb_pos - s->mb_stride])) {
 289                 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
 290                                           v->block[v->cur_blk_idx][0]);
 291                 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
 292                                           v->block[v->cur_blk_idx][1]);
 293                 if (!(s->flags & CODEC_FLAG_GRAY)) {
 294                     v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
 295                                               v->block[v->cur_blk_idx][4]);
 296                     v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
 297                                               v->block[v->cur_blk_idx][5]);
 298                 }
 299             }
 300             v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
 301                                       v->block[v->cur_blk_idx][2]);
 302             v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
 303                                       v->block[v->cur_blk_idx][3]);
 304         }
 305     }
 306     if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
 307         if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
 308                                      v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
 309             v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
 310                                       v->block[v->left_blk_idx][0]);
 311             v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
 312                                       v->block[v->left_blk_idx][1]);
 313             if (!(s->flags & CODEC_FLAG_GRAY)) {
 314                 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
 315                                           v->block[v->left_blk_idx][4]);
 316                 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
 317                                           v->block[v->left_blk_idx][5]);
 318             }
 319         }
 320         v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
 321                                   v->block[v->left_blk_idx][2]);
 322         v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
 323                                   v->block[v->left_blk_idx][3]);
 324     }
 325 }
 326
 327 /** Do motion compensation over 1 macroblock
 328  * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
 329  */
 330 static void vc1_mc_1mv(VC1Context *v, int dir)
 331 {
 332     MpegEncContext *s = &v->s;
 333     DSPContext *dsp   = &v->s.dsp;
 334     uint8_t *srcY, *srcU, *srcV;
 335     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
 336     int off, off_uv;
 337     int v_edge_pos = s->v_edge_pos >> v->field_mode;
 338
 339     if ((!v->field_mode ||
 340          (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
 341         !v->s.last_picture.f.data[0])
 342         return;
 343
 344     mx = s->mv[dir][0][0];
 345     my = s->mv[dir][0][1];
 346
 347     // store motion vectors for further use in B frames
 348     if (s->pict_type == AV_PICTURE_TYPE_P) {
 349         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = mx;
 350         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = my;
 351     }
 352
 353     uvmx = (mx + ((mx & 3) == 3)) >> 1;
 354     uvmy = (my + ((my & 3) == 3)) >> 1;
 355     v->luma_mv[s->mb_x][0] = uvmx;
 356     v->luma_mv[s->mb_x][1] = uvmy;
 357
 358     if (v->field_mode &&
 359         v->cur_field_type != v->ref_field_type[dir]) {
 360         my   = my   - 2 + 4 * v->cur_field_type;
 361         uvmy = uvmy - 2 + 4 * v->cur_field_type;
 362     }
 363
 364     // fastuvmc shall be ignored for interlaced frame picture
 365     if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
 366         uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
 367         uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
 368     }
 369     if (v->field_mode) { // interlaced field picture
 370         if (!dir) {
 371             if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type) {
 372                 srcY = s->current_picture.f.data[0];
 373                 srcU = s->current_picture.f.data[1];
 374                 srcV = s->current_picture.f.data[2];
 375             } else {
 376                 srcY = s->last_picture.f.data[0];
 377                 srcU = s->last_picture.f.data[1];
 378                 srcV = s->last_picture.f.data[2];
 379             }
 380         } else {
 381             srcY = s->next_picture.f.data[0];
 382             srcU = s->next_picture.f.data[1];
 383             srcV = s->next_picture.f.data[2];
 384         }
 385     } else {
 386         if (!dir) {
 387             srcY = s->last_picture.f.data[0];
 388             srcU = s->last_picture.f.data[1];
 389             srcV = s->last_picture.f.data[2];
 390         } else {
 391             srcY = s->next_picture.f.data[0];
 392             srcU = s->next_picture.f.data[1];
 393             srcV = s->next_picture.f.data[2];
 394         }
 395     }
 396
 397     src_x   = s->mb_x * 16 + (mx   >> 2);
 398     src_y   = s->mb_y * 16 + (my   >> 2);
 399     uvsrc_x = s->mb_x *  8 + (uvmx >> 2);
 400     uvsrc_y = s->mb_y *  8 + (uvmy >> 2);
 401
 402     if (v->profile != PROFILE_ADVANCED) {
 403         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
 404         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
 405         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
 406         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
 407     } else {
 408         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
 409         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
 410         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
 411         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
 412     }
 413
 414     srcY += src_y   * s->linesize   + src_x;
 415     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
 416     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
 417
 418     if (v->field_mode && v->ref_field_type[dir]) {
 419         srcY += s->current_picture_ptr->f.linesize[0];
 420         srcU += s->current_picture_ptr->f.linesize[1];
 421         srcV += s->current_picture_ptr->f.linesize[2];
 422     }
 423
 424     /* for grayscale we should not try to read from unknown area */
 425     if (s->flags & CODEC_FLAG_GRAY) {
 426         srcU = s->edge_emu_buffer + 18 * s->linesize;
 427         srcV = s->edge_emu_buffer + 18 * s->linesize;
 428     }
 429
 430     if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
 431         || s->h_edge_pos < 22 || v_edge_pos < 22
 432         || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
 433         || (unsigned)(src_y - s->mspel) > v_edge_pos    - (my&3) - 16 - s->mspel * 3) {
 434         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
 435
 436         srcY -= s->mspel * (1 + s->linesize);
 437         s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
 438                                 17 + s->mspel * 2, 17 + s->mspel * 2,
 439                                 src_x - s->mspel, src_y - s->mspel,
 440                                 s->h_edge_pos, v_edge_pos);
 441         srcY = s->edge_emu_buffer;
 442         s->dsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
 443                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
 444         s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
 445                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
 446         srcU = uvbuf;
 447         srcV = uvbuf + 16;
 448         /* if we deal with range reduction we need to scale source blocks */
 449         if (v->rangeredfrm) {
 450             int i, j;
 451             uint8_t *src, *src2;
 452
 453             src = srcY;
 454             for (j = 0; j < 17 + s->mspel * 2; j++) {
 455                 for (i = 0; i < 17 + s->mspel * 2; i++)
 456                     src[i] = ((src[i] - 128) >> 1) + 128;
 457                 src += s->linesize;
 458             }
 459             src  = srcU;
 460             src2 = srcV;
 461             for (j = 0; j < 9; j++) {
 462                 for (i = 0; i < 9; i++) {
 463                     src[i]  = ((src[i]  - 128) >> 1) + 128;
 464                     src2[i] = ((src2[i] - 128) >> 1) + 128;
 465                 }
 466                 src  += s->uvlinesize;
 467                 src2 += s->uvlinesize;
 468             }
 469         }
 470         /* if we deal with intensity compensation we need to scale source blocks */
 471         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 472             int i, j;
 473             uint8_t *src, *src2;
 474
 475             src = srcY;
 476             for (j = 0; j < 17 + s->mspel * 2; j++) {
 477                 for (i = 0; i < 17 + s->mspel * 2; i++)
 478                     src[i] = v->luty[src[i]];
 479                 src += s->linesize;
 480             }
 481             src  = srcU;
 482             src2 = srcV;
 483             for (j = 0; j < 9; j++) {
 484                 for (i = 0; i < 9; i++) {
 485                     src[i]  = v->lutuv[src[i]];
 486                     src2[i] = v->lutuv[src2[i]];
 487                 }
 488                 src  += s->uvlinesize;
 489                 src2 += s->uvlinesize;
 490             }
 491         }
 492         srcY += s->mspel * (1 + s->linesize);
 493     }
 494
 495     if (v->field_mode && v->cur_field_type) {
 496         off    = s->current_picture_ptr->f.linesize[0];
 497         off_uv = s->current_picture_ptr->f.linesize[1];
 498     } else {
 499         off    = 0;
 500         off_uv = 0;
 501     }
 502     if (s->mspel) {
 503         dxy = ((my & 3) << 2) | (mx & 3);
 504         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off    , srcY    , s->linesize, v->rnd);
 505         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
 506         srcY += s->linesize * 8;
 507         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
 508         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
 509     } else { // hpel mc - always used for luma
 510         dxy = (my & 2) | ((mx & 2) >> 1);
 511         if (!v->rnd)
 512             dsp->put_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
 513         else
 514             dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
 515     }
 516
 517     if (s->flags & CODEC_FLAG_GRAY) return;
 518     /* Chroma MC always uses qpel bilinear */
 519     uvmx = (uvmx & 3) << 1;
 520     uvmy = (uvmy & 3) << 1;
 521     if (!v->rnd) {
 522         dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
 523         dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
 524     } else {
 525         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
 526         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
 527     }
 528 }
 529
 530 static inline int median4(int a, int b, int c, int d)
 531 {
 532     if (a < b) {
 533         if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
 534         else       return (FFMIN(b, c) + FFMAX(a, d)) / 2;
 535     } else {
 536         if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
 537         else       return (FFMIN(a, c) + FFMAX(b, d)) / 2;
 538     }
 539 }
 540
 541 /** Do motion compensation for 4-MV macroblock - luminance block
 542  */
 543 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
 544 {
 545     MpegEncContext *s = &v->s;
 546     DSPContext *dsp = &v->s.dsp;
 547     uint8_t *srcY;
 548     int dxy, mx, my, src_x, src_y;
 549     int off;
 550     int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
 551     int v_edge_pos = s->v_edge_pos >> v->field_mode;
 552
 553     if ((!v->field_mode ||
 554          (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
 555         !v->s.last_picture.f.data[0])
 556         return;
 557
 558     mx = s->mv[dir][n][0];
 559     my = s->mv[dir][n][1];
 560
 561     if (!dir) {
 562         if (v->field_mode) {
 563             if ((v->cur_field_type != v->ref_field_type[dir]) && v->cur_field_type)
 564                 srcY = s->current_picture.f.data[0];
 565             else
 566                 srcY = s->last_picture.f.data[0];
 567         } else
 568             srcY = s->last_picture.f.data[0];
 569     } else
 570         srcY = s->next_picture.f.data[0];
 571
 572     if (v->field_mode) {
 573         if (v->cur_field_type != v->ref_field_type[dir])
 574             my = my - 2 + 4 * v->cur_field_type;
 575     }
 576
 577     if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
 578         int same_count = 0, opp_count = 0, k;
 579         int chosen_mv[2][4][2], f;
 580         int tx, ty;
 581         for (k = 0; k < 4; k++) {
 582             f = v->mv_f[0][s->block_index[k] + v->blocks_off];
 583             chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
 584             chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
 585             opp_count  += f;
 586             same_count += 1 - f;
 587         }
 588         f = opp_count > same_count;
 589         switch (f ? opp_count : same_count) {
 590         case 4:
 591             tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
 592                          chosen_mv[f][2][0], chosen_mv[f][3][0]);
 593             ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
 594                          chosen_mv[f][2][1], chosen_mv[f][3][1]);
 595             break;
 596         case 3:
 597             tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
 598             ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
 599             break;
 600         case 2:
 601             tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
 602             ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
 603             break;
 604         }
 605         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
 606         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
 607         for (k = 0; k < 4; k++)
 608             v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
 609     }
 610
 611     if (v->fcm == ILACE_FRAME) {  // not sure if needed for other types of picture
 612         int qx, qy;
 613         int width  = s->avctx->coded_width;
 614         int height = s->avctx->coded_height >> 1;
 615         qx = (s->mb_x * 16) + (mx >> 2);
 616         qy = (s->mb_y *  8) + (my >> 3);
 617
 618         if (qx < -17)
 619             mx -= 4 * (qx + 17);
 620         else if (qx > width)
 621             mx -= 4 * (qx - width);
 622         if (qy < -18)
 623             my -= 8 * (qy + 18);
 624         else if (qy > height + 1)
 625             my -= 8 * (qy - height - 1);
 626     }
 627
 628     if ((v->fcm == ILACE_FRAME) && fieldmv)
 629         off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
 630     else
 631         off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
 632     if (v->field_mode && v->cur_field_type)
 633         off += s->current_picture_ptr->f.linesize[0];
 634
 635     src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
 636     if (!fieldmv)
 637         src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
 638     else
 639         src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
 640
 641     if (v->profile != PROFILE_ADVANCED) {
 642         src_x = av_clip(src_x, -16, s->mb_width  * 16);
 643         src_y = av_clip(src_y, -16, s->mb_height * 16);
 644     } else {
 645         src_x = av_clip(src_x, -17, s->avctx->coded_width);
 646         if (v->fcm == ILACE_FRAME) {
 647             if (src_y & 1)
 648                 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
 649             else
 650                 src_y = av_clip(src_y, -18, s->avctx->coded_height);
 651         } else {
 652             src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
 653         }
 654     }
 655
 656     srcY += src_y * s->linesize + src_x;
 657     if (v->field_mode && v->ref_field_type[dir])
 658         srcY += s->current_picture_ptr->f.linesize[0];
 659
 660     if (fieldmv && !(src_y & 1))
 661         v_edge_pos--;
 662     if (fieldmv && (src_y & 1) && src_y < 4)
 663         src_y--;
 664     if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
 665         || s->h_edge_pos < 13 || v_edge_pos < 23
 666         || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
 667         || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
 668         srcY -= s->mspel * (1 + (s->linesize << fieldmv));
 669         /* check emulate edge stride and offset */
 670         s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
 671                                 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
 672                                 src_x - s->mspel, src_y - (s->mspel << fieldmv),
 673                                 s->h_edge_pos, v_edge_pos);
 674         srcY = s->edge_emu_buffer;
 675         /* if we deal with range reduction we need to scale source blocks */
 676         if (v->rangeredfrm) {
 677             int i, j;
 678             uint8_t *src;
 679
 680             src = srcY;
 681             for (j = 0; j < 9 + s->mspel * 2; j++) {
 682                 for (i = 0; i < 9 + s->mspel * 2; i++)
 683                     src[i] = ((src[i] - 128) >> 1) + 128;
 684                 src += s->linesize << fieldmv;
 685             }
 686         }
 687         /* if we deal with intensity compensation we need to scale source blocks */
 688         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 689             int i, j;
 690             uint8_t *src;
 691
 692             src = srcY;
 693             for (j = 0; j < 9 + s->mspel * 2; j++) {
 694                 for (i = 0; i < 9 + s->mspel * 2; i++)
 695                     src[i] = v->luty[src[i]];
 696                 src += s->linesize << fieldmv;
 697             }
 698         }
 699         srcY += s->mspel * (1 + (s->linesize << fieldmv));
 700     }
 701
 702     if (s->mspel) {
 703         dxy = ((my & 3) << 2) | (mx & 3);
 704         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
 705     } else { // hpel mc - always used for luma
 706         dxy = (my & 2) | ((mx & 2) >> 1);
 707         if (!v->rnd)
 708             dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
 709         else
 710             dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
 711     }
 712 }
 713
 714 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
 715 {
 716     int idx, i;
 717     static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
 718
 719     idx =  ((a[3] != flag) << 3)
 720          | ((a[2] != flag) << 2)
 721          | ((a[1] != flag) << 1)
 722          |  (a[0] != flag);
 723     if (!idx) {
 724         *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
 725         *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
 726         return 4;
 727     } else if (count[idx] == 1) {
 728         switch (idx) {
 729         case 0x1:
 730             *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
 731             *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
 732             return 3;
 733         case 0x2:
 734             *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
 735             *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
 736             return 3;
 737         case 0x4:
 738             *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
 739             *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
 740             return 3;
 741         case 0x8:
 742             *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
 743             *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
 744             return 3;
 745         }
 746     } else if (count[idx] == 2) {
 747         int t1 = 0, t2 = 0;
 748         for (i = 0; i < 3; i++)
 749             if (!a[i]) {
 750                 t1 = i;
 751                 break;
 752             }
 753         for (i = t1 + 1; i < 4; i++)
 754             if (!a[i]) {
 755                 t2 = i;
 756                 break;
 757             }
 758         *tx = (mvx[t1] + mvx[t2]) / 2;
 759         *ty = (mvy[t1] + mvy[t2]) / 2;
 760         return 2;
 761     } else {
 762         return 0;
 763     }
 764     return -1;
 765 }
 766
 767 /** Do motion compensation for 4-MV macroblock - both chroma blocks
 768  */
 769 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
 770 {
 771     MpegEncContext *s = &v->s;
 772     DSPContext *dsp   = &v->s.dsp;
 773     uint8_t *srcU, *srcV;
 774     int uvmx, uvmy, uvsrc_x, uvsrc_y;
 775     int k, tx = 0, ty = 0;
 776     int mvx[4], mvy[4], intra[4], mv_f[4];
 777     int valid_count;
 778     int chroma_ref_type = v->cur_field_type, off = 0;
 779     int v_edge_pos = s->v_edge_pos >> v->field_mode;
 780
 781     if (!v->field_mode && !v->s.last_picture.f.data[0])
 782         return;
 783     if (s->flags & CODEC_FLAG_GRAY)
 784         return;
 785
 786     for (k = 0; k < 4; k++) {
 787         mvx[k] = s->mv[dir][k][0];
 788         mvy[k] = s->mv[dir][k][1];
 789         intra[k] = v->mb_type[0][s->block_index[k]];
 790         if (v->field_mode)
 791             mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
 792     }
 793
 794     /* calculate chroma MV vector from four luma MVs */
 795     if (!v->field_mode || (v->field_mode && !v->numref)) {
 796         valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
 797         if (!valid_count) {
 798             s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
 799             s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
 800             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
 801             return; //no need to do MC for intra blocks
 802         }
 803     } else {
 804         int dominant = 0;
 805         if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
 806             dominant = 1;
 807         valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
 808         if (dominant)
 809             chroma_ref_type = !v->cur_field_type;
 810     }
 811     if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
 812         return;
 813     s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
 814     s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
 815     uvmx = (tx + ((tx & 3) == 3)) >> 1;
 816     uvmy = (ty + ((ty & 3) == 3)) >> 1;
 817
 818     v->luma_mv[s->mb_x][0] = uvmx;
 819     v->luma_mv[s->mb_x][1] = uvmy;
 820
 821     if (v->fastuvmc) {
 822         uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
 823         uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
 824     }
 825     // Field conversion bias
 826     if (v->cur_field_type != chroma_ref_type)
 827         uvmy += 2 - 4 * chroma_ref_type;
 828
 829     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
 830     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
 831
 832     if (v->profile != PROFILE_ADVANCED) {
 833         uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width  * 8);
 834         uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
 835     } else {
 836         uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width  >> 1);
 837         uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
 838     }
 839
 840     if (!dir) {
 841         if (v->field_mode) {
 842             if ((v->cur_field_type != chroma_ref_type) && v->cur_field_type) {
 843                 srcU = s->current_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
 844                 srcV = s->current_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
 845             } else {
 846                 srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
 847                 srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
 848             }
 849         } else {
 850             srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
 851             srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
 852         }
 853     } else {
 854         srcU = s->next_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
 855         srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
 856     }
 857
 858     if (v->field_mode) {
 859         if (chroma_ref_type) {
 860             srcU += s->current_picture_ptr->f.linesize[1];
 861             srcV += s->current_picture_ptr->f.linesize[2];
 862         }
 863         off = v->cur_field_type ? s->current_picture_ptr->f.linesize[1] : 0;
 864     }
 865
 866     if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
 867         || s->h_edge_pos < 18 || v_edge_pos < 18
 868         || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
 869         || (unsigned)uvsrc_y > (v_edge_pos    >> 1) - 9) {
 870         s->dsp.emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize,
 871                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
 872                                 s->h_edge_pos >> 1, v_edge_pos >> 1);
 873         s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
 874                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
 875                                 s->h_edge_pos >> 1, v_edge_pos >> 1);
 876         srcU = s->edge_emu_buffer;
 877         srcV = s->edge_emu_buffer + 16;
 878
 879         /* if we deal with range reduction we need to scale source blocks */
 880         if (v->rangeredfrm) {
 881             int i, j;
 882             uint8_t *src, *src2;
 883
 884             src  = srcU;
 885             src2 = srcV;
 886             for (j = 0; j < 9; j++) {
 887                 for (i = 0; i < 9; i++) {
 888                     src[i]  = ((src[i]  - 128) >> 1) + 128;
 889                     src2[i] = ((src2[i] - 128) >> 1) + 128;
 890                 }
 891                 src  += s->uvlinesize;
 892                 src2 += s->uvlinesize;
 893             }
 894         }
 895         /* if we deal with intensity compensation we need to scale source blocks */
 896         if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 897             int i, j;
 898             uint8_t *src, *src2;
 899
 900             src  = srcU;
 901             src2 = srcV;
 902             for (j = 0; j < 9; j++) {
 903                 for (i = 0; i < 9; i++) {
 904                     src[i]  = v->lutuv[src[i]];
 905                     src2[i] = v->lutuv[src2[i]];
 906                 }
 907                 src  += s->uvlinesize;
 908                 src2 += s->uvlinesize;
 909             }
 910         }
 911     }
 912
 913     /* Chroma MC always uses qpel bilinear */
 914     uvmx = (uvmx & 3) << 1;
 915     uvmy = (uvmy & 3) << 1;
 916     if (!v->rnd) {
 917         dsp->put_h264_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
 918         dsp->put_h264_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
 919     } else {
 920         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off, srcU, s->uvlinesize, 8, uvmx, uvmy);
 921         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off, srcV, s->uvlinesize, 8, uvmx, uvmy);
 922     }
 923 }
 924
 925 /** Do motion compensation for 4-MV field chroma macroblock (both U and V)
 926  */
 927 static void vc1_mc_4mv_chroma4(VC1Context *v)
 928 {
 929     MpegEncContext *s = &v->s;
 930     DSPContext *dsp = &v->s.dsp;
 931     uint8_t *srcU, *srcV;
 932     int uvsrc_x, uvsrc_y;
 933     int uvmx_field[4], uvmy_field[4];
 934     int i, off, tx, ty;
 935     int fieldmv = v->blk_mv_type[s->block_index[0]];
 936     static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
 937     int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
 938     int v_edge_pos = s->v_edge_pos >> 1;
 939
 940     if (!v->s.last_picture.f.data[0])
 941         return;
 942     if (s->flags & CODEC_FLAG_GRAY)
 943         return;
 944
 945     for (i = 0; i < 4; i++) {
 946         tx = s->mv[0][i][0];
 947         uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
 948         ty = s->mv[0][i][1];
 949         if (fieldmv)
 950             uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
 951         else
 952             uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
 953     }
 954
 955     for (i = 0; i < 4; i++) {
 956         off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
 957         uvsrc_x = s->mb_x * 8 +  (i & 1) * 4           + (uvmx_field[i] >> 2);
 958         uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
 959         // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
 960         uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width  >> 1);
 961         uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
 962         srcU = s->last_picture.f.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
 963         srcV = s->last_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
 964         uvmx_field[i] = (uvmx_field[i] & 3) << 1;
 965         uvmy_field[i] = (uvmy_field[i] & 3) << 1;
 966
 967         if (fieldmv && !(uvsrc_y & 1))
 968             v_edge_pos--;
 969         if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
 970             uvsrc_y--;
 971         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP)
 972             || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
 973             || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
 974             || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
 975             s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
 976                                     5, (5 << fieldmv), uvsrc_x, uvsrc_y,
 977                                     s->h_edge_pos >> 1, v_edge_pos);
 978             s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
 979                                     5, (5 << fieldmv), uvsrc_x, uvsrc_y,
 980                                     s->h_edge_pos >> 1, v_edge_pos);
 981             srcU = s->edge_emu_buffer;
 982             srcV = s->edge_emu_buffer + 16;
 983
 984             /* if we deal with intensity compensation we need to scale source blocks */
 985             if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 986                 int i, j;
 987                 uint8_t *src, *src2;
 988
 989                 src  = srcU;
 990                 src2 = srcV;
 991                 for (j = 0; j < 5; j++) {
 992                     for (i = 0; i < 5; i++) {
 993                         src[i]  = v->lutuv[src[i]];
 994                         src2[i] = v->lutuv[src2[i]];
 995                     }
 996                     src  += s->uvlinesize << 1;
 997                     src2 += s->uvlinesize << 1;
 998                 }
 999             }
1000         }
1001         if (!v->rnd) {
1002             dsp->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1003             dsp->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1004         } else {
1005             v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1006             v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1007         }
1008     }
1009 }
1010
1011 /***********************************************************************/
1012 /**
1013  * @name VC-1 Block-level functions
1014  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1015  * @{
1016  */
1017
1018 /**
1019  * @def GET_MQUANT
1020  * @brief Get macroblock-level quantizer scale
1021  */
1022 #define GET_MQUANT()                                           \
1023     if (v->dquantfrm) {                                        \
1024         int edges = 0;                                         \
1025         if (v->dqprofile == DQPROFILE_ALL_MBS) {               \
1026             if (v->dqbilevel) {                                \
1027                 mquant = (get_bits1(gb)) ? v->altpq : v->pq;   \
1028             } else {                                           \
1029                 mqdiff = get_bits(gb, 3);                      \
1030                 if (mqdiff != 7)                               \
1031                     mquant = v->pq + mqdiff;                   \
1032                 else                                           \
1033                     mquant = get_bits(gb, 5);                  \
1034             }                                                  \
1035         }                                                      \
1036         if (v->dqprofile == DQPROFILE_SINGLE_EDGE)             \
1037             edges = 1 << v->dqsbedge;                          \
1038         else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES)       \
1039             edges = (3 << v->dqsbedge) % 15;                   \
1040         else if (v->dqprofile == DQPROFILE_FOUR_EDGES)         \
1041             edges = 15;                                        \
1042         if ((edges&1) && !s->mb_x)                             \
1043             mquant = v->altpq;                                 \
1044         if ((edges&2) && s->first_slice_line)                  \
1045             mquant = v->altpq;                                 \
1046         if ((edges&4) && s->mb_x == (s->mb_width - 1))         \
1047             mquant = v->altpq;                                 \
1048         if ((edges&8) && s->mb_y == (s->mb_height - 1))        \
1049             mquant = v->altpq;                                 \
1050         if (!mquant || mquant > 31) {                          \
1051             av_log(v->s.avctx, AV_LOG_ERROR,                   \
1052                    "Overriding invalid mquant %d\n", mquant);  \
1053             mquant = 1;                                        \
1054         }                                                      \
1055     }
1056
1057 /**
1058  * @def GET_MVDATA(_dmv_x, _dmv_y)
1059  * @brief Get MV differentials
1060  * @see MVDATA decoding from 8.3.5.2, p(1)20
1061  * @param _dmv_x Horizontal differential for decoded MV
1062  * @param _dmv_y Vertical differential for decoded MV
1063  */
1064 #define GET_MVDATA(_dmv_x, _dmv_y)                                      \
1065     index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1066                          VC1_MV_DIFF_VLC_BITS, 2);                      \
1067     if (index > 36) {                                                   \
1068         mb_has_coeffs = 1;                                              \
1069         index -= 37;                                                    \
1070     } else                                                              \
1071         mb_has_coeffs = 0;                                              \
1072     s->mb_intra = 0;                                                    \
1073     if (!index) {                                                       \
1074         _dmv_x = _dmv_y = 0;                                            \
1075     } else if (index == 35) {                                           \
1076         _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1077         _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1078     } else if (index == 36) {                                           \
1079         _dmv_x = 0;                                                     \
1080         _dmv_y = 0;                                                     \
1081         s->mb_intra = 1;                                                \
1082     } else {                                                            \
1083         index1 = index % 6;                                             \
1084         if (!s->quarter_sample && index1 == 5) val = 1;                 \
1085         else                                   val = 0;                 \
1086         if (size_table[index1] - val > 0)                               \
1087             val = get_bits(gb, size_table[index1] - val);               \
1088         else                                   val = 0;                 \
1089         sign = 0 - (val&1);                                             \
1090         _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1091                                                                         \
1092         index1 = index / 6;                                             \
1093         if (!s->quarter_sample && index1 == 5) val = 1;                 \
1094         else                                   val = 0;                 \
1095         if (size_table[index1] - val > 0)                               \
1096             val = get_bits(gb, size_table[index1] - val);               \
1097         else                                   val = 0;                 \
1098         sign = 0 - (val & 1);                                           \
1099         _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign;   \
1100     }
1101
1102 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1103                                                    int *dmv_y, int *pred_flag)
1104 {
1105     int index, index1;
1106     int extend_x = 0, extend_y = 0;
1107     GetBitContext *gb = &v->s.gb;
1108     int bits, esc;
1109     int val, sign;
1110     const int* offs_tab;
1111
1112     if (v->numref) {
1113         bits = VC1_2REF_MVDATA_VLC_BITS;
1114         esc  = 125;
1115     } else {
1116         bits = VC1_1REF_MVDATA_VLC_BITS;
1117         esc  = 71;
1118     }
1119     switch (v->dmvrange) {
1120     case 1:
1121         extend_x = 1;
1122         break;
1123     case 2:
1124         extend_y = 1;
1125         break;
1126     case 3:
1127         extend_x = extend_y = 1;
1128         break;
1129     }
1130     index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1131     if (index == esc) {
1132         *dmv_x = get_bits(gb, v->k_x);
1133         *dmv_y = get_bits(gb, v->k_y);
1134         if (v->numref) {
1135             *pred_flag = *dmv_y & 1;
1136             *dmv_y     = (*dmv_y + *pred_flag) >> 1;
1137         }
1138     }
1139     else {
1140         if (extend_x)
1141             offs_tab = offset_table2;
1142         else
1143             offs_tab = offset_table1;
1144         index1 = (index + 1) % 9;
1145         if (index1 != 0) {
1146             val    = get_bits(gb, index1 + extend_x);
1147             sign   = 0 -(val & 1);
1148             *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1149         } else
1150             *dmv_x = 0;
1151         if (extend_y)
1152             offs_tab = offset_table2;
1153         else
1154             offs_tab = offset_table1;
1155         index1 = (index + 1) / 9;
1156         if (index1 > v->numref) {
1157             val    = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1158             sign   = 0 - (val & 1);
1159             *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1160         } else
1161             *dmv_y = 0;
1162         if (v->numref)
1163             *pred_flag = index1 & 1;
1164     }
1165 }
1166
1167 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1168 {
1169     int scaledvalue, refdist;
1170     int scalesame1, scalesame2;
1171     int scalezone1_x, zone1offset_x;
1172     int table_index = dir ^ v->second_field;
1173
1174     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1175         refdist = v->refdist;
1176     else
1177         refdist = dir ? v->brfd : v->frfd;
1178     if (refdist > 3)
1179         refdist = 3;
1180     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1181     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1182     scalezone1_x  = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1183     zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1184
1185     if (FFABS(n) > 255)
1186         scaledvalue = n;
1187     else {
1188         if (FFABS(n) < scalezone1_x)
1189             scaledvalue = (n * scalesame1) >> 8;
1190         else {
1191             if (n < 0)
1192                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1193             else
1194                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1195         }
1196     }
1197     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1198 }
1199
1200 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1201 {
1202     int scaledvalue, refdist;
1203     int scalesame1, scalesame2;
1204     int scalezone1_y, zone1offset_y;
1205     int table_index = dir ^ v->second_field;
1206
1207     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1208         refdist = v->refdist;
1209     else
1210         refdist = dir ? v->brfd : v->frfd;
1211     if (refdist > 3)
1212         refdist = 3;
1213     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1214     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1215     scalezone1_y  = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1216     zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1217
1218     if (FFABS(n) > 63)
1219         scaledvalue = n;
1220     else {
1221         if (FFABS(n) < scalezone1_y)
1222             scaledvalue = (n * scalesame1) >> 8;
1223         else {
1224             if (n < 0)
1225                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1226             else
1227                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1228         }
1229     }
1230
1231     if (v->cur_field_type && !v->ref_field_type[dir])
1232         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1233     else
1234         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1235 }
1236
1237 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1238 {
1239     int scalezone1_x, zone1offset_x;
1240     int scaleopp1, scaleopp2, brfd;
1241     int scaledvalue;
1242
1243     brfd = FFMIN(v->brfd, 3);
1244     scalezone1_x  = ff_vc1_b_field_mvpred_scales[3][brfd];
1245     zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1246     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
1247     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1248
1249     if (FFABS(n) > 255)
1250         scaledvalue = n;
1251     else {
1252         if (FFABS(n) < scalezone1_x)
1253             scaledvalue = (n * scaleopp1) >> 8;
1254         else {
1255             if (n < 0)
1256                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1257             else
1258                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1259         }
1260     }
1261     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1262 }
1263
1264 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1265 {
1266     int scalezone1_y, zone1offset_y;
1267     int scaleopp1, scaleopp2, brfd;
1268     int scaledvalue;
1269
1270     brfd = FFMIN(v->brfd, 3);
1271     scalezone1_y  = ff_vc1_b_field_mvpred_scales[4][brfd];
1272     zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1273     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
1274     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1275
1276     if (FFABS(n) > 63)
1277         scaledvalue = n;
1278     else {
1279         if (FFABS(n) < scalezone1_y)
1280             scaledvalue = (n * scaleopp1) >> 8;
1281         else {
1282             if (n < 0)
1283                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1284             else
1285                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1286         }
1287     }
1288     if (v->cur_field_type && !v->ref_field_type[dir]) {
1289         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1290     } else {
1291         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1292     }
1293 }
1294
1295 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1296                                          int dim, int dir)
1297 {
1298     int brfd, scalesame;
1299     int hpel = 1 - v->s.quarter_sample;
1300
1301     n >>= hpel;
1302     if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1303         if (dim)
1304             n = scaleforsame_y(v, i, n, dir) << hpel;
1305         else
1306             n = scaleforsame_x(v, n, dir) << hpel;
1307         return n;
1308     }
1309     brfd      = FFMIN(v->brfd, 3);
1310     scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1311
1312     n = (n * scalesame >> 8) << hpel;
1313     return n;
1314 }
1315
1316 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1317                                         int dim, int dir)
1318 {
1319     int refdist, scaleopp;
1320     int hpel = 1 - v->s.quarter_sample;
1321
1322     n >>= hpel;
1323     if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1324         if (dim)
1325             n = scaleforopp_y(v, n, dir) << hpel;
1326         else
1327             n = scaleforopp_x(v, n) << hpel;
1328         return n;
1329     }
1330     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1331         refdist = FFMIN(v->refdist, 3);
1332     else
1333         refdist = dir ? v->brfd : v->frfd;
1334     scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1335
1336     n = (n * scaleopp >> 8) << hpel;
1337     return n;
1338 }
1339
1340 /** Predict and set motion vector
1341  */
1342 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1343                                int mv1, int r_x, int r_y, uint8_t* is_intra,
1344                                int pred_flag, int dir)
1345 {
1346     MpegEncContext *s = &v->s;
1347     int xy, wrap, off = 0;
1348     int16_t *A, *B, *C;
1349     int px, py;
1350     int sum;
1351     int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1352     int opposit, a_f, b_f, c_f;
1353     int16_t field_predA[2];
1354     int16_t field_predB[2];
1355     int16_t field_predC[2];
1356     int a_valid, b_valid, c_valid;
1357     int hybridmv_thresh, y_bias = 0;
1358
1359     if (v->mv_mode == MV_PMODE_MIXED_MV ||
1360         ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1361         mixedmv_pic = 1;
1362     else
1363         mixedmv_pic = 0;
1364     /* scale MV difference to be quad-pel */
1365     dmv_x <<= 1 - s->quarter_sample;
1366     dmv_y <<= 1 - s->quarter_sample;
1367
1368     wrap = s->b8_stride;
1369     xy   = s->block_index[n];
1370
1371     if (s->mb_intra) {
1372         s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = 0;
1373         s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = 0;
1374         s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = 0;
1375         s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
1376         if (mv1) { /* duplicate motion data for 1-MV block */
1377             s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][0]        = 0;
1378             s->current_picture.f.motion_val[0][xy + 1 + v->blocks_off][1]        = 0;
1379             s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][0]     = 0;
1380             s->current_picture.f.motion_val[0][xy + wrap + v->blocks_off][1]     = 0;
1381             s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1382             s->current_picture.f.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1383             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1384             s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][0]        = 0;
1385             s->current_picture.f.motion_val[1][xy + 1 + v->blocks_off][1]        = 0;
1386             s->current_picture.f.motion_val[1][xy + wrap][0]                     = 0;
1387             s->current_picture.f.motion_val[1][xy + wrap + v->blocks_off][1]     = 0;
1388             s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1389             s->current_picture.f.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1390         }
1391         return;
1392     }
1393
1394     C = s->current_picture.f.motion_val[dir][xy -    1 + v->blocks_off];
1395     A = s->current_picture.f.motion_val[dir][xy - wrap + v->blocks_off];
1396     if (mv1) {
1397         if (v->field_mode && mixedmv_pic)
1398             off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1399         else
1400             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1401     } else {
1402         //in 4-MV mode different blocks have different B predictor position
1403         switch (n) {
1404         case 0:
1405             off = (s->mb_x > 0) ? -1 : 1;
1406             break;
1407         case 1:
1408             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1409             break;
1410         case 2:
1411             off = 1;
1412             break;
1413         case 3:
1414             off = -1;
1415         }
1416     }
1417     B = s->current_picture.f.motion_val[dir][xy - wrap + off + v->blocks_off];
1418
1419     a_valid = !s->first_slice_line || (n == 2 || n == 3);
1420     b_valid = a_valid && (s->mb_width > 1);
1421     c_valid = s->mb_x || (n == 1 || n == 3);
1422     if (v->field_mode) {
1423         a_valid = a_valid && !is_intra[xy - wrap];
1424         b_valid = b_valid && !is_intra[xy - wrap + off];
1425         c_valid = c_valid && !is_intra[xy - 1];
1426     }
1427
1428     if (a_valid) {
1429         a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1430         num_oppfield  += a_f;
1431         num_samefield += 1 - a_f;
1432         field_predA[0] = A[0];
1433         field_predA[1] = A[1];
1434     } else {
1435         field_predA[0] = field_predA[1] = 0;
1436         a_f = 0;
1437     }
1438     if (b_valid) {
1439         b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1440         num_oppfield  += b_f;
1441         num_samefield += 1 - b_f;
1442         field_predB[0] = B[0];
1443         field_predB[1] = B[1];
1444     } else {
1445         field_predB[0] = field_predB[1] = 0;
1446         b_f = 0;
1447     }
1448     if (c_valid) {
1449         c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1450         num_oppfield  += c_f;
1451         num_samefield += 1 - c_f;
1452         field_predC[0] = C[0];
1453         field_predC[1] = C[1];
1454     } else {
1455         field_predC[0] = field_predC[1] = 0;
1456         c_f = 0;
1457     }
1458
1459     if (v->field_mode) {
1460         if (num_samefield <= num_oppfield)
1461             opposit = 1 - pred_flag;
1462         else
1463             opposit = pred_flag;
1464     } else
1465         opposit = 0;
1466     if (opposit) {
1467         if (a_valid && !a_f) {
1468             field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1469             field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1470         }
1471         if (b_valid && !b_f) {
1472             field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1473             field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1474         }
1475         if (c_valid && !c_f) {
1476             field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1477             field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1478         }
1479         v->mv_f[dir][xy + v->blocks_off] = 1;
1480         v->ref_field_type[dir] = !v->cur_field_type;
1481     } else {
1482         if (a_valid && a_f) {
1483             field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1484             field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1485         }
1486         if (b_valid && b_f) {
1487             field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1488             field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1489         }
1490         if (c_valid && c_f) {
1491             field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1492             field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1493         }
1494         v->mv_f[dir][xy + v->blocks_off] = 0;
1495         v->ref_field_type[dir] = v->cur_field_type;
1496     }
1497
1498     if (a_valid) {
1499         px = field_predA[0];
1500         py = field_predA[1];
1501     } else if (c_valid) {
1502         px = field_predC[0];
1503         py = field_predC[1];
1504     } else if (b_valid) {
1505         px = field_predB[0];
1506         py = field_predB[1];
1507     } else {
1508         px = 0;
1509         py = 0;
1510     }
1511
1512     if (num_samefield + num_oppfield > 1) {
1513         px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1514         py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1515     }
1516
1517     /* Pullback MV as specified in 8.3.5.3.4 */
1518     if (!v->field_mode) {
1519         int qx, qy, X, Y;
1520         qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1521         qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1522         X  = (s->mb_width  << 6) - 4;
1523         Y  = (s->mb_height << 6) - 4;
1524         if (mv1) {
1525             if (qx + px < -60) px = -60 - qx;
1526             if (qy + py < -60) py = -60 - qy;
1527         } else {
1528             if (qx + px < -28) px = -28 - qx;
1529             if (qy + py < -28) py = -28 - qy;
1530         }
1531         if (qx + px > X) px = X - qx;
1532         if (qy + py > Y) py = Y - qy;
1533     }
1534
1535     if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1536         /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1537         hybridmv_thresh = 32;
1538         if (a_valid && c_valid) {
1539             if (is_intra[xy - wrap])
1540                 sum = FFABS(px) + FFABS(py);
1541             else
1542                 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1543             if (sum > hybridmv_thresh) {
1544                 if (get_bits1(&s->gb)) {     // read HYBRIDPRED bit
1545                     px = field_predA[0];
1546                     py = field_predA[1];
1547                 } else {
1548                     px = field_predC[0];
1549                     py = field_predC[1];
1550                 }
1551             } else {
1552                 if (is_intra[xy - 1])
1553                     sum = FFABS(px) + FFABS(py);
1554                 else
1555                     sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1556                 if (sum > hybridmv_thresh) {
1557                     if (get_bits1(&s->gb)) {
1558                         px = field_predA[0];
1559                         py = field_predA[1];
1560                     } else {
1561                         px = field_predC[0];
1562                         py = field_predC[1];
1563                     }
1564                 }
1565             }
1566         }
1567     }
1568
1569     if (v->field_mode && !s->quarter_sample) {
1570         r_x <<= 1;
1571         r_y <<= 1;
1572     }
1573     if (v->field_mode && v->numref)
1574         r_y >>= 1;
1575     if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1576         y_bias = 1;
1577     /* store MV using signed modulus of MV range defined in 4.11 */
1578     s->mv[dir][n][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1579     s->mv[dir][n][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1] = ((py + dmv_y + r_y - y_bias) & ((r_y << 1) - 1)) - r_y + y_bias;
1580     if (mv1) { /* duplicate motion data for 1-MV block */
1581         s->current_picture.f.motion_val[dir][xy +    1 +     v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1582         s->current_picture.f.motion_val[dir][xy +    1 +     v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1583         s->current_picture.f.motion_val[dir][xy + wrap +     v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1584         s->current_picture.f.motion_val[dir][xy + wrap +     v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1585         s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][0];
1586         s->current_picture.f.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.f.motion_val[dir][xy + v->blocks_off][1];
1587         v->mv_f[dir][xy +    1 + v->blocks_off] = v->mv_f[dir][xy +            v->blocks_off];
1588         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];
1589     }
1590 }
1591
1592 /** Predict and set motion vector for interlaced frame picture MBs
1593  */
1594 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1595                                      int mvn, int r_x, int r_y, uint8_t* is_intra)
1596 {
1597     MpegEncContext *s = &v->s;
1598     int xy, wrap, off = 0;
1599     int A[2], B[2], C[2];
1600     int px, py;
1601     int a_valid = 0, b_valid = 0, c_valid = 0;
1602     int field_a, field_b, field_c; // 0: same, 1: opposit
1603     int total_valid, num_samefield, num_oppfield;
1604     int pos_c, pos_b, n_adj;
1605
1606     wrap = s->b8_stride;
1607     xy = s->block_index[n];
1608
1609     if (s->mb_intra) {
1610         s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = 0;
1611         s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = 0;
1612         s->current_picture.f.motion_val[1][xy][0] = 0;
1613         s->current_picture.f.motion_val[1][xy][1] = 0;
1614         if (mvn == 1) { /* duplicate motion data for 1-MV block */
1615             s->current_picture.f.motion_val[0][xy + 1][0]        = 0;
1616             s->current_picture.f.motion_val[0][xy + 1][1]        = 0;
1617             s->current_picture.f.motion_val[0][xy + wrap][0]     = 0;
1618             s->current_picture.f.motion_val[0][xy + wrap][1]     = 0;
1619             s->current_picture.f.motion_val[0][xy + wrap + 1][0] = 0;
1620             s->current_picture.f.motion_val[0][xy + wrap + 1][1] = 0;
1621             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1622             s->current_picture.f.motion_val[1][xy + 1][0]        = 0;
1623             s->current_picture.f.motion_val[1][xy + 1][1]        = 0;
1624             s->current_picture.f.motion_val[1][xy + wrap][0]     = 0;
1625             s->current_picture.f.motion_val[1][xy + wrap][1]     = 0;
1626             s->current_picture.f.motion_val[1][xy + wrap + 1][0] = 0;
1627             s->current_picture.f.motion_val[1][xy + wrap + 1][1] = 0;
1628         }
1629         return;
1630     }
1631
1632     off = ((n == 0) || (n == 1)) ? 1 : -1;
1633     /* predict A */
1634     if (s->mb_x || (n == 1) || (n == 3)) {
1635         if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1636             || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1637             A[0] = s->current_picture.f.motion_val[0][xy - 1][0];
1638             A[1] = s->current_picture.f.motion_val[0][xy - 1][1];
1639             a_valid = 1;
1640         } else { // current block has frame mv and cand. has field MV (so average)
1641             A[0] = (s->current_picture.f.motion_val[0][xy - 1][0]
1642                     + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][0] + 1) >> 1;
1643             A[1] = (s->current_picture.f.motion_val[0][xy - 1][1]
1644                     + s->current_picture.f.motion_val[0][xy - 1 + off * wrap][1] + 1) >> 1;
1645             a_valid = 1;
1646         }
1647         if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1648             a_valid = 0;
1649             A[0] = A[1] = 0;
1650         }
1651     } else
1652         A[0] = A[1] = 0;
1653     /* Predict B and C */
1654     B[0] = B[1] = C[0] = C[1] = 0;
1655     if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1656         if (!s->first_slice_line) {
1657             if (!v->is_intra[s->mb_x - s->mb_stride]) {
1658                 b_valid = 1;
1659                 n_adj   = n | 2;
1660                 pos_b   = s->block_index[n_adj] - 2 * wrap;
1661                 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1662                     n_adj = (n & 2) | (n & 1);
1663                 }
1664                 B[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][0];
1665                 B[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap][1];
1666                 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1667                     B[0] = (B[0] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1668                     B[1] = (B[1] + s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1669                 }
1670             }
1671             if (s->mb_width > 1) {
1672                 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1673                     c_valid = 1;
1674                     n_adj   = 2;
1675                     pos_c   = s->block_index[2] - 2 * wrap + 2;
1676                     if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1677                         n_adj = n & 2;
1678                     }
1679                     C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][0];
1680                     C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap + 2][1];
1681                     if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1682                         C[0] = (1 + C[0] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1683                         C[1] = (1 + C[1] + (s->current_picture.f.motion_val[0][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1684                     }
1685                     if (s->mb_x == s->mb_width - 1) {
1686                         if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1687                             c_valid = 1;
1688                             n_adj   = 3;
1689                             pos_c   = s->block_index[3] - 2 * wrap - 2;
1690                             if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1691                                 n_adj = n | 1;
1692                             }
1693                             C[0] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][0];
1694                             C[1] = s->current_picture.f.motion_val[0][s->block_index[n_adj] - 2 * wrap - 2][1];
1695                             if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1696                                 C[0] = (1 + C[0] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1697                                 C[1] = (1 + C[1] + s->current_picture.f.motion_val[0][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1698                             }
1699                         } else
1700                             c_valid = 0;
1701                     }
1702                 }
1703             }
1704         }
1705     } else {
1706         pos_b   = s->block_index[1];
1707         b_valid = 1;
1708         B[0]    = s->current_picture.f.motion_val[0][pos_b][0];
1709         B[1]    = s->current_picture.f.motion_val[0][pos_b][1];
1710         pos_c   = s->block_index[0];
1711         c_valid = 1;
1712         C[0]    = s->current_picture.f.motion_val[0][pos_c][0];
1713         C[1]    = s->current_picture.f.motion_val[0][pos_c][1];
1714     }
1715
1716     total_valid = a_valid + b_valid + c_valid;
1717     // check if predictor A is out of bounds
1718     if (!s->mb_x && !(n == 1 || n == 3)) {
1719         A[0] = A[1] = 0;
1720     }
1721     // check if predictor B is out of bounds
1722     if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1723         B[0] = B[1] = C[0] = C[1] = 0;
1724     }
1725     if (!v->blk_mv_type[xy]) {
1726         if (s->mb_width == 1) {
1727             px = B[0];
1728             py = B[1];
1729         } else {
1730             if (total_valid >= 2) {
1731                 px = mid_pred(A[0], B[0], C[0]);
1732                 py = mid_pred(A[1], B[1], C[1]);
1733             } else if (total_valid) {
1734                 if (a_valid) { px = A[0]; py = A[1]; }
1735                 if (b_valid) { px = B[0]; py = B[1]; }
1736                 if (c_valid) { px = C[0]; py = C[1]; }
1737             } else
1738                 px = py = 0;
1739         }
1740     } else {
1741         if (a_valid)
1742             field_a = (A[1] & 4) ? 1 : 0;
1743         else
1744             field_a = 0;
1745         if (b_valid)
1746             field_b = (B[1] & 4) ? 1 : 0;
1747         else
1748             field_b = 0;
1749         if (c_valid)
1750             field_c = (C[1] & 4) ? 1 : 0;
1751         else
1752             field_c = 0;
1753
1754         num_oppfield  = field_a + field_b + field_c;
1755         num_samefield = total_valid - num_oppfield;
1756         if (total_valid == 3) {
1757             if ((num_samefield == 3) || (num_oppfield == 3)) {
1758                 px = mid_pred(A[0], B[0], C[0]);
1759                 py = mid_pred(A[1], B[1], C[1]);
1760             } else if (num_samefield >= num_oppfield) {
1761                 /* take one MV from same field set depending on priority
1762                 the check for B may not be necessary */
1763                 px = !field_a ? A[0] : B[0];
1764                 py = !field_a ? A[1] : B[1];
1765             } else {
1766                 px =  field_a ? A[0] : B[0];
1767                 py =  field_a ? A[1] : B[1];
1768             }
1769         } else if (total_valid == 2) {
1770             if (num_samefield >= num_oppfield) {
1771                 if (!field_a && a_valid) {
1772                     px = A[0];
1773                     py = A[1];
1774                 } else if (!field_b && b_valid) {
1775                     px = B[0];
1776                     py = B[1];
1777                 } else if (c_valid) {
1778                     px = C[0];
1779                     py = C[1];
1780                 } else px = py = 0;
1781             } else {
1782                 if (field_a && a_valid) {
1783                     px = A[0];
1784                     py = A[1];
1785                 } else if (field_b && b_valid) {
1786                     px = B[0];
1787                     py = B[1];
1788                 } else if (c_valid) {
1789                     px = C[0];
1790                     py = C[1];
1791                 }
1792             }
1793         } else if (total_valid == 1) {
1794             px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1795             py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1796         } else
1797             px = py = 0;
1798     }
1799
1800     /* store MV using signed modulus of MV range defined in 4.11 */
1801     s->mv[0][n][0] = s->current_picture.f.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1802     s->mv[0][n][1] = s->current_picture.f.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1803     if (mvn == 1) { /* duplicate motion data for 1-MV block */
1804         s->current_picture.f.motion_val[0][xy +    1    ][0] = s->current_picture.f.motion_val[0][xy][0];
1805         s->current_picture.f.motion_val[0][xy +    1    ][1] = s->current_picture.f.motion_val[0][xy][1];
1806         s->current_picture.f.motion_val[0][xy + wrap    ][0] = s->current_picture.f.motion_val[0][xy][0];
1807         s->current_picture.f.motion_val[0][xy + wrap    ][1] = s->current_picture.f.motion_val[0][xy][1];
1808         s->current_picture.f.motion_val[0][xy + wrap + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1809         s->current_picture.f.motion_val[0][xy + wrap + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1810     } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1811         s->current_picture.f.motion_val[0][xy + 1][0] = s->current_picture.f.motion_val[0][xy][0];
1812         s->current_picture.f.motion_val[0][xy + 1][1] = s->current_picture.f.motion_val[0][xy][1];
1813         s->mv[0][n + 1][0] = s->mv[0][n][0];
1814         s->mv[0][n + 1][1] = s->mv[0][n][1];
1815     }
1816 }
1817
1818 /** Motion compensation for direct or interpolated blocks in B-frames
1819  */
1820 static void vc1_interp_mc(VC1Context *v)
1821 {
1822     MpegEncContext *s = &v->s;
1823     DSPContext *dsp = &v->s.dsp;
1824     uint8_t *srcY, *srcU, *srcV;
1825     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1826     int off, off_uv;
1827     int v_edge_pos = s->v_edge_pos >> v->field_mode;
1828
1829     if (!v->field_mode && !v->s.next_picture.f.data[0])
1830         return;
1831
1832     mx   = s->mv[1][0][0];
1833     my   = s->mv[1][0][1];
1834     uvmx = (mx + ((mx & 3) == 3)) >> 1;
1835     uvmy = (my + ((my & 3) == 3)) >> 1;
1836     if (v->field_mode) {
1837         if (v->cur_field_type != v->ref_field_type[1])
1838             my   = my   - 2 + 4 * v->cur_field_type;
1839             uvmy = uvmy - 2 + 4 * v->cur_field_type;
1840     }
1841     if (v->fastuvmc) {
1842         uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1843         uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1844     }
1845     srcY = s->next_picture.f.data[0];
1846     srcU = s->next_picture.f.data[1];
1847     srcV = s->next_picture.f.data[2];
1848
1849     src_x   = s->mb_x * 16 + (mx   >> 2);
1850     src_y   = s->mb_y * 16 + (my   >> 2);
1851     uvsrc_x = s->mb_x *  8 + (uvmx >> 2);
1852     uvsrc_y = s->mb_y *  8 + (uvmy >> 2);
1853
1854     if (v->profile != PROFILE_ADVANCED) {
1855         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
1856         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
1857         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
1858         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
1859     } else {
1860         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
1861         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
1862         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
1863         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
1864     }
1865
1866     srcY += src_y   * s->linesize   + src_x;
1867     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1868     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1869
1870     if (v->field_mode && v->ref_field_type[1]) {
1871         srcY += s->current_picture_ptr->f.linesize[0];
1872         srcU += s->current_picture_ptr->f.linesize[1];
1873         srcV += s->current_picture_ptr->f.linesize[2];
1874     }
1875
1876     /* for grayscale we should not try to read from unknown area */
1877     if (s->flags & CODEC_FLAG_GRAY) {
1878         srcU = s->edge_emu_buffer + 18 * s->linesize;
1879         srcV = s->edge_emu_buffer + 18 * s->linesize;
1880     }
1881
1882     if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1883         || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1884         || (unsigned)(src_y - 1) > v_edge_pos    - (my & 3) - 16 - 3) {
1885         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1886
1887         srcY -= s->mspel * (1 + s->linesize);
1888         s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1889                                 17 + s->mspel * 2, 17 + s->mspel * 2,
1890                                 src_x - s->mspel, src_y - s->mspel,
1891                                 s->h_edge_pos, v_edge_pos);
1892         srcY = s->edge_emu_buffer;
1893         s->dsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1894                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1895         s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1896                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1897         srcU = uvbuf;
1898         srcV = uvbuf + 16;
1899         /* if we deal with range reduction we need to scale source blocks */
1900         if (v->rangeredfrm) {
1901             int i, j;
1902             uint8_t *src, *src2;
1903
1904             src = srcY;
1905             for (j = 0; j < 17 + s->mspel * 2; j++) {
1906                 for (i = 0; i < 17 + s->mspel * 2; i++)
1907                     src[i] = ((src[i] - 128) >> 1) + 128;
1908                 src += s->linesize;
1909             }
1910             src = srcU;
1911             src2 = srcV;
1912             for (j = 0; j < 9; j++) {
1913                 for (i = 0; i < 9; i++) {
1914                     src[i]  = ((src[i]  - 128) >> 1) + 128;
1915                     src2[i] = ((src2[i] - 128) >> 1) + 128;
1916                 }
1917                 src  += s->uvlinesize;
1918                 src2 += s->uvlinesize;
1919             }
1920         }
1921         srcY += s->mspel * (1 + s->linesize);
1922     }
1923
1924     if (v->field_mode && v->cur_field_type) {
1925         off    = s->current_picture_ptr->f.linesize[0];
1926         off_uv = s->current_picture_ptr->f.linesize[1];
1927     } else {
1928         off    = 0;
1929         off_uv = 0;
1930     }
1931
1932     if (s->mspel) {
1933         dxy = ((my & 3) << 2) | (mx & 3);
1934         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off    , srcY    , s->linesize, v->rnd);
1935         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8, srcY + 8, s->linesize, v->rnd);
1936         srcY += s->linesize * 8;
1937         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
1938         v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
1939     } else { // hpel mc
1940         dxy = (my & 2) | ((mx & 2) >> 1);
1941
1942         if (!v->rnd)
1943             dsp->avg_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1944         else
1945             dsp->avg_no_rnd_pixels_tab[0][dxy](s->dest[0] + off, srcY, s->linesize, 16);
1946     }
1947
1948     if (s->flags & CODEC_FLAG_GRAY) return;
1949     /* Chroma MC always uses qpel blilinear */
1950     uvmx = (uvmx & 3) << 1;
1951     uvmy = (uvmy & 3) << 1;
1952     if (!v->rnd) {
1953         dsp->avg_h264_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1954         dsp->avg_h264_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1955     } else {
1956         v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1] + off_uv, srcU, s->uvlinesize, 8, uvmx, uvmy);
1957         v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2] + off_uv, srcV, s->uvlinesize, 8, uvmx, uvmy);
1958     }
1959 }
1960
1961 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
1962 {
1963     int n = bfrac;
1964
1965 #if B_FRACTION_DEN==256
1966     if (inv)
1967         n -= 256;
1968     if (!qs)
1969         return 2 * ((value * n + 255) >> 9);
1970     return (value * n + 128) >> 8;
1971 #else
1972     if (inv)
1973         n -= B_FRACTION_DEN;
1974     if (!qs)
1975         return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
1976     return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1977 #endif
1978 }
1979
1980 /** Reconstruct motion vector for B-frame and do motion compensation
1981  */
1982 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
1983                             int direct, int mode)
1984 {
1985     if (v->use_ic) {
1986         v->mv_mode2 = v->mv_mode;
1987         v->mv_mode  = MV_PMODE_INTENSITY_COMP;
1988     }
1989     if (direct) {
1990         vc1_mc_1mv(v, 0);
1991         vc1_interp_mc(v);
1992         if (v->use_ic)
1993             v->mv_mode = v->mv_mode2;
1994         return;
1995     }
1996     if (mode == BMV_TYPE_INTERPOLATED) {
1997         vc1_mc_1mv(v, 0);
1998         vc1_interp_mc(v);
1999         if (v->use_ic)
2000             v->mv_mode = v->mv_mode2;
2001         return;
2002     }
2003
2004     if (v->use_ic && (mode == BMV_TYPE_BACKWARD))
2005         v->mv_mode = v->mv_mode2;
2006     vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2007     if (v->use_ic)
2008         v->mv_mode = v->mv_mode2;
2009 }
2010
2011 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
2012                                  int direct, int mvtype)
2013 {
2014     MpegEncContext *s = &v->s;
2015     int xy, wrap, off = 0;
2016     int16_t *A, *B, *C;
2017     int px, py;
2018     int sum;
2019     int r_x, r_y;
2020     const uint8_t *is_intra = v->mb_type[0];
2021
2022     r_x = v->range_x;
2023     r_y = v->range_y;
2024     /* scale MV difference to be quad-pel */
2025     dmv_x[0] <<= 1 - s->quarter_sample;
2026     dmv_y[0] <<= 1 - s->quarter_sample;
2027     dmv_x[1] <<= 1 - s->quarter_sample;
2028     dmv_y[1] <<= 1 - s->quarter_sample;
2029
2030     wrap = s->b8_stride;
2031     xy = s->block_index[0];
2032
2033     if (s->mb_intra) {
2034         s->current_picture.f.motion_val[0][xy + v->blocks_off][0] =
2035         s->current_picture.f.motion_val[0][xy + v->blocks_off][1] =
2036         s->current_picture.f.motion_val[1][xy + v->blocks_off][0] =
2037         s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = 0;
2038         return;
2039     }
2040     if (!v->field_mode) {
2041         s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2042         s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2043         s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2044         s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2045
2046         /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2047         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));
2048         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));
2049         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));
2050         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));
2051     }
2052     if (direct) {
2053         s->current_picture.f.motion_val[0][xy + v->blocks_off][0] = s->mv[0][0][0];
2054         s->current_picture.f.motion_val[0][xy + v->blocks_off][1] = s->mv[0][0][1];
2055         s->current_picture.f.motion_val[1][xy + v->blocks_off][0] = s->mv[1][0][0];
2056         s->current_picture.f.motion_val[1][xy + v->blocks_off][1] = s->mv[1][0][1];
2057         return;
2058     }
2059
2060     if ((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2061         C   = s->current_picture.f.motion_val[0][xy - 2];
2062         A   = s->current_picture.f.motion_val[0][xy - wrap * 2];
2063         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2064         B   = s->current_picture.f.motion_val[0][xy - wrap * 2 + off];
2065
2066         if (!s->mb_x) C[0] = C[1] = 0;
2067         if (!s->first_slice_line) { // predictor A is not out of bounds
2068             if (s->mb_width == 1) {
2069                 px = A[0];
2070                 py = A[1];
2071             } else {
2072                 px = mid_pred(A[0], B[0], C[0]);
2073                 py = mid_pred(A[1], B[1], C[1]);
2074             }
2075         } else if (s->mb_x) { // predictor C is not out of bounds
2076             px = C[0];
2077             py = C[1];
2078         } else {
2079             px = py = 0;
2080         }
2081         /* Pullback MV as specified in 8.3.5.3.4 */
2082         {
2083             int qx, qy, X, Y;
2084             if (v->profile < PROFILE_ADVANCED) {
2085                 qx = (s->mb_x << 5);
2086                 qy = (s->mb_y << 5);
2087                 X  = (s->mb_width  << 5) - 4;
2088                 Y  = (s->mb_height << 5) - 4;
2089                 if (qx + px < -28) px = -28 - qx;
2090                 if (qy + py < -28) py = -28 - qy;
2091                 if (qx + px > X) px = X - qx;
2092                 if (qy + py > Y) py = Y - qy;
2093             } else {
2094                 qx = (s->mb_x << 6);
2095                 qy = (s->mb_y << 6);
2096                 X  = (s->mb_width  << 6) - 4;
2097                 Y  = (s->mb_height << 6) - 4;
2098                 if (qx + px < -60) px = -60 - qx;
2099                 if (qy + py < -60) py = -60 - qy;
2100                 if (qx + px > X) px = X - qx;
2101                 if (qy + py > Y) py = Y - qy;
2102             }
2103         }
2104         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2105         if (0 && !s->first_slice_line && s->mb_x) {
2106             if (is_intra[xy - wrap])
2107                 sum = FFABS(px) + FFABS(py);
2108             else
2109                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2110             if (sum > 32) {
2111                 if (get_bits1(&s->gb)) {
2112                     px = A[0];
2113                     py = A[1];
2114                 } else {
2115                     px = C[0];
2116                     py = C[1];
2117                 }
2118             } else {
2119                 if (is_intra[xy - 2])
2120                     sum = FFABS(px) + FFABS(py);
2121                 else
2122                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2123                 if (sum > 32) {
2124                     if (get_bits1(&s->gb)) {
2125                         px = A[0];
2126                         py = A[1];
2127                     } else {
2128                         px = C[0];
2129                         py = C[1];
2130                     }
2131                 }
2132             }
2133         }
2134         /* store MV using signed modulus of MV range defined in 4.11 */
2135         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2136         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2137     }
2138     if ((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2139         C   = s->current_picture.f.motion_val[1][xy - 2];
2140         A   = s->current_picture.f.motion_val[1][xy - wrap * 2];
2141         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2142         B   = s->current_picture.f.motion_val[1][xy - wrap * 2 + off];
2143
2144         if (!s->mb_x)
2145             C[0] = C[1] = 0;
2146         if (!s->first_slice_line) { // predictor A is not out of bounds
2147             if (s->mb_width == 1) {
2148                 px = A[0];
2149                 py = A[1];
2150             } else {
2151                 px = mid_pred(A[0], B[0], C[0]);
2152                 py = mid_pred(A[1], B[1], C[1]);
2153             }
2154         } else if (s->mb_x) { // predictor C is not out of bounds
2155             px = C[0];
2156             py = C[1];
2157         } else {
2158             px = py = 0;
2159         }
2160         /* Pullback MV as specified in 8.3.5.3.4 */
2161         {
2162             int qx, qy, X, Y;
2163             if (v->profile < PROFILE_ADVANCED) {
2164                 qx = (s->mb_x << 5);
2165                 qy = (s->mb_y << 5);
2166                 X  = (s->mb_width  << 5) - 4;
2167                 Y  = (s->mb_height << 5) - 4;
2168                 if (qx + px < -28) px = -28 - qx;
2169                 if (qy + py < -28) py = -28 - qy;
2170                 if (qx + px > X) px = X - qx;
2171                 if (qy + py > Y) py = Y - qy;
2172             } else {
2173                 qx = (s->mb_x << 6);
2174                 qy = (s->mb_y << 6);
2175                 X  = (s->mb_width  << 6) - 4;
2176                 Y  = (s->mb_height << 6) - 4;
2177                 if (qx + px < -60) px = -60 - qx;
2178                 if (qy + py < -60) py = -60 - qy;
2179                 if (qx + px > X) px = X - qx;
2180                 if (qy + py > Y) py = Y - qy;
2181             }
2182         }
2183         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2184         if (0 && !s->first_slice_line && s->mb_x) {
2185             if (is_intra[xy - wrap])
2186                 sum = FFABS(px) + FFABS(py);
2187             else
2188                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2189             if (sum > 32) {
2190                 if (get_bits1(&s->gb)) {
2191                     px = A[0];
2192                     py = A[1];
2193                 } else {
2194                     px = C[0];
2195                     py = C[1];
2196                 }
2197             } else {
2198                 if (is_intra[xy - 2])
2199                     sum = FFABS(px) + FFABS(py);
2200                 else
2201                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2202                 if (sum > 32) {
2203                     if (get_bits1(&s->gb)) {
2204                         px = A[0];
2205                         py = A[1];
2206                     } else {
2207                         px = C[0];
2208                         py = C[1];
2209                     }
2210                 }
2211             }
2212         }
2213         /* store MV using signed modulus of MV range defined in 4.11 */
2214
2215         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2216         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2217     }
2218     s->current_picture.f.motion_val[0][xy][0] = s->mv[0][0][0];
2219     s->current_picture.f.motion_val[0][xy][1] = s->mv[0][0][1];
2220     s->current_picture.f.motion_val[1][xy][0] = s->mv[1][0][0];
2221     s->current_picture.f.motion_val[1][xy][1] = s->mv[1][0][1];
2222 }
2223
2224 static inline void vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y, int mv1, int *pred_flag)
2225 {
2226     int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
2227     MpegEncContext *s = &v->s;
2228     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2229
2230     if (v->bmvtype == BMV_TYPE_DIRECT) {
2231         int total_opp, k, f;
2232         if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2233             s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2234                                       v->bfraction, 0, s->quarter_sample);
2235             s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2236                                       v->bfraction, 0, s->quarter_sample);
2237             s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2238                                       v->bfraction, 1, s->quarter_sample);
2239             s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2240                                       v->bfraction, 1, s->quarter_sample);
2241
2242             total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2243                       + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
2244                       + v->mv_f_next[0][s->block_index[2] + v->blocks_off]
2245                       + v->mv_f_next[0][s->block_index[3] + v->blocks_off];
2246             f = (total_opp > 2) ? 1 : 0;
2247         } else {
2248             s->mv[0][0][0] = s->mv[0][0][1] = 0;
2249             s->mv[1][0][0] = s->mv[1][0][1] = 0;
2250             f = 0;
2251         }
2252         v->ref_field_type[0] = v->ref_field_type[1] = v->cur_field_type ^ f;
2253         for (k = 0; k < 4; k++) {
2254             s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][0] = s->mv[0][0][0];
2255             s->current_picture.f.motion_val[0][s->block_index[k] + v->blocks_off][1] = s->mv[0][0][1];
2256             s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][0] = s->mv[1][0][0];
2257             s->current_picture.f.motion_val[1][s->block_index[k] + v->blocks_off][1] = s->mv[1][0][1];
2258             v->mv_f[0][s->block_index[k] + v->blocks_off] = f;
2259             v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
2260         }
2261         return;
2262     }
2263     if (v->bmvtype == BMV_TYPE_INTERPOLATED) {
2264         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);
2265         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);
2266         return;
2267     }
2268     if (dir) { // backward
2269         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);
2270         if (n == 3 || mv1) {
2271             vc1_pred_mv(v, 0, dmv_x[0], dmv_y[0],   1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
2272         }
2273     } else { // forward
2274         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);
2275         if (n == 3 || mv1) {
2276             vc1_pred_mv(v, 0, dmv_x[1], dmv_y[1],   1, v->range_x, v->range_y, v->mb_type[0], 0, 1);
2277         }
2278     }
2279 }
2280
2281 /** Get predicted DC value for I-frames only
2282  * prediction dir: left=0, top=1
2283  * @param s MpegEncContext
2284  * @param overlap flag indicating that overlap filtering is used
2285  * @param pq integer part of picture quantizer
2286  * @param[in] n block index in the current MB
2287  * @param dc_val_ptr Pointer to DC predictor
2288  * @param dir_ptr Prediction direction for use in AC prediction
2289  */
2290 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2291                                 int16_t **dc_val_ptr, int *dir_ptr)
2292 {
2293     int a, b, c, wrap, pred, scale;
2294     int16_t *dc_val;
2295     static const uint16_t dcpred[32] = {
2296         -1, 1024,  512,  341,  256,  205,  171,  146,  128,
2297              114,  102,   93,   85,   79,   73,   68,   64,
2298               60,   57,   54,   51,   49,   47,   45,   43,
2299               41,   39,   38,   37,   35,   34,   33
2300     };
2301
2302     /* find prediction - wmv3_dc_scale always used here in fact */
2303     if (n < 4) scale = s->y_dc_scale;
2304     else       scale = s->c_dc_scale;
2305
2306     wrap   = s->block_wrap[n];
2307     dc_val = s->dc_val[0] + s->block_index[n];
2308
2309     /* B A
2310      * C X
2311      */
2312     c = dc_val[ - 1];
2313     b = dc_val[ - 1 - wrap];
2314     a = dc_val[ - wrap];
2315
2316     if (pq < 9 || !overlap) {
2317         /* Set outer values */
2318         if (s->first_slice_line && (n != 2 && n != 3))
2319             b = a = dcpred[scale];
2320         if (s->mb_x == 0 && (n != 1 && n != 3))
2321             b = c = dcpred[scale];
2322     } else {
2323         /* Set outer values */
2324         if (s->first_slice_line && (n != 2 && n != 3))
2325             b = a = 0;
2326         if (s->mb_x == 0 && (n != 1 && n != 3))
2327             b = c = 0;
2328     }
2329
2330     if (abs(a - b) <= abs(b - c)) {
2331         pred     = c;
2332         *dir_ptr = 1; // left
2333     } else {
2334         pred     = a;
2335         *dir_ptr = 0; // top
2336     }
2337
2338     /* update predictor */
2339     *dc_val_ptr = &dc_val[0];
2340     return pred;
2341 }
2342
2343
2344 /** Get predicted DC value
2345  * prediction dir: left=0, top=1
2346  * @param s MpegEncContext
2347  * @param overlap flag indicating that overlap filtering is used
2348  * @param pq integer part of picture quantizer
2349  * @param[in] n block index in the current MB
2350  * @param a_avail flag indicating top block availability
2351  * @param c_avail flag indicating left block availability
2352  * @param dc_val_ptr Pointer to DC predictor
2353  * @param dir_ptr Prediction direction for use in AC prediction
2354  */
2355 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2356                               int a_avail, int c_avail,
2357                               int16_t **dc_val_ptr, int *dir_ptr)
2358 {
2359     int a, b, c, wrap, pred;
2360     int16_t *dc_val;
2361     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2362     int q1, q2 = 0;
2363     int dqscale_index;
2364
2365     wrap = s->block_wrap[n];
2366     dc_val = s->dc_val[0] + s->block_index[n];
2367
2368     /* B A
2369      * C X
2370      */
2371     c = dc_val[ - 1];
2372     b = dc_val[ - 1 - wrap];
2373     a = dc_val[ - wrap];
2374     /* scale predictors if needed */
2375     q1 = s->current_picture.f.qscale_table[mb_pos];
2376     dqscale_index = s->y_dc_scale_table[q1] - 1;
2377     if (dqscale_index < 0)
2378         return 0;
2379     if (c_avail && (n != 1 && n != 3)) {
2380         q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2381         if (q2 && q2 != q1)
2382             c = (c * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2383     }
2384     if (a_avail && (n != 2 && n != 3)) {
2385         q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2386         if (q2 && q2 != q1)
2387             a = (a * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2388     }
2389     if (a_avail && c_avail && (n != 3)) {
2390         int off = mb_pos;
2391         if (n != 1)
2392             off--;
2393         if (n != 2)
2394             off -= s->mb_stride;
2395         q2 = s->current_picture.f.qscale_table[off];
2396         if (q2 && q2 != q1)
2397             b = (b * s->y_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18;
2398     }
2399
2400     if (a_avail && c_avail) {
2401         if (abs(a - b) <= abs(b - c)) {
2402             pred     = c;
2403             *dir_ptr = 1; // left
2404         } else {
2405             pred     = a;
2406             *dir_ptr = 0; // top
2407         }
2408     } else if (a_avail) {
2409         pred     = a;
2410         *dir_ptr = 0; // top
2411     } else if (c_avail) {
2412         pred     = c;
2413         *dir_ptr = 1; // left
2414     } else {
2415         pred     = 0;
2416         *dir_ptr = 1; // left
2417     }
2418
2419     /* update predictor */
2420     *dc_val_ptr = &dc_val[0];
2421     return pred;
2422 }
2423
2424 /** @} */ // Block group
2425
2426 /**
2427  * @name VC1 Macroblock-level functions in Simple/Main Profiles
2428  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2429  * @{
2430  */
2431
2432 static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
2433                                        uint8_t **coded_block_ptr)
2434 {
2435     int xy, wrap, pred, a, b, c;
2436
2437     xy   = s->block_index[n];
2438     wrap = s->b8_stride;
2439
2440     /* B C
2441      * A X
2442      */
2443     a = s->coded_block[xy - 1       ];
2444     b = s->coded_block[xy - 1 - wrap];
2445     c = s->coded_block[xy     - wrap];
2446
2447     if (b == c) {
2448         pred = a;
2449     } else {
2450         pred = c;
2451     }
2452
2453     /* store value */
2454     *coded_block_ptr = &s->coded_block[xy];
2455
2456     return pred;
2457 }
2458
2459 /**
2460  * Decode one AC coefficient
2461  * @param v The VC1 context
2462  * @param last Last coefficient
2463  * @param skip How much zero coefficients to skip
2464  * @param value Decoded AC coefficient value
2465  * @param codingset set of VLC to decode data
2466  * @see 8.1.3.4
2467  */
2468 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
2469                                 int *value, int codingset)
2470 {
2471     GetBitContext *gb = &v->s.gb;
2472     int index, escape, run = 0, level = 0, lst = 0;
2473
2474     index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2475     if (index != ff_vc1_ac_sizes[codingset] - 1) {
2476         run   = vc1_index_decode_table[codingset][index][0];
2477         level = vc1_index_decode_table[codingset][index][1];
2478         lst   = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0;
2479         if (get_bits1(gb))
2480             level = -level;
2481     } else {
2482         escape = decode210(gb);
2483         if (escape != 2) {
2484             index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2485             run   = vc1_index_decode_table[codingset][index][0];
2486             level = vc1_index_decode_table[codingset][index][1];
2487             lst   = index >= vc1_last_decode_table[codingset];
2488             if (escape == 0) {
2489                 if (lst)
2490                     level += vc1_last_delta_level_table[codingset][run];
2491                 else
2492                     level += vc1_delta_level_table[codingset][run];
2493             } else {
2494                 if (lst)
2495                     run += vc1_last_delta_run_table[codingset][level] + 1;
2496                 else
2497                     run += vc1_delta_run_table[codingset][level] + 1;
2498             }
2499             if (get_bits1(gb))
2500                 level = -level;
2501         } else {
2502             int sign;
2503             lst = get_bits1(gb);
2504             if (v->s.esc3_level_length == 0) {
2505                 if (v->pq < 8 || v->dquantfrm) { // table 59
2506                     v->s.esc3_level_length = get_bits(gb, 3);
2507                     if (!v->s.esc3_level_length)
2508                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
2509                 } else { // table 60
2510                     v->s.esc3_level_length = get_unary(gb, 1, 6) + 2;
2511                 }
2512                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2513             }
2514             run   = get_bits(gb, v->s.esc3_run_length);
2515             sign  = get_bits1(gb);
2516             level = get_bits(gb, v->s.esc3_level_length);
2517             if (sign)
2518                 level = -level;
2519         }
2520     }
2521
2522     *last  = lst;
2523     *skip  = run;
2524     *value = level;
2525 }
2526
2527 /** Decode intra block in intra frames - should be faster than decode_intra_block
2528  * @param v VC1Context
2529  * @param block block to decode
2530  * @param[in] n subblock index
2531  * @param coded are AC coeffs present or not
2532  * @param codingset set of VLC to decode data
2533  */
2534 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n,
2535                               int coded, int codingset)
2536 {
2537     GetBitContext *gb = &v->s.gb;
2538     MpegEncContext *s = &v->s;
2539     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2540     int i;
2541     int16_t *dc_val;
2542     int16_t *ac_val, *ac_val2;
2543     int dcdiff;
2544
2545     /* Get DC differential */
2546     if (n < 4) {
2547         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2548     } else {
2549         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2550     }
2551     if (dcdiff < 0) {
2552         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2553         return -1;
2554     }
2555     if (dcdiff) {
2556         if (dcdiff == 119 /* ESC index value */) {
2557             /* TODO: Optimize */
2558             if (v->pq == 1)      dcdiff = get_bits(gb, 10);
2559             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2560             else                 dcdiff = get_bits(gb, 8);
2561         } else {
2562             if (v->pq == 1)
2563                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2564             else if (v->pq == 2)
2565                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
2566         }
2567         if (get_bits1(gb))
2568             dcdiff = -dcdiff;
2569     }
2570
2571     /* Prediction */
2572     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2573     *dc_val = dcdiff;
2574
2575     /* Store the quantized DC coeff, used for prediction */
2576     if (n < 4) {
2577         block[0] = dcdiff * s->y_dc_scale;
2578     } else {
2579         block[0] = dcdiff * s->c_dc_scale;
2580     }
2581     /* Skip ? */
2582     if (!coded) {
2583         goto not_coded;
2584     }
2585
2586     // AC Decoding
2587     i = 1;
2588
2589     {
2590         int last = 0, skip, value;
2591         const uint8_t *zz_table;
2592         int scale;
2593         int k;
2594
2595         scale = v->pq * 2 + v->halfpq;
2596
2597         if (v->s.ac_pred) {
2598             if (!dc_pred_dir)
2599                 zz_table = v->zz_8x8[2];
2600             else
2601                 zz_table = v->zz_8x8[3];
2602         } else
2603             zz_table = v->zz_8x8[1];
2604
2605         ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
2606         ac_val2 = ac_val;
2607         if (dc_pred_dir) // left
2608             ac_val -= 16;
2609         else // top
2610             ac_val -= 16 * s->block_wrap[n];
2611
2612         while (!last) {
2613             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2614             i += skip;
2615             if (i > 63)
2616                 break;
2617             block[zz_table[i++]] = value;
2618         }
2619
2620         /* apply AC prediction if needed */
2621         if (s->ac_pred) {
2622             if (dc_pred_dir) { // left
2623                 for (k = 1; k < 8; k++)
2624                     block[k << v->left_blk_sh] += ac_val[k];
2625             } else { // top
2626                 for (k = 1; k < 8; k++)
2627                     block[k << v->top_blk_sh] += ac_val[k + 8];
2628             }
2629         }
2630         /* save AC coeffs for further prediction */
2631         for (k = 1; k < 8; k++) {
2632             ac_val2[k]     = block[k << v->left_blk_sh];
2633             ac_val2[k + 8] = block[k << v->top_blk_sh];
2634         }
2635
2636         /* scale AC coeffs */
2637         for (k = 1; k < 64; k++)
2638             if (block[k]) {
2639                 block[k] *= scale;
2640                 if (!v->pquantizer)
2641                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
2642             }
2643
2644         if (s->ac_pred) i = 63;
2645     }
2646
2647 not_coded:
2648     if (!coded) {
2649         int k, scale;
2650         ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
2651         ac_val2 = ac_val;
2652
2653         i = 0;
2654         scale = v->pq * 2 + v->halfpq;
2655         memset(ac_val2, 0, 16 * 2);
2656         if (dc_pred_dir) { // left
2657             ac_val -= 16;
2658             if (s->ac_pred)
2659                 memcpy(ac_val2, ac_val, 8 * 2);
2660         } else { // top
2661             ac_val -= 16 * s->block_wrap[n];
2662             if (s->ac_pred)
2663                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2664         }
2665
2666         /* apply AC prediction if needed */
2667         if (s->ac_pred) {
2668             if (dc_pred_dir) { //left
2669                 for (k = 1; k < 8; k++) {
2670                     block[k << v->left_blk_sh] = ac_val[k] * scale;
2671                     if (!v->pquantizer && block[k << v->left_blk_sh])
2672                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -v->pq : v->pq;
2673                 }
2674             } else { // top
2675                 for (k = 1; k < 8; k++) {
2676                     block[k << v->top_blk_sh] = ac_val[k + 8] * scale;
2677                     if (!v->pquantizer && block[k << v->top_blk_sh])
2678                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -v->pq : v->pq;
2679                 }
2680             }
2681             i = 63;
2682         }
2683     }
2684     s->block_last_index[n] = i;
2685
2686     return 0;
2687 }
2688
2689 /** Decode intra block in intra frames - should be faster than decode_intra_block
2690  * @param v VC1Context
2691  * @param block block to decode
2692  * @param[in] n subblock number
2693  * @param coded are AC coeffs present or not
2694  * @param codingset set of VLC to decode data
2695  * @param mquant quantizer value for this macroblock
2696  */
2697 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n,
2698                                   int coded, int codingset, int mquant)
2699 {
2700     GetBitContext *gb = &v->s.gb;
2701     MpegEncContext *s = &v->s;
2702     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2703     int i;
2704     int16_t *dc_val;
2705     int16_t *ac_val, *ac_val2;
2706     int dcdiff;
2707     int a_avail = v->a_avail, c_avail = v->c_avail;
2708     int use_pred = s->ac_pred;
2709     int scale;
2710     int q1, q2 = 0;
2711     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2712
2713     /* Get DC differential */
2714     if (n < 4) {
2715         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2716     } else {
2717         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2718     }
2719     if (dcdiff < 0) {
2720         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2721         return -1;
2722     }
2723     if (dcdiff) {
2724         if (dcdiff == 119 /* ESC index value */) {
2725             /* TODO: Optimize */
2726             if (mquant == 1)      dcdiff = get_bits(gb, 10);
2727             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2728             else                  dcdiff = get_bits(gb, 8);
2729         } else {
2730             if (mquant == 1)
2731                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2732             else if (mquant == 2)
2733                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
2734         }
2735         if (get_bits1(gb))
2736             dcdiff = -dcdiff;
2737     }
2738
2739     /* Prediction */
2740     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2741     *dc_val = dcdiff;
2742
2743     /* Store the quantized DC coeff, used for prediction */
2744     if (n < 4) {
2745         block[0] = dcdiff * s->y_dc_scale;
2746     } else {
2747         block[0] = dcdiff * s->c_dc_scale;
2748     }
2749
2750     //AC Decoding
2751     i = 1;
2752
2753     /* check if AC is needed at all */
2754     if (!a_avail && !c_avail)
2755         use_pred = 0;
2756     ac_val  = s->ac_val[0][0] + s->block_index[n] * 16;
2757     ac_val2 = ac_val;
2758
2759     scale = mquant * 2 + ((mquant == v->pq) ? v->halfpq : 0);
2760
2761     if (dc_pred_dir) // left
2762         ac_val -= 16;
2763     else // top
2764         ac_val -= 16 * s->block_wrap[n];
2765
2766     q1 = s->current_picture.f.qscale_table[mb_pos];
2767     if ( dc_pred_dir && c_avail && mb_pos)
2768         q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2769     if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2770         q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2771     if ( dc_pred_dir && n == 1)
2772         q2 = q1;
2773     if (!dc_pred_dir && n == 2)
2774         q2 = q1;
2775     if (n == 3)
2776         q2 = q1;
2777
2778     if (coded) {
2779         int last = 0, skip, value;
2780         const uint8_t *zz_table;
2781         int k;
2782
2783         if (v->s.ac_pred) {
2784             if (!use_pred && v->fcm == ILACE_FRAME) {
2785                 zz_table = v->zzi_8x8;
2786             } else {
2787                 if (!dc_pred_dir) // top
2788                     zz_table = v->zz_8x8[2];
2789                 else // left
2790                     zz_table = v->zz_8x8[3];
2791             }
2792         } else {
2793             if (v->fcm != ILACE_FRAME)
2794                 zz_table = v->zz_8x8[1];
2795             else
2796                 zz_table = v->zzi_8x8;
2797         }
2798
2799         while (!last) {
2800             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2801             i += skip;
2802             if (i > 63)
2803                 break;
2804             block[zz_table[i++]] = value;
2805         }
2806
2807         /* apply AC prediction if needed */
2808         if (use_pred) {
2809             /* scale predictors if needed*/
2810             if (q2 && q1 != q2) {
2811                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2812                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2813
2814                 if (q1 < 1)
2815                     return AVERROR_INVALIDDATA;
2816                 if (dc_pred_dir) { // left
2817                     for (k = 1; k < 8; k++)
2818                         block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2819                 } else { // top
2820                     for (k = 1; k < 8; k++)
2821                         block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2822                 }
2823             } else {
2824                 if (dc_pred_dir) { //left
2825                     for (k = 1; k < 8; k++)
2826                         block[k << v->left_blk_sh] += ac_val[k];
2827                 } else { //top
2828                     for (k = 1; k < 8; k++)
2829                         block[k << v->top_blk_sh] += ac_val[k + 8];
2830                 }
2831             }
2832         }
2833         /* save AC coeffs for further prediction */
2834         for (k = 1; k < 8; k++) {
2835             ac_val2[k    ] = block[k << v->left_blk_sh];
2836             ac_val2[k + 8] = block[k << v->top_blk_sh];
2837         }
2838
2839         /* scale AC coeffs */
2840         for (k = 1; k < 64; k++)
2841             if (block[k]) {
2842                 block[k] *= scale;
2843                 if (!v->pquantizer)
2844                     block[k] += (block[k] < 0) ? -mquant : mquant;
2845             }
2846
2847         if (use_pred) i = 63;
2848     } else { // no AC coeffs
2849         int k;
2850
2851         memset(ac_val2, 0, 16 * 2);
2852         if (dc_pred_dir) { // left
2853             if (use_pred) {
2854                 memcpy(ac_val2, ac_val, 8 * 2);
2855                 if (q2 && q1 != q2) {
2856                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2857                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2858                     if (q1 < 1)
2859                         return AVERROR_INVALIDDATA;
2860                     for (k = 1; k < 8; k++)
2861                         ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2862                 }
2863             }
2864         } else { // top
2865             if (use_pred) {
2866                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2867                 if (q2 && q1 != q2) {
2868                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2869                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2870                     if (q1 < 1)
2871                         return AVERROR_INVALIDDATA;
2872                     for (k = 1; k < 8; k++)
2873                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2874                 }
2875             }
2876         }
2877
2878         /* apply AC prediction if needed */
2879         if (use_pred) {
2880             if (dc_pred_dir) { // left
2881                 for (k = 1; k < 8; k++) {
2882                     block[k << v->left_blk_sh] = ac_val2[k] * scale;
2883                     if (!v->pquantizer && block[k << v->left_blk_sh])
2884                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
2885                 }
2886             } else { // top
2887                 for (k = 1; k < 8; k++) {
2888                     block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
2889                     if (!v->pquantizer && block[k << v->top_blk_sh])
2890                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
2891                 }
2892             }
2893             i = 63;
2894         }
2895     }
2896     s->block_last_index[n] = i;
2897
2898     return 0;
2899 }
2900
2901 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2902  * @param v VC1Context
2903  * @param block block to decode
2904  * @param[in] n subblock index
2905  * @param coded are AC coeffs present or not
2906  * @param mquant block quantizer
2907  * @param codingset set of VLC to decode data
2908  */
2909 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n,
2910                                   int coded, int mquant, int codingset)
2911 {
2912     GetBitContext *gb = &v->s.gb;
2913     MpegEncContext *s = &v->s;
2914     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2915     int i;
2916     int16_t *dc_val;
2917     int16_t *ac_val, *ac_val2;
2918     int dcdiff;
2919     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2920     int a_avail = v->a_avail, c_avail = v->c_avail;
2921     int use_pred = s->ac_pred;
2922     int scale;
2923     int q1, q2 = 0;
2924
2925     s->dsp.clear_block(block);
2926
2927     /* XXX: Guard against dumb values of mquant */
2928     mquant = (mquant < 1) ? 0 : ((mquant > 31) ? 31 : mquant);
2929
2930     /* Set DC scale - y and c use the same */
2931     s->y_dc_scale = s->y_dc_scale_table[mquant];
2932     s->c_dc_scale = s->c_dc_scale_table[mquant];
2933
2934     /* Get DC differential */
2935     if (n < 4) {
2936         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2937     } else {
2938         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2939     }
2940     if (dcdiff < 0) {
2941         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2942         return -1;
2943     }
2944     if (dcdiff) {
2945         if (dcdiff == 119 /* ESC index value */) {
2946             /* TODO: Optimize */
2947             if (mquant == 1)      dcdiff = get_bits(gb, 10);
2948             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2949             else                  dcdiff = get_bits(gb, 8);
2950         } else {
2951             if (mquant == 1)
2952                 dcdiff = (dcdiff << 2) + get_bits(gb, 2) - 3;
2953             else if (mquant == 2)
2954                 dcdiff = (dcdiff << 1) + get_bits1(gb)   - 1;
2955         }
2956         if (get_bits1(gb))
2957             dcdiff = -dcdiff;
2958     }
2959
2960     /* Prediction */
2961     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2962     *dc_val = dcdiff;
2963
2964     /* Store the quantized DC coeff, used for prediction */
2965
2966     if (n < 4) {
2967         block[0] = dcdiff * s->y_dc_scale;
2968     } else {
2969         block[0] = dcdiff * s->c_dc_scale;
2970     }
2971
2972     //AC Decoding
2973     i = 1;
2974
2975     /* check if AC is needed at all and adjust direction if needed */
2976     if (!a_avail) dc_pred_dir = 1;
2977     if (!c_avail) dc_pred_dir = 0;
2978     if (!a_avail && !c_avail) use_pred = 0;
2979     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2980     ac_val2 = ac_val;
2981
2982     scale = mquant * 2 + v->halfpq;
2983
2984     if (dc_pred_dir) //left
2985         ac_val -= 16;
2986     else //top
2987         ac_val -= 16 * s->block_wrap[n];
2988
2989     q1 = s->current_picture.f.qscale_table[mb_pos];
2990     if (dc_pred_dir && c_avail && mb_pos)
2991         q2 = s->current_picture.f.qscale_table[mb_pos - 1];
2992     if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride)
2993         q2 = s->current_picture.f.qscale_table[mb_pos - s->mb_stride];
2994     if ( dc_pred_dir && n == 1)
2995         q2 = q1;
2996     if (!dc_pred_dir && n == 2)
2997         q2 = q1;
2998     if (n == 3) q2 = q1;
2999
3000     if (coded) {
3001         int last = 0, skip, value;
3002         int k;
3003
3004         while (!last) {
3005             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3006             i += skip;
3007             if (i > 63)
3008                 break;
3009             if (v->fcm == PROGRESSIVE)
3010                 block[v->zz_8x8[0][i++]] = value;
3011             else {
3012                 if (use_pred && (v->fcm == ILACE_FRAME)) {
3013                     if (!dc_pred_dir) // top
3014                         block[v->zz_8x8[2][i++]] = value;
3015                     else // left
3016                         block[v->zz_8x8[3][i++]] = value;
3017                 } else {
3018                     block[v->zzi_8x8[i++]] = value;
3019                 }
3020             }
3021         }
3022
3023         /* apply AC prediction if needed */
3024         if (use_pred) {
3025             /* scale predictors if needed*/
3026             if (q2 && q1 != q2) {
3027                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3028                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3029
3030                 if (q1 < 1)
3031                     return AVERROR_INVALIDDATA;
3032                 if (dc_pred_dir) { // left
3033                     for (k = 1; k < 8; k++)
3034                         block[k << v->left_blk_sh] += (ac_val[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3035                 } else { //top
3036                     for (k = 1; k < 8; k++)
3037                         block[k << v->top_blk_sh] += (ac_val[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3038                 }
3039             } else {
3040                 if (dc_pred_dir) { // left
3041                     for (k = 1; k < 8; k++)
3042                         block[k << v->left_blk_sh] += ac_val[k];
3043                 } else { // top
3044                     for (k = 1; k < 8; k++)
3045                         block[k << v->top_blk_sh] += ac_val[k + 8];
3046                 }
3047             }
3048         }
3049         /* save AC coeffs for further prediction */
3050         for (k = 1; k < 8; k++) {
3051             ac_val2[k    ] = block[k << v->left_blk_sh];
3052             ac_val2[k + 8] = block[k << v->top_blk_sh];
3053         }
3054
3055         /* scale AC coeffs */
3056         for (k = 1; k < 64; k++)
3057             if (block[k]) {
3058                 block[k] *= scale;
3059                 if (!v->pquantizer)
3060                     block[k] += (block[k] < 0) ? -mquant : mquant;
3061             }
3062
3063         if (use_pred) i = 63;
3064     } else { // no AC coeffs
3065         int k;
3066
3067         memset(ac_val2, 0, 16 * 2);
3068         if (dc_pred_dir) { // left
3069             if (use_pred) {
3070                 memcpy(ac_val2, ac_val, 8 * 2);
3071                 if (q2 && q1 != q2) {
3072                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3073                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3074                     if (q1 < 1)
3075                         return AVERROR_INVALIDDATA;
3076                     for (k = 1; k < 8; k++)
3077                         ac_val2[k] = (ac_val2[k] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3078                 }
3079             }
3080         } else { // top
3081             if (use_pred) {
3082                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3083                 if (q2 && q1 != q2) {
3084                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3085                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3086                     if (q1 < 1)
3087                         return AVERROR_INVALIDDATA;
3088                     for (k = 1; k < 8; k++)
3089                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3090                 }
3091             }
3092         }
3093
3094         /* apply AC prediction if needed */
3095         if (use_pred) {
3096             if (dc_pred_dir) { // left
3097                 for (k = 1; k < 8; k++) {
3098                     block[k << v->left_blk_sh] = ac_val2[k] * scale;
3099                     if (!v->pquantizer && block[k << v->left_blk_sh])
3100                         block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -mquant : mquant;
3101                 }
3102             } else { // top
3103                 for (k = 1; k < 8; k++) {
3104                     block[k << v->top_blk_sh] = ac_val2[k + 8] * scale;
3105                     if (!v->pquantizer && block[k << v->top_blk_sh])
3106                         block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -mquant : mquant;
3107                 }
3108             }
3109             i = 63;
3110         }
3111     }
3112     s->block_last_index[n] = i;
3113
3114     return 0;
3115 }
3116
3117 /** Decode P block
3118  */
3119 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n,
3120                               int mquant, int ttmb, int first_block,
3121                               uint8_t *dst, int linesize, int skip_block,
3122                               int *ttmb_out)
3123 {
3124     MpegEncContext *s = &v->s;
3125     GetBitContext *gb = &s->gb;
3126     int i, j;
3127     int subblkpat = 0;
3128     int scale, off, idx, last, skip, value;
3129     int ttblk = ttmb & 7;
3130     int pat = 0;
3131
3132     s->dsp.clear_block(block);
3133
3134     if (ttmb == -1) {
3135         ttblk = ff_vc1_ttblk_to_tt[v->tt_index][get_vlc2(gb, ff_vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
3136     }
3137     if (ttblk == TT_4X4) {
3138         subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3139     }
3140     if ((ttblk != TT_8X8 && ttblk != TT_4X4)
3141         && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))
3142             || (!v->res_rtm_flag && !first_block))) {
3143         subblkpat = decode012(gb);
3144         if (subblkpat)
3145             subblkpat ^= 3; // swap decoded pattern bits
3146         if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM)
3147             ttblk = TT_8X4;
3148         if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT)
3149             ttblk = TT_4X8;
3150     }
3151     scale = 2 * mquant + ((v->pq == mquant) ? v->halfpq : 0);
3152
3153     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3154     if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3155         subblkpat = 2 - (ttblk == TT_8X4_TOP);
3156         ttblk     = TT_8X4;
3157     }
3158     if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3159         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3160         ttblk     = TT_4X8;
3161     }
3162     switch (ttblk) {
3163     case TT_8X8:
3164         pat  = 0xF;
3165         i    = 0;
3166         last = 0;
3167         while (!last) {
3168             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3169             i += skip;
3170             if (i > 63)
3171                 break;
3172             if (!v->fcm)
3173                 idx = v->zz_8x8[0][i++];
3174             else
3175                 idx = v->zzi_8x8[i++];
3176             block[idx] = value * scale;
3177             if (!v->pquantizer)
3178                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3179         }
3180         if (!skip_block) {
3181             if (i == 1)
3182                 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
3183             else {
3184                 v->vc1dsp.vc1_inv_trans_8x8(block);
3185                 s->dsp.add_pixels_clamped(block, dst, linesize);
3186             }
3187         }
3188         break;
3189     case TT_4X4:
3190         pat = ~subblkpat & 0xF;
3191         for (j = 0; j < 4; j++) {
3192             last = subblkpat & (1 << (3 - j));
3193             i    = 0;
3194             off  = (j & 1) * 4 + (j & 2) * 16;
3195             while (!last) {
3196                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3197                 i += skip;
3198                 if (i > 15)
3199                     break;
3200                 if (!v->fcm)
3201                     idx = ff_vc1_simple_progressive_4x4_zz[i++];
3202                 else
3203                     idx = ff_vc1_adv_interlaced_4x4_zz[i++];
3204                 block[idx + off] = value * scale;
3205                 if (!v->pquantizer)
3206                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3207             }
3208             if (!(subblkpat & (1 << (3 - j))) && !skip_block) {
3209                 if (i == 1)
3210                     v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off);
3211                 else
3212                     v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) *  2 * linesize, linesize, block + off);
3213             }
3214         }
3215         break;
3216     case TT_8X4:
3217         pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF;
3218         for (j = 0; j < 2; j++) {
3219             last = subblkpat & (1 << (1 - j));
3220             i    = 0;
3221             off  = j * 32;
3222             while (!last) {
3223                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3224                 i += skip;
3225                 if (i > 31)
3226                     break;
3227                 if (!v->fcm)
3228                     idx = v->zz_8x4[i++] + off;
3229                 else
3230                     idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off;
3231                 block[idx] = value * scale;
3232                 if (!v->pquantizer)
3233                     block[idx] += (block[idx] < 0) ? -mquant : mquant;
3234             }
3235             if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3236                 if (i == 1)
3237                     v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off);
3238                 else
3239                     v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off);
3240             }
3241         }
3242         break;
3243     case TT_4X8:
3244         pat = ~(subblkpat * 5) & 0xF;
3245         for (j = 0; j < 2; j++) {
3246             last = subblkpat & (1 << (1 - j));
3247             i    = 0;
3248             off  = j * 4;
3249             while (!last) {
3250                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3251                 i += skip;
3252                 if (i > 31)
3253                     break;
3254                 if (!v->fcm)
3255                     idx = v->zz_4x8[i++] + off;
3256                 else
3257                     idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off;
3258                 block[idx] = value * scale;
3259                 if (!v->pquantizer)
3260                     block[idx] += (block[idx] < 0) ? -mquant : mquant;
3261             }
3262             if (!(subblkpat & (1 << (1 - j))) && !skip_block) {
3263                 if (i == 1)
3264                     v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off);
3265                 else
3266                     v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
3267             }
3268         }
3269         break;
3270     }
3271     if (ttmb_out)
3272         *ttmb_out |= ttblk << (n * 4);
3273     return pat;
3274 }
3275
3276 /** @} */ // Macroblock group
3277
3278 static const int size_table  [6] = { 0, 2, 3, 4,  5,  8 };
3279 static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3280
3281 static av_always_inline void vc1_apply_p_v_loop_filter(VC1Context *v, int block_num)
3282 {
3283     MpegEncContext *s  = &v->s;
3284     int mb_cbp         = v->cbp[s->mb_x - s->mb_stride],
3285         block_cbp      = mb_cbp      >> (block_num * 4), bottom_cbp,
3286         mb_is_intra    = v->is_intra[s->mb_x - s->mb_stride],
3287         block_is_intra = mb_is_intra >> (block_num * 4), bottom_is_intra;
3288     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3289     uint8_t *dst;
3290
3291     if (block_num > 3) {
3292         dst      = s->dest[block_num - 3];
3293     } else {
3294         dst      = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 8) * linesize;
3295     }
3296     if (s->mb_y != s->end_mb_y || block_num < 2) {
3297         int16_t (*mv)[2];
3298         int mv_stride;
3299
3300         if (block_num > 3) {
3301             bottom_cbp      = v->cbp[s->mb_x]      >> (block_num * 4);
3302             bottom_is_intra = v->is_intra[s->mb_x] >> (block_num * 4);
3303             mv              = &v->luma_mv[s->mb_x - s->mb_stride];
3304             mv_stride       = s->mb_stride;
3305         } else {
3306             bottom_cbp      = (block_num < 2) ? (mb_cbp               >> ((block_num + 2) * 4))
3307                                               : (v->cbp[s->mb_x]      >> ((block_num - 2) * 4));
3308             bottom_is_intra = (block_num < 2) ? (mb_is_intra          >> ((block_num + 2) * 4))
3309                                               : (v->is_intra[s->mb_x] >> ((block_num - 2) * 4));
3310             mv_stride       = s->b8_stride;
3311             mv              = &s->current_picture.f.motion_val[0][s->block_index[block_num] - 2 * mv_stride];
3312         }
3313
3314         if (bottom_is_intra & 1 || block_is_intra & 1 ||
3315             mv[0][0] != mv[mv_stride][0] || mv[0][1] != mv[mv_stride][1]) {
3316             v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3317         } else {
3318             idx = ((bottom_cbp >> 2) | block_cbp) & 3;
3319             if (idx == 3) {
3320                 v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3321             } else if (idx) {
3322                 if (idx == 1)
3323                     v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3324                 else
3325                     v->vc1dsp.vc1_v_loop_filter4(dst,     linesize, v->pq);
3326             }
3327         }
3328     }
3329
3330     dst -= 4 * linesize;
3331     ttblk = (v->ttblk[s->mb_x - s->mb_stride] >> (block_num * 4)) & 0xF;
3332     if (ttblk == TT_4X4 || ttblk == TT_8X4) {
3333         idx = (block_cbp | (block_cbp >> 2)) & 3;
3334         if (idx == 3) {
3335             v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
3336         } else if (idx) {
3337             if (idx == 1)
3338                 v->vc1dsp.vc1_v_loop_filter4(dst + 4, linesize, v->pq);
3339             else
3340                 v->vc1dsp.vc1_v_loop_filter4(dst,     linesize, v->pq);
3341         }
3342     }
3343 }
3344
3345 static av_always_inline void vc1_apply_p_h_loop_filter(VC1Context *v, int block_num)
3346 {
3347     MpegEncContext *s  = &v->s;
3348     int mb_cbp         = v->cbp[s->mb_x - 1 - s->mb_stride],
3349         block_cbp      = mb_cbp      >> (block_num * 4), right_cbp,
3350         mb_is_intra    = v->is_intra[s->mb_x - 1 - s->mb_stride],
3351         block_is_intra = mb_is_intra >> (block_num * 4), right_is_intra;
3352     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize, ttblk;
3353     uint8_t *dst;
3354
3355     if (block_num > 3) {
3356         dst = s->dest[block_num - 3] - 8 * linesize;
3357     } else {
3358         dst = s->dest[0] + (block_num & 1) * 8 + ((block_num & 2) * 4 - 16) * linesize - 8;
3359     }
3360
3361     if (s->mb_x != s->mb_width || !(block_num & 5)) {
3362         int16_t (*mv)[2];
3363
3364         if (block_num > 3) {
3365             right_cbp      = v->cbp[s->mb_x - s->mb_stride] >> (block_num * 4);
3366             right_is_intra = v->is_intra[s->mb_x - s->mb_stride] >> (block_num * 4);
3367             mv             = &v->luma_mv[s->mb_x - s->mb_stride - 1];
3368         } else {
3369             right_cbp      = (block_num & 1) ? (v->cbp[s->mb_x - s->mb_stride]      >> ((block_num - 1) * 4))
3370                                              : (mb_cbp                              >> ((block_num + 1) * 4));
3371             right_is_intra = (block_num & 1) ? (v->is_intra[s->mb_x - s->mb_stride] >> ((block_num - 1) * 4))
3372                                              : (mb_is_intra                         >> ((block_num + 1) * 4));
3373             mv             = &s->current_picture.f.motion_val[0][s->block_index[block_num] - s->b8_stride * 2 - 2];
3374         }
3375         if (block_is_intra & 1 || right_is_intra & 1 || mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1]) {
3376             v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3377         } else {
3378             idx = ((right_cbp >> 1) | block_cbp) & 5; // FIXME check
3379             if (idx == 5) {
3380                 v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3381             } else if (idx) {
3382                 if (idx == 1)
3383                     v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize, linesize, v->pq);
3384                 else
3385                     v->vc1dsp.vc1_h_loop_filter4(dst,                linesize, v->pq);
3386             }
3387         }
3388     }
3389
3390     dst -= 4;
3391     ttblk = (v->ttblk[s->mb_x - s->mb_stride - 1] >> (block_num * 4)) & 0xf;
3392     if (ttblk == TT_4X4 || ttblk == TT_4X8) {
3393         idx = (block_cbp | (block_cbp >> 1)) & 5;
3394         if (idx == 5) {
3395             v->vc1dsp.vc1_h_loop_filter8(dst, linesize, v->pq);
3396         } else if (idx) {
3397             if (idx == 1)
3398                 v->vc1dsp.vc1_h_loop_filter4(dst + linesize * 4, linesize, v->pq);
3399             else
3400                 v->vc1dsp.vc1_h_loop_filter4(dst,                linesize, v->pq);
3401         }
3402     }
3403 }
3404
3405 static void vc1_apply_p_loop_filter(VC1Context *v)
3406 {
3407     MpegEncContext *s = &v->s;
3408     int i;
3409
3410     for (i = 0; i < 6; i++) {
3411         vc1_apply_p_v_loop_filter(v, i);
3412     }
3413
3414     /* V always precedes H, therefore we run H one MB before V;
3415      * at the end of a row, we catch up to complete the row */
3416     if (s->mb_x) {
3417         for (i = 0; i < 6; i++) {
3418             vc1_apply_p_h_loop_filter(v, i);
3419         }
3420         if (s->mb_x == s->mb_width - 1) {
3421             s->mb_x++;
3422             ff_update_block_index(s);
3423             for (i = 0; i < 6; i++) {
3424                 vc1_apply_p_h_loop_filter(v, i);
3425             }
3426         }
3427     }
3428 }
3429
3430 /** Decode one P-frame MB
3431  */
3432 static int vc1_decode_p_mb(VC1Context *v)
3433 {
3434     MpegEncContext *s = &v->s;
3435     GetBitContext *gb = &s->gb;
3436     int i, j;
3437     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3438     int cbp; /* cbp decoding stuff */
3439     int mqdiff, mquant; /* MB quantization */
3440     int ttmb = v->ttfrm; /* MB Transform type */
3441
3442     int mb_has_coeffs = 1; /* last_flag */
3443     int dmv_x, dmv_y; /* Differential MV components */
3444     int index, index1; /* LUT indexes */
3445     int val, sign; /* temp values */
3446     int first_block = 1;
3447     int dst_idx, off;
3448     int skipped, fourmv;
3449     int block_cbp = 0, pat, block_tt = 0, block_intra = 0;
3450
3451     mquant = v->pq; /* lossy initialization */
3452
3453     if (v->mv_type_is_raw)
3454         fourmv = get_bits1(gb);
3455     else
3456         fourmv = v->mv_type_mb_plane[mb_pos];
3457     if (v->skip_is_raw)
3458         skipped = get_bits1(gb);
3459     else
3460         skipped = v->s.mbskip_table[mb_pos];
3461
3462     if (!fourmv) { /* 1MV mode */
3463         if (!skipped) {
3464             GET_MVDATA(dmv_x, dmv_y);
3465
3466             if (s->mb_intra) {
3467                 s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3468                 s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3469             }
3470             s->current_picture.f.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3471             vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3472
3473             /* FIXME Set DC val for inter block ? */
3474             if (s->mb_intra && !mb_has_coeffs) {
3475                 GET_MQUANT();
3476                 s->ac_pred = get_bits1(gb);
3477                 cbp        = 0;
3478             } else if (mb_has_coeffs) {
3479                 if (s->mb_intra)
3480                     s->ac_pred = get_bits1(gb);
3481                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3482                 GET_MQUANT();
3483             } else {
3484                 mquant = v->pq;
3485                 cbp    = 0;
3486             }
3487             s->current_picture.f.qscale_table[mb_pos] = mquant;
3488
3489             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3490                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table,
3491                                 VC1_TTMB_VLC_BITS, 2);
3492             if (!s->mb_intra) vc1_mc_1mv(v, 0);
3493             dst_idx = 0;
3494             for (i = 0; i < 6; i++) {
3495                 s->dc_val[0][s->block_index[i]] = 0;
3496                 dst_idx += i >> 2;
3497                 val = ((cbp >> (5 - i)) & 1);
3498                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3499                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3500                 if (s->mb_intra) {
3501                     /* check if prediction blocks A and C are available */
3502                     v->a_avail = v->c_avail = 0;
3503                     if (i == 2 || i == 3 || !s->first_slice_line)
3504                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3505                     if (i == 1 || i == 3 || s->mb_x)
3506                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3507
3508                     vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3509                                            (i & 4) ? v->codingset2 : v->codingset);
3510                     if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3511                         continue;
3512                     v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3513                     if (v->rangeredfrm)
3514                         for (j = 0; j < 64; j++)
3515                             s->block[i][j] <<= 1;
3516                     s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3517                     if (v->pq >= 9 && v->overlap) {
3518                         if (v->c_avail)
3519                             v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3520                         if (v->a_avail)
3521                             v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3522                     }
3523                     block_cbp   |= 0xF << (i << 2);
3524                     block_intra |= 1 << i;
3525                 } else if (val) {
3526                     pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block,
3527                                              s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize,
3528                                              (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3529                     block_cbp |= pat << (i << 2);
3530                     if (!v->ttmbf && ttmb < 8)
3531                         ttmb = -1;
3532                     first_block = 0;
3533                 }
3534             }
3535         } else { // skipped
3536             s->mb_intra = 0;
3537             for (i = 0; i < 6; i++) {
3538                 v->mb_type[0][s->block_index[i]] = 0;
3539                 s->dc_val[0][s->block_index[i]]  = 0;
3540             }
3541             s->current_picture.f.mb_type[mb_pos]      = MB_TYPE_SKIP;
3542             s->current_picture.f.qscale_table[mb_pos] = 0;
3543             vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3544             vc1_mc_1mv(v, 0);
3545         }
3546     } else { // 4MV mode
3547         if (!skipped /* unskipped MB */) {
3548             int intra_count = 0, coded_inter = 0;
3549             int is_intra[6], is_coded[6];
3550             /* Get CBPCY */
3551             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3552             for (i = 0; i < 6; i++) {
3553                 val = ((cbp >> (5 - i)) & 1);
3554                 s->dc_val[0][s->block_index[i]] = 0;
3555                 s->mb_intra                     = 0;
3556                 if (i < 4) {
3557                     dmv_x = dmv_y = 0;
3558                     s->mb_intra   = 0;
3559                     mb_has_coeffs = 0;
3560                     if (val) {
3561                         GET_MVDATA(dmv_x, dmv_y);
3562                     }
3563                     vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3564                     if (!s->mb_intra)
3565                         vc1_mc_4mv_luma(v, i, 0);
3566                     intra_count += s->mb_intra;
3567                     is_intra[i]  = s->mb_intra;
3568                     is_coded[i]  = mb_has_coeffs;
3569                 }
3570                 if (i & 4) {
3571                     is_intra[i] = (intra_count >= 3);
3572                     is_coded[i] = val;
3573                 }
3574                 if (i == 4)
3575                     vc1_mc_4mv_chroma(v, 0);
3576                 v->mb_type[0][s->block_index[i]] = is_intra[i];
3577                 if (!coded_inter)
3578                     coded_inter = !is_intra[i] & is_coded[i];
3579             }
3580             // if there are no coded blocks then don't do anything more
3581             dst_idx = 0;
3582             if (!intra_count && !coded_inter)
3583                 goto end;
3584             GET_MQUANT();
3585             s->current_picture.f.qscale_table[mb_pos] = mquant;
3586             /* test if block is intra and has pred */
3587             {
3588                 int intrapred = 0;
3589                 for (i = 0; i < 6; i++)
3590                     if (is_intra[i]) {
3591                         if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3592                             || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[0][s->block_index[i] - 1])) {
3593                             intrapred = 1;
3594                             break;
3595                         }
3596                     }
3597                 if (intrapred)
3598                     s->ac_pred = get_bits1(gb);
3599                 else
3600                     s->ac_pred = 0;
3601             }
3602             if (!v->ttmbf && coded_inter)
3603                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3604             for (i = 0; i < 6; i++) {
3605                 dst_idx    += i >> 2;
3606                 off         = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3607                 s->mb_intra = is_intra[i];
3608                 if (is_intra[i]) {
3609                     /* check if prediction blocks A and C are available */
3610                     v->a_avail = v->c_avail = 0;
3611                     if (i == 2 || i == 3 || !s->first_slice_line)
3612                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3613                     if (i == 1 || i == 3 || s->mb_x)
3614                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3615
3616                     vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant,
3617                                            (i & 4) ? v->codingset2 : v->codingset);
3618                     if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3619                         continue;
3620                     v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3621                     if (v->rangeredfrm)
3622                         for (j = 0; j < 64; j++)
3623                             s->block[i][j] <<= 1;
3624                     s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
3625                                                      (i & 4) ? s->uvlinesize : s->linesize);
3626                     if (v->pq >= 9 && v->overlap) {
3627                         if (v->c_avail)
3628                             v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3629                         if (v->a_avail)
3630                             v->vc1dsp.vc1_v_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
3631                     }
3632                     block_cbp   |= 0xF << (i << 2);
3633                     block_intra |= 1 << i;
3634                 } else if (is_coded[i]) {
3635                     pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3636                                              first_block, s->dest[dst_idx] + off,
3637                                              (i & 4) ? s->uvlinesize : s->linesize,
3638                                              (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3639                                              &block_tt);
3640                     block_cbp |= pat << (i << 2);
3641                     if (!v->ttmbf && ttmb < 8)
3642                         ttmb = -1;
3643                     first_block = 0;
3644                 }
3645             }
3646         } else { // skipped MB
3647             s->mb_intra                               = 0;
3648             s->current_picture.f.qscale_table[mb_pos] = 0;
3649             for (i = 0; i < 6; i++) {
3650                 v->mb_type[0][s->block_index[i]] = 0;
3651                 s->dc_val[0][s->block_index[i]]  = 0;
3652             }
3653             for (i = 0; i < 4; i++) {
3654                 vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0], 0, 0);
3655                 vc1_mc_4mv_luma(v, i, 0);
3656             }
3657             vc1_mc_4mv_chroma(v, 0);
3658             s->current_picture.f.qscale_table[mb_pos] = 0;
3659         }
3660     }
3661 end:
3662     v->cbp[s->mb_x]      = block_cbp;
3663     v->ttblk[s->mb_x]    = block_tt;
3664     v->is_intra[s->mb_x] = block_intra;
3665
3666     return 0;
3667 }
3668
3669 /* Decode one macroblock in an interlaced frame p picture */
3670
3671 static int vc1_decode_p_mb_intfr(VC1Context *v)
3672 {
3673     MpegEncContext *s = &v->s;
3674     GetBitContext *gb = &s->gb;
3675     int i;
3676     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3677     int cbp = 0; /* cbp decoding stuff */
3678     int mqdiff, mquant; /* MB quantization */
3679     int ttmb = v->ttfrm; /* MB Transform type */
3680
3681     int mb_has_coeffs = 1; /* last_flag */
3682     int dmv_x, dmv_y; /* Differential MV components */
3683     int val; /* temp value */
3684     int first_block = 1;
3685     int dst_idx, off;
3686     int skipped, fourmv = 0, twomv = 0;
3687     int block_cbp = 0, pat, block_tt = 0;
3688     int idx_mbmode = 0, mvbp;
3689     int stride_y, fieldtx;
3690
3691     mquant = v->pq; /* Loosy initialization */
3692
3693     if (v->skip_is_raw)
3694         skipped = get_bits1(gb);
3695     else
3696         skipped = v->s.mbskip_table[mb_pos];
3697     if (!skipped) {
3698         if (v->fourmvswitch)
3699             idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done
3700         else
3701             idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line
3702         switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) {
3703         /* store the motion vector type in a flag (useful later) */
3704         case MV_PMODE_INTFR_4MV:
3705             fourmv = 1;
3706             v->blk_mv_type[s->block_index[0]] = 0;
3707             v->blk_mv_type[s->block_index[1]] = 0;
3708             v->blk_mv_type[s->block_index[2]] = 0;
3709             v->blk_mv_type[s->block_index[3]] = 0;
3710             break;
3711         case MV_PMODE_INTFR_4MV_FIELD:
3712             fourmv = 1;
3713             v->blk_mv_type[s->block_index[0]] = 1;
3714             v->blk_mv_type[s->block_index[1]] = 1;
3715             v->blk_mv_type[s->block_index[2]] = 1;
3716             v->blk_mv_type[s->block_index[3]] = 1;
3717             break;
3718         case MV_PMODE_INTFR_2MV_FIELD:
3719             twomv = 1;
3720             v->blk_mv_type[s->block_index[0]] = 1;
3721             v->blk_mv_type[s->block_index[1]] = 1;
3722             v->blk_mv_type[s->block_index[2]] = 1;
3723             v->blk_mv_type[s->block_index[3]] = 1;
3724             break;
3725         case MV_PMODE_INTFR_1MV:
3726             v->blk_mv_type[s->block_index[0]] = 0;
3727             v->blk_mv_type[s->block_index[1]] = 0;
3728             v->blk_mv_type[s->block_index[2]] = 0;
3729             v->blk_mv_type[s->block_index[3]] = 0;
3730             break;
3731         }
3732         if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB
3733             s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
3734             s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
3735             s->current_picture.f.mb_type[mb_pos]                     = MB_TYPE_INTRA;
3736             s->mb_intra = v->is_intra[s->mb_x] = 1;
3737             for (i = 0; i < 6; i++)
3738                 v->mb_type[0][s->block_index[i]] = 1;
3739             fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb);
3740             mb_has_coeffs = get_bits1(gb);
3741             if (mb_has_coeffs)
3742                 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3743             v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb);
3744             GET_MQUANT();
3745             s->current_picture.f.qscale_table[mb_pos] = mquant;
3746             /* Set DC scale - y and c use the same (not sure if necessary here) */
3747             s->y_dc_scale = s->y_dc_scale_table[mquant];
3748             s->c_dc_scale = s->c_dc_scale_table[mquant];
3749             dst_idx = 0;
3750             for (i = 0; i < 6; i++) {
3751                 s->dc_val[0][s->block_index[i]] = 0;
3752                 dst_idx += i >> 2;
3753                 val = ((cbp >> (5 - i)) & 1);
3754                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3755                 v->a_avail = v->c_avail = 0;
3756                 if (i == 2 || i == 3 || !s->first_slice_line)
3757                     v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3758                 if (i == 1 || i == 3 || s->mb_x)
3759                     v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3760
3761                 vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3762                                        (i & 4) ? v->codingset2 : v->codingset);
3763                 if ((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3764                 v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3765                 if (i < 4) {
3766                     stride_y = s->linesize << fieldtx;
3767                     off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize;
3768                 } else {
3769                     stride_y = s->uvlinesize;
3770                     off = 0;
3771                 }
3772                 s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
3773                 //TODO: loop filter
3774             }
3775
3776         } else { // inter MB
3777             mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3];
3778             if (mb_has_coeffs)
3779                 cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3780             if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) {
3781                 v->twomvbp = get_vlc2(gb, v->twomvbp_vlc->table, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1);
3782             } else {
3783                 if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV)
3784                     || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) {
3785                     v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3786                 }
3787             }
3788             s->mb_intra = v->is_intra[s->mb_x] = 0;
3789             for (i = 0; i < 6; i++)
3790                 v->mb_type[0][s->block_index[i]] = 0;
3791             fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1];
3792             /* for all motion vector read MVDATA and motion compensate each block */
3793             dst_idx = 0;
3794             if (fourmv) {
3795                 mvbp = v->fourmvbp;
3796                 for (i = 0; i < 6; i++) {
3797                     if (i < 4) {
3798                         dmv_x = dmv_y = 0;
3799                         val   = ((mvbp >> (3 - i)) & 1);
3800                         if (val) {
3801                             get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3802                         }
3803                         vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3804                         vc1_mc_4mv_luma(v, i, 0);
3805                     } else if (i == 4) {
3806                         vc1_mc_4mv_chroma4(v);
3807                     }
3808                 }
3809             } else if (twomv) {
3810                 mvbp  = v->twomvbp;
3811                 dmv_x = dmv_y = 0;
3812                 if (mvbp & 2) {
3813                     get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3814                 }
3815                 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3816                 vc1_mc_4mv_luma(v, 0, 0);
3817                 vc1_mc_4mv_luma(v, 1, 0);
3818                 dmv_x = dmv_y = 0;
3819                 if (mvbp & 1) {
3820                     get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3821                 }
3822                 vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, v->mb_type[0]);
3823                 vc1_mc_4mv_luma(v, 2, 0);
3824                 vc1_mc_4mv_luma(v, 3, 0);
3825                 vc1_mc_4mv_chroma4(v);
3826             } else {
3827                 mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
3828                 dmv_x = dmv_y = 0;
3829                 if (mvbp) {
3830                     get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3831                 }
3832                 vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3833                 vc1_mc_1mv(v, 0);
3834             }
3835             if (cbp)
3836                 GET_MQUANT();  // p. 227
3837             s->current_picture.f.qscale_table[mb_pos] = mquant;
3838             if (!v->ttmbf && cbp)
3839                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3840             for (i = 0; i < 6; i++) {
3841                 s->dc_val[0][s->block_index[i]] = 0;
3842                 dst_idx += i >> 2;
3843                 val = ((cbp >> (5 - i)) & 1);
3844                 if (!fieldtx)
3845                     off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3846                 else
3847                     off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize));
3848                 if (val) {
3849                     pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3850                                              first_block, s->dest[dst_idx] + off,
3851                                              (i & 4) ? s->uvlinesize : (s->linesize << fieldtx),
3852                                              (i & 4) && (s->flags & CODEC_FLAG_GRAY), &block_tt);
3853                     block_cbp |= pat << (i << 2);
3854                     if (!v->ttmbf && ttmb < 8)
3855                         ttmb = -1;
3856                     first_block = 0;
3857                 }
3858             }
3859         }
3860     } else { // skipped
3861         s->mb_intra = v->is_intra[s->mb_x] = 0;
3862         for (i = 0; i < 6; i++) {
3863             v->mb_type[0][s->block_index[i]] = 0;
3864             s->dc_val[0][s->block_index[i]] = 0;
3865         }
3866         s->current_picture.f.mb_type[mb_pos]      = MB_TYPE_SKIP;
3867         s->current_picture.f.qscale_table[mb_pos] = 0;
3868         v->blk_mv_type[s->block_index[0]] = 0;
3869         v->blk_mv_type[s->block_index[1]] = 0;
3870         v->blk_mv_type[s->block_index[2]] = 0;
3871         v->blk_mv_type[s->block_index[3]] = 0;
3872         vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3873         vc1_mc_1mv(v, 0);
3874     }
3875     if (s->mb_x == s->mb_width - 1)
3876         memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0])*s->mb_stride);
3877     return 0;
3878 }
3879
3880 static int vc1_decode_p_mb_intfi(VC1Context *v)
3881 {
3882     MpegEncContext *s = &v->s;
3883     GetBitContext *gb = &s->gb;
3884     int i;
3885     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3886     int cbp = 0; /* cbp decoding stuff */
3887     int mqdiff, mquant; /* MB quantization */
3888     int ttmb = v->ttfrm; /* MB Transform type */
3889
3890     int mb_has_coeffs = 1; /* last_flag */
3891     int dmv_x, dmv_y; /* Differential MV components */
3892     int val; /* temp values */
3893     int first_block = 1;
3894     int dst_idx, off;
3895     int pred_flag;
3896     int block_cbp = 0, pat, block_tt = 0;
3897     int idx_mbmode = 0;
3898
3899     mquant = v->pq; /* Loosy initialization */
3900
3901     idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
3902     if (idx_mbmode <= 1) { // intra MB
3903         s->mb_intra = v->is_intra[s->mb_x] = 1;
3904         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
3905         s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
3906         s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA;
3907         GET_MQUANT();
3908         s->current_picture.f.qscale_table[mb_pos] = mquant;
3909         /* Set DC scale - y and c use the same (not sure if necessary here) */
3910         s->y_dc_scale = s->y_dc_scale_table[mquant];
3911         s->c_dc_scale = s->c_dc_scale_table[mquant];
3912         v->s.ac_pred  = v->acpred_plane[mb_pos] = get_bits1(gb);
3913         mb_has_coeffs = idx_mbmode & 1;
3914         if (mb_has_coeffs)
3915             cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
3916         dst_idx = 0;
3917         for (i = 0; i < 6; i++) {
3918             s->dc_val[0][s->block_index[i]]  = 0;
3919             v->mb_type[0][s->block_index[i]] = 1;
3920             dst_idx += i >> 2;
3921             val = ((cbp >> (5 - i)) & 1);
3922             v->a_avail = v->c_avail = 0;
3923             if (i == 2 || i == 3 || !s->first_slice_line)
3924                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3925             if (i == 1 || i == 3 || s->mb_x)
3926                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3927
3928             vc1_decode_intra_block(v, s->block[i], i, val, mquant,
3929                                    (i & 4) ? v->codingset2 : v->codingset);
3930             if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
3931                 continue;
3932             v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
3933             off  = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3934             off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
3935             s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
3936             // TODO: loop filter
3937         }
3938     } else {
3939         s->mb_intra = v->is_intra[s->mb_x] = 0;
3940         s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3941         for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3942         if (idx_mbmode <= 5) { // 1-MV
3943             dmv_x = dmv_y = pred_flag = 0;
3944             if (idx_mbmode & 1) {
3945                 get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3946             }
3947             vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3948             vc1_mc_1mv(v, 0);
3949             mb_has_coeffs = !(idx_mbmode & 2);
3950         } else { // 4-MV
3951             v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
3952             for (i = 0; i < 6; i++) {
3953                 if (i < 4) {
3954                     dmv_x = dmv_y = pred_flag = 0;
3955                     val   = ((v->fourmvbp >> (3 - i)) & 1);
3956                     if (val) {
3957                         get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3958                     }
3959                     vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0], pred_flag, 0);
3960                     vc1_mc_4mv_luma(v, i, 0);
3961                 } else if (i == 4)
3962                     vc1_mc_4mv_chroma(v, 0);
3963             }
3964             mb_has_coeffs = idx_mbmode & 1;
3965         }
3966         if (mb_has_coeffs)
3967             cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3968         if (cbp) {
3969             GET_MQUANT();
3970         }
3971         s->current_picture.f.qscale_table[mb_pos] = mquant;
3972         if (!v->ttmbf && cbp) {
3973             ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3974         }
3975         dst_idx = 0;
3976         for (i = 0; i < 6; i++) {
3977             s->dc_val[0][s->block_index[i]] = 0;
3978             dst_idx += i >> 2;
3979             val = ((cbp >> (5 - i)) & 1);
3980             off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
3981             if (v->cur_field_type)
3982                 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
3983             if (val) {
3984                 pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
3985                                          first_block, s->dest[dst_idx] + off,
3986                                          (i & 4) ? s->uvlinesize : s->linesize,
3987                                          (i & 4) && (s->flags & CODEC_FLAG_GRAY),
3988                                          &block_tt);
3989                 block_cbp |= pat << (i << 2);
3990                 if (!v->ttmbf && ttmb < 8) ttmb = -1;
3991                 first_block = 0;
3992             }
3993         }
3994     }
3995     if (s->mb_x == s->mb_width - 1)
3996         memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
3997     return 0;
3998 }
3999
4000 /** Decode one B-frame MB (in Main profile)
4001  */
4002 static void vc1_decode_b_mb(VC1Context *v)
4003 {
4004     MpegEncContext *s = &v->s;
4005     GetBitContext *gb = &s->gb;
4006     int i, j;
4007     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4008     int cbp = 0; /* cbp decoding stuff */
4009     int mqdiff, mquant; /* MB quantization */
4010     int ttmb = v->ttfrm; /* MB Transform type */
4011     int mb_has_coeffs = 0; /* last_flag */
4012     int index, index1; /* LUT indexes */
4013     int val, sign; /* temp values */
4014     int first_block = 1;
4015     int dst_idx, off;
4016     int skipped, direct;
4017     int dmv_x[2], dmv_y[2];
4018     int bmvtype = BMV_TYPE_BACKWARD;
4019
4020     mquant      = v->pq; /* lossy initialization */
4021     s->mb_intra = 0;
4022
4023     if (v->dmb_is_raw)
4024         direct = get_bits1(gb);
4025     else
4026         direct = v->direct_mb_plane[mb_pos];
4027     if (v->skip_is_raw)
4028         skipped = get_bits1(gb);
4029     else
4030         skipped = v->s.mbskip_table[mb_pos];
4031
4032     dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4033     for (i = 0; i < 6; i++) {
4034         v->mb_type[0][s->block_index[i]] = 0;
4035         s->dc_val[0][s->block_index[i]]  = 0;
4036     }
4037     s->current_picture.f.qscale_table[mb_pos] = 0;
4038
4039     if (!direct) {
4040         if (!skipped) {
4041             GET_MVDATA(dmv_x[0], dmv_y[0]);
4042             dmv_x[1] = dmv_x[0];
4043             dmv_y[1] = dmv_y[0];
4044         }
4045         if (skipped || !s->mb_intra) {
4046             bmvtype = decode012(gb);
4047             switch (bmvtype) {
4048             case 0:
4049                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
4050                 break;
4051             case 1:
4052                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
4053                 break;
4054             case 2:
4055                 bmvtype  = BMV_TYPE_INTERPOLATED;
4056                 dmv_x[0] = dmv_y[0] = 0;
4057             }
4058         }
4059     }
4060     for (i = 0; i < 6; i++)
4061         v->mb_type[0][s->block_index[i]] = s->mb_intra;
4062
4063     if (skipped) {
4064         if (direct)
4065             bmvtype = BMV_TYPE_INTERPOLATED;
4066         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4067         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4068         return;
4069     }
4070     if (direct) {
4071         cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4072         GET_MQUANT();
4073         s->mb_intra = 0;
4074         s->current_picture.f.qscale_table[mb_pos] = mquant;
4075         if (!v->ttmbf)
4076             ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4077         dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
4078         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4079         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4080     } else {
4081         if (!mb_has_coeffs && !s->mb_intra) {
4082             /* no coded blocks - effectively skipped */
4083             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4084             vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4085             return;
4086         }
4087         if (s->mb_intra && !mb_has_coeffs) {
4088             GET_MQUANT();
4089             s->current_picture.f.qscale_table[mb_pos] = mquant;
4090             s->ac_pred = get_bits1(gb);
4091             cbp = 0;
4092             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4093         } else {
4094             if (bmvtype == BMV_TYPE_INTERPOLATED) {
4095                 GET_MVDATA(dmv_x[0], dmv_y[0]);
4096                 if (!mb_has_coeffs) {
4097                     /* interpolated skipped block */
4098                     vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4099                     vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4100                     return;
4101                 }
4102             }
4103             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
4104             if (!s->mb_intra) {
4105                 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
4106             }
4107             if (s->mb_intra)
4108                 s->ac_pred = get_bits1(gb);
4109             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4110             GET_MQUANT();
4111             s->current_picture.f.qscale_table[mb_pos] = mquant;
4112             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
4113                 ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4114         }
4115     }
4116     dst_idx = 0;
4117     for (i = 0; i < 6; i++) {
4118         s->dc_val[0][s->block_index[i]] = 0;
4119         dst_idx += i >> 2;
4120         val = ((cbp >> (5 - i)) & 1);
4121         off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4122         v->mb_type[0][s->block_index[i]] = s->mb_intra;
4123         if (s->mb_intra) {
4124             /* check if prediction blocks A and C are available */
4125             v->a_avail = v->c_avail = 0;
4126             if (i == 2 || i == 3 || !s->first_slice_line)
4127                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4128             if (i == 1 || i == 3 || s->mb_x)
4129                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4130
4131             vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4132                                    (i & 4) ? v->codingset2 : v->codingset);
4133             if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4134                 continue;
4135             v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4136             if (v->rangeredfrm)
4137                 for (j = 0; j < 64; j++)
4138                     s->block[i][j] <<= 1;
4139             s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
4140         } else if (val) {
4141             vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4142                                first_block, s->dest[dst_idx] + off,
4143                                (i & 4) ? s->uvlinesize : s->linesize,
4144                                (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4145             if (!v->ttmbf && ttmb < 8)
4146                 ttmb = -1;
4147             first_block = 0;
4148         }
4149     }
4150 }
4151
4152 /** Decode one B-frame MB (in interlaced field B picture)
4153  */
4154 static void vc1_decode_b_mb_intfi(VC1Context *v)
4155 {
4156     MpegEncContext *s = &v->s;
4157     GetBitContext *gb = &s->gb;
4158     int i, j;
4159     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4160     int cbp = 0; /* cbp decoding stuff */
4161     int mqdiff, mquant; /* MB quantization */
4162     int ttmb = v->ttfrm; /* MB Transform type */
4163     int mb_has_coeffs = 0; /* last_flag */
4164     int val; /* temp value */
4165     int first_block = 1;
4166     int dst_idx, off;
4167     int fwd;
4168     int dmv_x[2], dmv_y[2], pred_flag[2];
4169     int bmvtype = BMV_TYPE_BACKWARD;
4170     int idx_mbmode, interpmvp;
4171
4172     mquant      = v->pq; /* Loosy initialization */
4173     s->mb_intra = 0;
4174
4175     idx_mbmode = get_vlc2(gb, v->mbmode_vlc->table, VC1_IF_MBMODE_VLC_BITS, 2);
4176     if (idx_mbmode <= 1) { // intra MB
4177         s->mb_intra = v->is_intra[s->mb_x] = 1;
4178         s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4179         s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4180         s->current_picture.f.mb_type[mb_pos + v->mb_off]         = MB_TYPE_INTRA;
4181         GET_MQUANT();
4182         s->current_picture.f.qscale_table[mb_pos] = mquant;
4183         /* Set DC scale - y and c use the same (not sure if necessary here) */
4184         s->y_dc_scale = s->y_dc_scale_table[mquant];
4185         s->c_dc_scale = s->c_dc_scale_table[mquant];
4186         v->s.ac_pred  = v->acpred_plane[mb_pos] = get_bits1(gb);
4187         mb_has_coeffs = idx_mbmode & 1;
4188         if (mb_has_coeffs)
4189             cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_ICBPCY_VLC_BITS, 2);
4190         dst_idx = 0;
4191         for (i = 0; i < 6; i++) {
4192             s->dc_val[0][s->block_index[i]] = 0;
4193             dst_idx += i >> 2;
4194             val = ((cbp >> (5 - i)) & 1);
4195             v->mb_type[0][s->block_index[i]] = s->mb_intra;
4196             v->a_avail                       = v->c_avail = 0;
4197             if (i == 2 || i == 3 || !s->first_slice_line)
4198                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
4199             if (i == 1 || i == 3 || s->mb_x)
4200                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
4201
4202             vc1_decode_intra_block(v, s->block[i], i, val, mquant,
4203                                    (i & 4) ? v->codingset2 : v->codingset);
4204             if ((i>3) && (s->flags & CODEC_FLAG_GRAY))
4205                 continue;
4206             v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
4207             if (v->rangeredfrm)
4208                 for (j = 0; j < 64; j++)
4209                     s->block[i][j] <<= 1;
4210             off  = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
4211             off += v->cur_field_type ? ((i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0]) : 0;
4212             s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
4213             // TODO: yet to perform loop filter
4214         }
4215     } else {
4216         s->mb_intra = v->is_intra[s->mb_x] = 0;
4217         s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
4218         for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
4219         if (v->fmb_is_raw)
4220             fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb);
4221         else
4222             fwd = v->forward_mb_plane[mb_pos];
4223         if (idx_mbmode <= 5) { // 1-MV
4224             dmv_x[0]     = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
4225             pred_flag[0] = pred_flag[1] = 0;
4226             if (fwd)
4227                 bmvtype = BMV_TYPE_FORWARD;
4228             else {
4229                 bmvtype = decode012(gb);
4230                 switch (bmvtype) {
4231                 case 0:
4232                     bmvtype = BMV_TYPE_BACKWARD;
4233                     break;
4234                 case 1:
4235                     bmvtype = BMV_TYPE_DIRECT;
4236                     break;
4237                 case 2:
4238                     bmvtype   = BMV_TYPE_INTERPOLATED;
4239                     interpmvp = get_bits1(gb);
4240                 }
4241             }
4242             v->bmvtype = bmvtype;
4243             if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) {
4244                 get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4245             }
4246             if (bmvtype == BMV_TYPE_INTERPOLATED && interpmvp) {
4247                 get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]);
4248             }
4249             if (bmvtype == BMV_TYPE_DIRECT) {
4250                 dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4251                 dmv_x[1] = dmv_y[1] = pred_flag[0] = 0;
4252             }
4253             vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag);
4254             vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype);
4255             mb_has_coeffs = !(idx_mbmode & 2);
4256         } else { // 4-MV
4257             if (fwd)
4258                 bmvtype = BMV_TYPE_FORWARD;
4259             v->bmvtype  = bmvtype;
4260             v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc->table, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1);
4261             for (i = 0; i < 6; i++) {
4262                 if (i < 4) {
4263                     dmv_x[0] = dmv_y[0] = pred_flag[0] = 0;
4264                     dmv_x[1] = dmv_y[1] = pred_flag[1] = 0;
4265                     val = ((v->fourmvbp >> (3 - i)) & 1);
4266                     if (val) {
4267                         get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD],
4268                                                  &dmv_y[bmvtype == BMV_TYPE_BACKWARD],
4269                                              &pred_flag[bmvtype == BMV_TYPE_BACKWARD]);
4270                     }
4271                     vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag);
4272                     vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD);
4273                 } else if (i == 4)
4274                     vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD);
4275             }
4276             mb_has_coeffs = idx_mbmode & 1;
4277         }
4278         if (mb_has_coeffs)
4279             cbp = 1 + get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
4280         if (cbp) {
4281             GET_MQUANT();
4282         }
4283         s->current_picture.f.qscale_table[mb_pos] = mquant;
4284         if (!v->ttmbf && cbp) {
4285             ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
4286         }
4287         dst_idx = 0;
4288         for (i = 0; i < 6; i++) {
4289             s->dc_val[0][s->block_index[i]] = 0;
4290             dst_idx += i >> 2;
4291             val = ((cbp >> (5 - i)) & 1);
4292             off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize;
4293             if (v->cur_field_type)
4294                 off += (i & 4) ? s->current_picture_ptr->f.linesize[1] : s->current_picture_ptr->f.linesize[0];
4295             if (val) {
4296                 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
4297                                    first_block, s->dest[dst_idx] + off,
4298                                    (i & 4) ? s->uvlinesize : s->linesize,
4299                                    (i & 4) && (s->flags & CODEC_FLAG_GRAY), NULL);
4300                 if (!v->ttmbf && ttmb < 8)
4301                     ttmb = -1;
4302                 first_block = 0;
4303             }
4304         }
4305     }
4306 }
4307
4308 /** Decode blocks of I-frame
4309  */
4310 static void vc1_decode_i_blocks(VC1Context *v)
4311 {
4312     int k, j;
4313     MpegEncContext *s = &v->s;
4314     int cbp, val;
4315     uint8_t *coded_val;
4316     int mb_pos;
4317
4318     /* select codingmode used for VLC tables selection */
4319     switch (v->y_ac_table_index) {
4320     case 0:
4321         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4322         break;
4323     case 1:
4324         v->codingset = CS_HIGH_MOT_INTRA;
4325         break;
4326     case 2:
4327         v->codingset = CS_MID_RATE_INTRA;
4328         break;
4329     }
4330
4331     switch (v->c_ac_table_index) {
4332     case 0:
4333         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4334         break;
4335     case 1:
4336         v->codingset2 = CS_HIGH_MOT_INTER;
4337         break;
4338     case 2:
4339         v->codingset2 = CS_MID_RATE_INTER;
4340         break;
4341     }
4342
4343     /* Set DC scale - y and c use the same */
4344     s->y_dc_scale = s->y_dc_scale_table[v->pq];
4345     s->c_dc_scale = s->c_dc_scale_table[v->pq];
4346
4347     //do frame decode
4348     s->mb_x = s->mb_y = 0;
4349     s->mb_intra         = 1;
4350     s->first_slice_line = 1;
4351     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4352         s->mb_x = 0;
4353         ff_init_block_index(s);
4354         for (; s->mb_x < s->mb_width; s->mb_x++) {
4355             uint8_t *dst[6];
4356             ff_update_block_index(s);
4357             dst[0] = s->dest[0];
4358             dst[1] = dst[0] + 8;
4359             dst[2] = s->dest[0] + s->linesize * 8;
4360             dst[3] = dst[2] + 8;
4361             dst[4] = s->dest[1];
4362             dst[5] = s->dest[2];
4363             s->dsp.clear_blocks(s->block[0]);
4364             mb_pos = s->mb_x + s->mb_y * s->mb_width;
4365             s->current_picture.f.mb_type[mb_pos]                     = MB_TYPE_INTRA;
4366             s->current_picture.f.qscale_table[mb_pos]                = v->pq;
4367             s->current_picture.f.motion_val[1][s->block_index[0]][0] = 0;
4368             s->current_picture.f.motion_val[1][s->block_index[0]][1] = 0;
4369
4370             // do actual MB decoding and displaying
4371             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4372             v->s.ac_pred = get_bits1(&v->s.gb);
4373
4374             for (k = 0; k < 6; k++) {
4375                 val = ((cbp >> (5 - k)) & 1);
4376
4377                 if (k < 4) {
4378                     int pred   = vc1_coded_block_pred(&v->s, k, &coded_val);
4379                     val        = val ^ pred;
4380                     *coded_val = val;
4381                 }
4382                 cbp |= val << (5 - k);
4383
4384                 vc1_decode_i_block(v, s->block[k], k, val, (k < 4) ? v->codingset : v->codingset2);
4385
4386                 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4387                     continue;
4388                 v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
4389                 if (v->pq >= 9 && v->overlap) {
4390                     if (v->rangeredfrm)
4391                         for (j = 0; j < 64; j++)
4392                             s->block[k][j] <<= 1;
4393                     s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4394                 } else {
4395                     if (v->rangeredfrm)
4396                         for (j = 0; j < 64; j++)
4397                             s->block[k][j] = (s->block[k][j] - 64) << 1;
4398                     s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
4399                 }
4400             }
4401
4402             if (v->pq >= 9 && v->overlap) {
4403                 if (s->mb_x) {
4404                     v->vc1dsp.vc1_h_overlap(s->dest[0], s->linesize);
4405                     v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4406                     if (!(s->flags & CODEC_FLAG_GRAY)) {
4407                         v->vc1dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4408                         v->vc1dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4409                     }
4410                 }
4411                 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4412                 v->vc1dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4413                 if (!s->first_slice_line) {
4414                     v->vc1dsp.vc1_v_overlap(s->dest[0], s->linesize);
4415                     v->vc1dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4416                     if (!(s->flags & CODEC_FLAG_GRAY)) {
4417                         v->vc1dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4418                         v->vc1dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4419                     }
4420                 }
4421                 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4422                 v->vc1dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4423             }
4424             if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4425
4426             if (get_bits_count(&s->gb) > v->bits) {
4427                 ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR);
4428                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4429                        get_bits_count(&s->gb), v->bits);
4430                 return;
4431             }
4432         }
4433         if (!v->s.loop_filter)
4434             ff_draw_horiz_band(s, s->mb_y * 16, 16);
4435         else if (s->mb_y)
4436             ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4437
4438         s->first_slice_line = 0;
4439     }
4440     if (v->s.loop_filter)
4441         ff_draw_horiz_band(s, (s->mb_height - 1) * 16, 16);
4442     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4443 }
4444
4445 /** Decode blocks of I-frame for advanced profile
4446  */
4447 static void vc1_decode_i_blocks_adv(VC1Context *v)
4448 {
4449     int k;
4450     MpegEncContext *s = &v->s;
4451     int cbp, val;
4452     uint8_t *coded_val;
4453     int mb_pos;
4454     int mquant = v->pq;
4455     int mqdiff;
4456     GetBitContext *gb = &s->gb;
4457
4458     /* select codingmode used for VLC tables selection */
4459     switch (v->y_ac_table_index) {
4460     case 0:
4461         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4462         break;
4463     case 1:
4464         v->codingset = CS_HIGH_MOT_INTRA;
4465         break;
4466     case 2:
4467         v->codingset = CS_MID_RATE_INTRA;
4468         break;
4469     }
4470
4471     switch (v->c_ac_table_index) {
4472     case 0:
4473         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4474         break;
4475     case 1:
4476         v->codingset2 = CS_HIGH_MOT_INTER;
4477         break;
4478     case 2:
4479         v->codingset2 = CS_MID_RATE_INTER;
4480         break;
4481     }
4482
4483     // do frame decode
4484     s->mb_x             = s->mb_y = 0;
4485     s->mb_intra         = 1;
4486     s->first_slice_line = 1;
4487     s->mb_y             = s->start_mb_y;
4488     if (s->start_mb_y) {
4489         s->mb_x = 0;
4490         ff_init_block_index(s);
4491         memset(&s->coded_block[s->block_index[0] - s->b8_stride], 0,
4492                (1 + s->b8_stride) * sizeof(*s->coded_block));
4493     }
4494     for (; s->mb_y < s->end_mb_y; s->mb_y++) {
4495         s->mb_x = 0;
4496         ff_init_block_index(s);
4497         for (;s->mb_x < s->mb_width; s->mb_x++) {
4498             DCTELEM (*block)[64] = v->block[v->cur_blk_idx];
4499             ff_update_block_index(s);
4500             s->dsp.clear_blocks(block[0]);
4501             mb_pos = s->mb_x + s->mb_y * s->mb_stride;
4502             s->current_picture.f.mb_type[mb_pos + v->mb_off]                         = MB_TYPE_INTRA;
4503             s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
4504             s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
4505
4506             // do actual MB decoding and displaying
4507             if (v->fieldtx_is_raw)
4508                 v->fieldtx_plane[mb_pos] = get_bits1(&v->s.gb);
4509             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
4510             if ( v->acpred_is_raw)
4511                 v->s.ac_pred = get_bits1(&v->s.gb);
4512             else
4513                 v->s.ac_pred = v->acpred_plane[mb_pos];
4514
4515             if (v->condover == CONDOVER_SELECT && v->overflg_is_raw)
4516                 v->over_flags_plane[mb_pos] = get_bits1(&v->s.gb);
4517
4518             GET_MQUANT();
4519
4520             s->current_picture.f.qscale_table[mb_pos] = mquant;
4521             /* Set DC scale - y and c use the same */
4522             s->y_dc_scale = s->y_dc_scale_table[mquant];
4523             s->c_dc_scale = s->c_dc_scale_table[mquant];
4524
4525             for (k = 0; k < 6; k++) {
4526                 val = ((cbp >> (5 - k)) & 1);
4527
4528                 if (k < 4) {
4529                     int pred   = vc1_coded_block_pred(&v->s, k, &coded_val);
4530                     val        = val ^ pred;
4531                     *coded_val = val;
4532                 }
4533                 cbp |= val << (5 - k);
4534
4535                 v->a_avail = !s->first_slice_line || (k == 2 || k == 3);
4536                 v->c_avail = !!s->mb_x || (k == 1 || k == 3);
4537
4538                 vc1_decode_i_block_adv(v, block[k], k, val,
4539                                        (k < 4) ? v->codingset : v->codingset2, mquant);
4540
4541                 if (k > 3 && (s->flags & CODEC_FLAG_GRAY))
4542                     continue;
4543                 v->vc1dsp.vc1_inv_trans_8x8(block[k]);
4544             }
4545
4546             vc1_smooth_overlap_filter_iblk(v);
4547             vc1_put_signed_blocks_clamped(v);
4548             if (v->s.loop_filter) vc1_loop_filter_iblk_delayed(v, v->pq);
4549
4550             if (get_bits_count(&s->gb) > v->bits) {
4551                 // TODO: may need modification to handle slice coding
4552                 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4553                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n",
4554                        get_bits_count(&s->gb), v->bits);
4555                 return;
4556             }
4557         }
4558         if (!v->s.loop_filter)
4559             ff_draw_horiz_band(s, s->mb_y * 16, 16);
4560         else if (s->mb_y)
4561             ff_draw_horiz_band(s, (s->mb_y-1) * 16, 16);
4562         s->first_slice_line = 0;
4563     }
4564
4565     /* raw bottom MB row */
4566     s->mb_x = 0;
4567     ff_init_block_index(s);
4568     for (;s->mb_x < s->mb_width; s->mb_x++) {
4569         ff_update_block_index(s);
4570         vc1_put_signed_blocks_clamped(v);
4571         if (v->s.loop_filter)
4572             vc1_loop_filter_iblk_delayed(v, v->pq);
4573     }
4574     if (v->s.loop_filter)
4575         ff_draw_horiz_band(s, (s->end_mb_y-1)*16, 16);
4576     ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4577                     (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4578 }
4579
4580 static void vc1_decode_p_blocks(VC1Context *v)
4581 {
4582     MpegEncContext *s = &v->s;
4583     int apply_loop_filter;
4584
4585     /* select codingmode used for VLC tables selection */
4586     switch (v->c_ac_table_index) {
4587     case 0:
4588         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4589         break;
4590     case 1:
4591         v->codingset = CS_HIGH_MOT_INTRA;
4592         break;
4593     case 2:
4594         v->codingset = CS_MID_RATE_INTRA;
4595         break;
4596     }
4597
4598     switch (v->c_ac_table_index) {
4599     case 0:
4600         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4601         break;
4602     case 1:
4603         v->codingset2 = CS_HIGH_MOT_INTER;
4604         break;
4605     case 2:
4606         v->codingset2 = CS_MID_RATE_INTER;
4607         break;
4608     }
4609
4610     apply_loop_filter   = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
4611     s->first_slice_line = 1;
4612     memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
4613     for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4614         s->mb_x = 0;
4615         ff_init_block_index(s);
4616         for (; s->mb_x < s->mb_width; s->mb_x++) {
4617             ff_update_block_index(s);
4618
4619             if (v->fcm == ILACE_FIELD)
4620                 vc1_decode_p_mb_intfi(v);
4621             else if (v->fcm == ILACE_FRAME)
4622                 vc1_decode_p_mb_intfr(v);
4623             else vc1_decode_p_mb(v);
4624             if (s->mb_y != s->start_mb_y && apply_loop_filter && v->fcm == PROGRESSIVE)
4625                 vc1_apply_p_loop_filter(v);
4626             if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4627                 // TODO: may need modification to handle slice coding
4628                 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4629                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4630                        get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4631                 return;
4632             }
4633         }
4634         memmove(v->cbp_base,      v->cbp,      sizeof(v->cbp_base[0])      * s->mb_stride);
4635         memmove(v->ttblk_base,    v->ttblk,    sizeof(v->ttblk_base[0])    * s->mb_stride);
4636         memmove(v->is_intra_base, v->is_intra, sizeof(v->is_intra_base[0]) * s->mb_stride);
4637         memmove(v->luma_mv_base,  v->luma_mv,  sizeof(v->luma_mv_base[0])  * s->mb_stride);
4638         if (s->mb_y != s->start_mb_y) ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4639         s->first_slice_line = 0;
4640     }
4641     if (apply_loop_filter) {
4642         s->mb_x = 0;
4643         ff_init_block_index(s);
4644         for (; s->mb_x < s->mb_width; s->mb_x++) {
4645             ff_update_block_index(s);
4646             vc1_apply_p_loop_filter(v);
4647         }
4648     }
4649     if (s->end_mb_y >= s->start_mb_y)
4650         ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4651     ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4652                     (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4653 }
4654
4655 static void vc1_decode_b_blocks(VC1Context *v)
4656 {
4657     MpegEncContext *s = &v->s;
4658
4659     /* select codingmode used for VLC tables selection */
4660     switch (v->c_ac_table_index) {
4661     case 0:
4662         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4663         break;
4664     case 1:
4665         v->codingset = CS_HIGH_MOT_INTRA;
4666         break;
4667     case 2:
4668         v->codingset = CS_MID_RATE_INTRA;
4669         break;
4670     }
4671
4672     switch (v->c_ac_table_index) {
4673     case 0:
4674         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4675         break;
4676     case 1:
4677         v->codingset2 = CS_HIGH_MOT_INTER;
4678         break;
4679     case 2:
4680         v->codingset2 = CS_MID_RATE_INTER;
4681         break;
4682     }
4683
4684     s->first_slice_line = 1;
4685     for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4686         s->mb_x = 0;
4687         ff_init_block_index(s);
4688         for (; s->mb_x < s->mb_width; s->mb_x++) {
4689             ff_update_block_index(s);
4690
4691             if (v->fcm == ILACE_FIELD)
4692                 vc1_decode_b_mb_intfi(v);
4693             else
4694                 vc1_decode_b_mb(v);
4695             if (get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4696                 // TODO: may need modification to handle slice coding
4697                 ff_er_add_slice(s, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR);
4698                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n",
4699                        get_bits_count(&s->gb), v->bits, s->mb_x, s->mb_y);
4700                 return;
4701             }
4702             if (v->s.loop_filter) vc1_loop_filter_iblk(v, v->pq);
4703         }
4704         if (!v->s.loop_filter)
4705             ff_draw_horiz_band(s, s->mb_y * 16, 16);
4706         else if (s->mb_y)
4707             ff_draw_horiz_band(s, (s->mb_y - 1) * 16, 16);
4708         s->first_slice_line = 0;
4709     }
4710     if (v->s.loop_filter)
4711         ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
4712     ff_er_add_slice(s, 0, s->start_mb_y << v->field_mode, s->mb_width - 1,
4713                     (s->end_mb_y << v->field_mode) - 1, ER_MB_END);
4714 }
4715
4716 static void vc1_decode_skip_blocks(VC1Context *v)
4717 {
4718     MpegEncContext *s = &v->s;
4719
4720     ff_er_add_slice(s, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END);
4721     s->first_slice_line = 1;
4722     for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4723         s->mb_x = 0;
4724         ff_init_block_index(s);
4725         ff_update_block_index(s);
4726         memcpy(s->dest[0], s->last_picture.f.data[0] + s->mb_y * 16 * s->linesize,   s->linesize   * 16);
4727         memcpy(s->dest[1], s->last_picture.f.data[1] + s->mb_y *  8 * s->uvlinesize, s->uvlinesize *  8);
4728         memcpy(s->dest[2], s->last_picture.f.data[2] + s->mb_y *  8 * s->uvlinesize, s->uvlinesize *  8);
4729         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4730         s->first_slice_line = 0;
4731     }
4732     s->pict_type = AV_PICTURE_TYPE_P;
4733 }
4734
4735 static void vc1_decode_blocks(VC1Context *v)
4736 {
4737
4738     v->s.esc3_level_length = 0;
4739     if (v->x8_type) {
4740         ff_intrax8_decode_picture(&v->x8, 2*v->pq + v->halfpq, v->pq * !v->pquantizer);
4741     } else {
4742         v->cur_blk_idx     =  0;
4743         v->left_blk_idx    = -1;
4744         v->topleft_blk_idx =  1;
4745         v->top_blk_idx     =  2;
4746         switch (v->s.pict_type) {
4747         case AV_PICTURE_TYPE_I:
4748             if (v->profile == PROFILE_ADVANCED)
4749                 vc1_decode_i_blocks_adv(v);
4750             else
4751                 vc1_decode_i_blocks(v);
4752             break;
4753         case AV_PICTURE_TYPE_P:
4754             if (v->p_frame_skipped)
4755                 vc1_decode_skip_blocks(v);
4756             else
4757                 vc1_decode_p_blocks(v);
4758             break;
4759         case AV_PICTURE_TYPE_B:
4760             if (v->bi_type) {
4761                 if (v->profile == PROFILE_ADVANCED)
4762                     vc1_decode_i_blocks_adv(v);
4763                 else
4764                     vc1_decode_i_blocks(v);
4765             } else
4766                 vc1_decode_b_blocks(v);
4767             break;
4768         }
4769     }
4770 }
4771
4772 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
4773
4774 typedef struct {
4775     /**
4776      * Transform coefficients for both sprites in 16.16 fixed point format,
4777      * in the order they appear in the bitstream:
4778      *  x scale
4779      *  rotation 1 (unused)
4780      *  x offset
4781      *  rotation 2 (unused)
4782      *  y scale
4783      *  y offset
4784      *  alpha
4785      */
4786     int coefs[2][7];
4787
4788     int effect_type, effect_flag;
4789     int effect_pcount1, effect_pcount2;   ///< amount of effect parameters stored in effect_params
4790     int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
4791 } SpriteData;
4792
4793 static inline int get_fp_val(GetBitContext* gb)
4794 {
4795     return (get_bits_long(gb, 30) - (1 << 29)) << 1;
4796 }
4797
4798 static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
4799 {
4800     c[1] = c[3] = 0;
4801
4802     switch (get_bits(gb, 2)) {
4803     case 0:
4804         c[0] = 1 << 16;
4805         c[2] = get_fp_val(gb);
4806         c[4] = 1 << 16;
4807         break;
4808     case 1:
4809         c[0] = c[4] = get_fp_val(gb);
4810         c[2] = get_fp_val(gb);
4811         break;
4812     case 2:
4813         c[0] = get_fp_val(gb);
4814         c[2] = get_fp_val(gb);
4815         c[4] = get_fp_val(gb);
4816         break;
4817     case 3:
4818         c[0] = get_fp_val(gb);
4819         c[1] = get_fp_val(gb);
4820         c[2] = get_fp_val(gb);
4821         c[3] = get_fp_val(gb);
4822         c[4] = get_fp_val(gb);
4823         break;
4824     }
4825     c[5] = get_fp_val(gb);
4826     if (get_bits1(gb))
4827         c[6] = get_fp_val(gb);
4828     else
4829         c[6] = 1 << 16;
4830 }
4831
4832 static void vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
4833 {
4834     AVCodecContext *avctx = v->s.avctx;
4835     int sprite, i;
4836
4837     for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4838         vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
4839         if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
4840             av_log_ask_for_sample(avctx, "Rotation coefficients are not zero");
4841         av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
4842         for (i = 0; i < 7; i++)
4843             av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
4844                    sd->coefs[sprite][i] / (1<<16),
4845                    (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
4846         av_log(avctx, AV_LOG_DEBUG, "\n");
4847     }
4848
4849     skip_bits(gb, 2);
4850     if (sd->effect_type = get_bits_long(gb, 30)) {
4851         switch (sd->effect_pcount1 = get_bits(gb, 4)) {
4852         case 7:
4853             vc1_sprite_parse_transform(gb, sd->effect_params1);
4854             break;
4855         case 14:
4856             vc1_sprite_parse_transform(gb, sd->effect_params1);
4857             vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
4858             break;
4859         default:
4860             for (i = 0; i < sd->effect_pcount1; i++)
4861                 sd->effect_params1[i] = get_fp_val(gb);
4862         }
4863         if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
4864             // effect 13 is simple alpha blending and matches the opacity above
4865             av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
4866             for (i = 0; i < sd->effect_pcount1; i++)
4867                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4868                        sd->effect_params1[i] / (1 << 16),
4869                        (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
4870             av_log(avctx, AV_LOG_DEBUG, "\n");
4871         }
4872
4873         sd->effect_pcount2 = get_bits(gb, 16);
4874         if (sd->effect_pcount2 > 10) {
4875             av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
4876             return;
4877         } else if (sd->effect_pcount2) {
4878             i = -1;
4879             av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
4880             while (++i < sd->effect_pcount2) {
4881                 sd->effect_params2[i] = get_fp_val(gb);
4882                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
4883                        sd->effect_params2[i] / (1 << 16),
4884                        (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
4885             }
4886             av_log(avctx, AV_LOG_DEBUG, "\n");
4887         }
4888     }
4889     if (sd->effect_flag = get_bits1(gb))
4890         av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4891
4892     if (get_bits_count(gb) >= gb->size_in_bits +
4893        (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
4894         av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4895     if (get_bits_count(gb) < gb->size_in_bits - 8)
4896         av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4897 }
4898
4899 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
4900 {
4901     int i, plane, row, sprite;
4902     int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
4903     uint8_t* src_h[2][2];
4904     int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
4905     int ysub[2];
4906     MpegEncContext *s = &v->s;
4907
4908     for (i = 0; i < 2; i++) {
4909         xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
4910         xadv[i] = sd->coefs[i][0];
4911         if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
4912             xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
4913
4914         yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
4915         yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
4916     }
4917     alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
4918
4919     for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
4920         int width = v->output_width>>!!plane;
4921
4922         for (row = 0; row < v->output_height>>!!plane; row++) {
4923             uint8_t *dst = v->sprite_output_frame.data[plane] +
4924                            v->sprite_output_frame.linesize[plane] * row;
4925
4926             for (sprite = 0; sprite <= v->two_sprites; sprite++) {
4927                 uint8_t *iplane = s->current_picture.f.data[plane];
4928                 int      iline  = s->current_picture.f.linesize[plane];
4929                 int      ycoord = yoff[sprite] + yadv[sprite] * row;
4930                 int      yline  = ycoord >> 16;
4931                 int      next_line;
4932                 ysub[sprite] = ycoord & 0xFFFF;
4933                 if (sprite) {
4934                     iplane = s->last_picture.f.data[plane];
4935                     iline  = s->last_picture.f.linesize[plane];
4936                 }
4937                 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
4938                 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4939                         src_h[sprite][0] = iplane + (xoff[sprite] >> 16) +  yline      * iline;
4940                     if (ysub[sprite])
4941                         src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
4942                 } else {
4943                     if (sr_cache[sprite][0] != yline) {
4944                         if (sr_cache[sprite][1] == yline) {
4945                             FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
4946                             FFSWAP(int,        sr_cache[sprite][0],   sr_cache[sprite][1]);
4947                         } else {
4948                             v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
4949                             sr_cache[sprite][0] = yline;
4950                         }
4951                     }
4952                     if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4953                         v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
4954                                            iplane + next_line, xoff[sprite],
4955                                            xadv[sprite], width);
4956                         sr_cache[sprite][1] = yline + 1;
4957                     }
4958                     src_h[sprite][0] = v->sr_rows[sprite][0];
4959                     src_h[sprite][1] = v->sr_rows[sprite][1];
4960                 }
4961             }
4962
4963             if (!v->two_sprites) {
4964                 if (ysub[0]) {
4965                     v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
4966                 } else {
4967                     memcpy(dst, src_h[0][0], width);
4968                 }
4969             } else {
4970                 if (ysub[0] && ysub[1]) {
4971                     v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
4972                                                        src_h[1][0], src_h[1][1], ysub[1], alpha, width);
4973                 } else if (ysub[0]) {
4974                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
4975                                                        src_h[1][0], alpha, width);
4976                 } else if (ysub[1]) {
4977                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
4978                                                        src_h[0][0], (1<<16)-1-alpha, width);
4979                 } else {
4980                     v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
4981                 }
4982             }
4983         }
4984
4985         if (!plane) {
4986             for (i = 0; i < 2; i++) {
4987                 xoff[i] >>= 1;
4988                 yoff[i] >>= 1;
4989             }
4990         }
4991
4992     }
4993 }
4994
4995
4996 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
4997 {
4998     MpegEncContext *s     = &v->s;
4999     AVCodecContext *avctx = s->avctx;
5000     SpriteData sd;
5001
5002     vc1_parse_sprites(v, gb, &sd);
5003
5004     if (!s->current_picture.f.data[0]) {
5005         av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5006         return -1;
5007     }
5008
5009     if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5010         av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5011         v->two_sprites = 0;
5012     }
5013
5014     if (v->sprite_output_frame.data[0])
5015         avctx->release_buffer(avctx, &v->sprite_output_frame);
5016
5017     v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5018     v->sprite_output_frame.reference = 0;
5019     if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
5020         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5021         return -1;
5022     }
5023
5024     vc1_draw_sprites(v, &sd);
5025
5026     return 0;
5027 }
5028
5029 static void vc1_sprite_flush(AVCodecContext *avctx)
5030 {
5031     VC1Context *v     = avctx->priv_data;
5032     MpegEncContext *s = &v->s;
5033     AVFrame *f = &s->current_picture.f;
5034     int plane, i;
5035
5036     /* Windows Media Image codecs have a convergence interval of two keyframes.
5037        Since we can't enforce it, clear to black the missing sprite. This is
5038        wrong but it looks better than doing nothing. */
5039
5040     if (f->data[0])
5041         for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5042             for (i = 0; i < v->sprite_height>>!!plane; i++)
5043                 memset(f->data[plane] + i * f->linesize[plane],
5044                        plane ? 128 : 0, f->linesize[plane]);
5045 }
5046
5047 #endif
5048
5049 static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
5050 {
5051     MpegEncContext *s = &v->s;
5052     int i;
5053
5054     /* Allocate mb bitplanes */
5055     v->mv_type_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5056     v->direct_mb_plane  = av_malloc (s->mb_stride * s->mb_height);
5057     v->forward_mb_plane = av_malloc (s->mb_stride * s->mb_height);
5058     v->fieldtx_plane    = av_mallocz(s->mb_stride * s->mb_height);
5059     v->acpred_plane     = av_malloc (s->mb_stride * s->mb_height);
5060     v->over_flags_plane = av_malloc (s->mb_stride * s->mb_height);
5061
5062     v->n_allocated_blks = s->mb_width + 2;
5063     v->block            = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5064     v->cbp_base         = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5065     v->cbp              = v->cbp_base + s->mb_stride;
5066     v->ttblk_base       = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5067     v->ttblk            = v->ttblk_base + s->mb_stride;
5068     v->is_intra_base    = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5069     v->is_intra         = v->is_intra_base + s->mb_stride;
5070     v->luma_mv_base     = av_malloc(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5071     v->luma_mv          = v->luma_mv_base + s->mb_stride;
5072
5073     /* allocate block type info in that way so it could be used with s->block_index[] */
5074     v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5075     v->mb_type[0]   = v->mb_type_base + s->b8_stride + 1;
5076     v->mb_type[1]   = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
5077     v->mb_type[2]   = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
5078
5079     /* allocate memory to store block level MV info */
5080     v->blk_mv_type_base = av_mallocz(     s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5081     v->blk_mv_type      = v->blk_mv_type_base + s->b8_stride + 1;
5082     v->mv_f_base        = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5083     v->mv_f[0]          = v->mv_f_base + s->b8_stride + 1;
5084     v->mv_f[1]          = v->mv_f[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5085     v->mv_f_last_base   = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5086     v->mv_f_last[0]     = v->mv_f_last_base + s->b8_stride + 1;
5087     v->mv_f_last[1]     = v->mv_f_last[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5088     v->mv_f_next_base   = av_mallocz(2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5089     v->mv_f_next[0]     = v->mv_f_next_base + s->b8_stride + 1;
5090     v->mv_f_next[1]     = v->mv_f_next[0] + (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
5091
5092     /* Init coded blocks info */
5093     if (v->profile == PROFILE_ADVANCED) {
5094 //        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5095 //            return -1;
5096 //        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5097 //            return -1;
5098     }
5099
5100     ff_intrax8_common_init(&v->x8,s);
5101
5102     if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5103         for (i = 0; i < 4; i++)
5104             if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5105     }
5106
5107     if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5108         !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5109         !v->mb_type_base)
5110             return -1;
5111
5112     return 0;
5113 }
5114
5115 /** Initialize a VC1/WMV3 decoder
5116  * @todo TODO: Handle VC-1 IDUs (Transport level?)
5117  * @todo TODO: Decypher remaining bits in extra_data
5118  */
5119 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5120 {
5121     VC1Context *v = avctx->priv_data;
5122     MpegEncContext *s = &v->s;
5123     GetBitContext gb;
5124     int i;
5125
5126     /* save the container output size for WMImage */
5127     v->output_width  = avctx->width;
5128     v->output_height = avctx->height;
5129
5130     if (!avctx->extradata_size || !avctx->extradata)
5131         return -1;
5132     if (!(avctx->flags & CODEC_FLAG_GRAY))
5133         avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5134     else
5135         avctx->pix_fmt = PIX_FMT_GRAY8;
5136     avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5137     v->s.avctx = avctx;
5138     avctx->flags |= CODEC_FLAG_EMU_EDGE;
5139     v->s.flags   |= CODEC_FLAG_EMU_EDGE;
5140
5141     if (avctx->idct_algo == FF_IDCT_AUTO) {
5142         avctx->idct_algo = FF_IDCT_WMV2;
5143     }
5144
5145     if (ff_vc1_init_common(v) < 0)
5146         return -1;
5147     ff_vc1dsp_init(&v->vc1dsp);
5148
5149     if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5150         int count = 0;
5151
5152         // looks like WMV3 has a sequence header stored in the extradata
5153         // advanced sequence header may be before the first frame
5154         // the last byte of the extradata is a version number, 1 for the
5155         // samples we can decode
5156
5157         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5158
5159         if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5160           return -1;
5161
5162         count = avctx->extradata_size*8 - get_bits_count(&gb);
5163         if (count > 0) {
5164             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5165                    count, get_bits(&gb, count));
5166         } else if (count < 0) {
5167             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5168         }
5169     } else { // VC1/WVC1/WVP2
5170         const uint8_t *start = avctx->extradata;
5171         uint8_t *end = avctx->extradata + avctx->extradata_size;
5172         const uint8_t *next;
5173         int size, buf2_size;
5174         uint8_t *buf2 = NULL;
5175         int seq_initialized = 0, ep_initialized = 0;
5176
5177         if (avctx->extradata_size < 16) {
5178             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5179             return -1;
5180         }
5181
5182         buf2  = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5183         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5184         next  = start;
5185         for (; next < end; start = next) {
5186             next = find_next_marker(start + 4, end);
5187             size = next - start - 4;
5188             if (size <= 0)
5189                 continue;
5190             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5191             init_get_bits(&gb, buf2, buf2_size * 8);
5192             switch (AV_RB32(start)) {
5193             case VC1_CODE_SEQHDR:
5194                 if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5195                     av_free(buf2);
5196                     return -1;
5197                 }
5198                 seq_initialized = 1;
5199                 break;
5200             case VC1_CODE_ENTRYPOINT:
5201                 if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5202                     av_free(buf2);
5203                     return -1;
5204                 }
5205                 ep_initialized = 1;
5206                 break;
5207             }
5208         }
5209         av_free(buf2);
5210         if (!seq_initialized || !ep_initialized) {
5211             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5212             return -1;
5213         }
5214         v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
5215     }
5216
5217     avctx->profile = v->profile;
5218     if (v->profile == PROFILE_ADVANCED)
5219         avctx->level = v->level;
5220
5221     avctx->has_b_frames = !!avctx->max_b_frames;
5222
5223     s->mb_width  = (avctx->coded_width  + 15) >> 4;
5224     s->mb_height = (avctx->coded_height + 15) >> 4;
5225
5226     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5227         for (i = 0; i < 64; i++) {
5228 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5229             v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5230             v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5231             v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5232             v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5233             v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5234         }
5235         v->left_blk_sh = 0;
5236         v->top_blk_sh  = 3;
5237     } else {
5238         memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5239         v->left_blk_sh = 3;
5240         v->top_blk_sh  = 0;
5241     }
5242
5243     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5244         v->sprite_width  = avctx->coded_width;
5245         v->sprite_height = avctx->coded_height;
5246
5247         avctx->coded_width  = avctx->width  = v->output_width;
5248         avctx->coded_height = avctx->height = v->output_height;
5249
5250         // prevent 16.16 overflows
5251         if (v->sprite_width  > 1 << 14 ||
5252             v->sprite_height > 1 << 14 ||
5253             v->output_width  > 1 << 14 ||
5254             v->output_height > 1 << 14) return -1;
5255     }
5256     return 0;
5257 }
5258
5259 /** Close a VC1/WMV3 decoder
5260  * @warning Initial try at using MpegEncContext stuff
5261  */
5262 static av_cold int vc1_decode_end(AVCodecContext *avctx)
5263 {
5264     VC1Context *v = avctx->priv_data;
5265     int i;
5266
5267     if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5268         && v->sprite_output_frame.data[0])
5269         avctx->release_buffer(avctx, &v->sprite_output_frame);
5270     for (i = 0; i < 4; i++)
5271         av_freep(&v->sr_rows[i >> 1][i & 1]);
5272     av_freep(&v->hrd_rate);
5273     av_freep(&v->hrd_buffer);
5274     ff_MPV_common_end(&v->s);
5275     av_freep(&v->mv_type_mb_plane);
5276     av_freep(&v->direct_mb_plane);
5277     av_freep(&v->forward_mb_plane);
5278     av_freep(&v->fieldtx_plane);
5279     av_freep(&v->acpred_plane);
5280     av_freep(&v->over_flags_plane);
5281     av_freep(&v->mb_type_base);
5282     av_freep(&v->blk_mv_type_base);
5283     av_freep(&v->mv_f_base);
5284     av_freep(&v->mv_f_last_base);
5285     av_freep(&v->mv_f_next_base);
5286     av_freep(&v->block);
5287     av_freep(&v->cbp_base);
5288     av_freep(&v->ttblk_base);
5289     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5290     av_freep(&v->luma_mv_base);
5291     ff_intrax8_common_end(&v->x8);
5292     return 0;
5293 }
5294
5295
5296 /** Decode a VC1/WMV3 frame
5297  * @todo TODO: Handle VC-1 IDUs (Transport level?)
5298  */
5299 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5300                             int *data_size, AVPacket *avpkt)
5301 {
5302     const uint8_t *buf = avpkt->data;
5303     int buf_size = avpkt->size, n_slices = 0, i;
5304     VC1Context *v = avctx->priv_data;
5305     MpegEncContext *s = &v->s;
5306     AVFrame *pict = data;
5307     uint8_t *buf2 = NULL;
5308     const uint8_t *buf_start = buf;
5309     int mb_height, n_slices1;
5310     struct {
5311         uint8_t *buf;
5312         GetBitContext gb;
5313         int mby_start;
5314     } *slices = NULL, *tmp;
5315
5316     /* no supplementary picture */
5317     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5318         /* special case for last picture */
5319         if (s->low_delay == 0 && s->next_picture_ptr) {
5320             *pict = s->next_picture_ptr->f;
5321             s->next_picture_ptr = NULL;
5322
5323             *data_size = sizeof(AVFrame);
5324         }
5325
5326         return 0;
5327     }
5328
5329     if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5330         if (v->profile < PROFILE_ADVANCED)
5331             avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
5332         else
5333             avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
5334     }
5335
5336     //for advanced profile we may need to parse and unescape data
5337     if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5338         int buf_size2 = 0;
5339         buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5340
5341         if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5342             const uint8_t *start, *end, *next;
5343             int size;
5344
5345             next = buf;
5346             for (start = buf, end = buf + buf_size; next < end; start = next) {
5347                 next = find_next_marker(start + 4, end);
5348                 size = next - start - 4;
5349                 if (size <= 0) continue;
5350                 switch (AV_RB32(start)) {
5351                 case VC1_CODE_FRAME:
5352                     if (avctx->hwaccel ||
5353                         s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5354                         buf_start = start;
5355                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5356                     break;
5357                 case VC1_CODE_FIELD: {
5358                     int buf_size3;
5359                     slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5360                     if (!slices)
5361                         goto err;
5362                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5363                     if (!slices[n_slices].buf)
5364                         goto err;
5365                     buf_size3 = vc1_unescape_buffer(start + 4, size,
5366                                                     slices[n_slices].buf);
5367                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5368                                   buf_size3 << 3);
5369                     /* assuming that the field marker is at the exact middle,
5370                        hope it's correct */
5371                     slices[n_slices].mby_start = s->mb_height >> 1;
5372                     n_slices1 = n_slices - 1; // index of the last slice of the first field
5373                     n_slices++;
5374                     break;
5375                 }
5376                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5377                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5378                     init_get_bits(&s->gb, buf2, buf_size2 * 8);
5379                     ff_vc1_decode_entry_point(avctx, v, &s->gb);
5380                     break;
5381                 case VC1_CODE_SLICE: {
5382                     int buf_size3;
5383                     slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5384                     if (!slices)
5385                         goto err;
5386                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5387                     if (!slices[n_slices].buf)
5388                         goto err;
5389                     buf_size3 = vc1_unescape_buffer(start + 4, size,
5390                                                     slices[n_slices].buf);
5391                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5392                                   buf_size3 << 3);
5393                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5394                     n_slices++;
5395                     break;
5396                 }
5397                 }
5398             }
5399         } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5400             const uint8_t *divider;
5401             int buf_size3;
5402
5403             divider = find_next_marker(buf, buf + buf_size);
5404             if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5405                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5406                 goto err;
5407             } else { // found field marker, unescape second field
5408                 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5409                 if (!tmp)
5410                     goto err;
5411                 slices = tmp;
5412                 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5413                 if (!slices[n_slices].buf)
5414                     goto err;
5415                 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5416                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5417                               buf_size3 << 3);
5418                 slices[n_slices].mby_start = s->mb_height >> 1;
5419                 n_slices1 = n_slices - 1;
5420                 n_slices++;
5421             }
5422             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5423         } else {
5424             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5425         }
5426         init_get_bits(&s->gb, buf2, buf_size2*8);
5427     } else
5428         init_get_bits(&s->gb, buf, buf_size*8);
5429
5430     if (v->res_sprite) {
5431         v->new_sprite  = !get_bits1(&s->gb);
5432         v->two_sprites =  get_bits1(&s->gb);
5433         /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5434            we're using the sprite compositor. These are intentionally kept separate
5435            so you can get the raw sprites by using the wmv3 decoder for WMVP or
5436            the vc1 one for WVP2 */
5437         if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5438             if (v->new_sprite) {
5439                 // switch AVCodecContext parameters to those of the sprites
5440                 avctx->width  = avctx->coded_width  = v->sprite_width;
5441                 avctx->height = avctx->coded_height = v->sprite_height;
5442             } else {
5443                 goto image;
5444             }
5445         }
5446     }
5447
5448     if (s->context_initialized &&
5449         (s->width  != avctx->coded_width ||
5450          s->height != avctx->coded_height)) {
5451         vc1_decode_end(avctx);
5452     }
5453
5454     if (!s->context_initialized) {
5455         if (ff_msmpeg4_decode_init(avctx) < 0 || vc1_decode_init_alloc_tables(v) < 0)
5456             return -1;
5457
5458         s->low_delay = !avctx->has_b_frames || v->res_sprite;
5459
5460         if (v->profile == PROFILE_ADVANCED) {
5461             s->h_edge_pos = avctx->coded_width;
5462             s->v_edge_pos = avctx->coded_height;
5463         }
5464     }
5465
5466     /* We need to set current_picture_ptr before reading the header,
5467      * otherwise we cannot store anything in there. */
5468     if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
5469         int i = ff_find_unused_picture(s, 0);
5470         if (i < 0)
5471             goto err;
5472         s->current_picture_ptr = &s->picture[i];
5473     }
5474
5475     // do parse frame header
5476     v->pic_header_flag = 0;
5477     if (v->profile < PROFILE_ADVANCED) {
5478         if (ff_vc1_parse_frame_header(v, &s->gb) == -1) {
5479             goto err;
5480         }
5481     } else {
5482         if (ff_vc1_parse_frame_header_adv(v, &s->gb) == -1) {
5483             goto err;
5484         }
5485     }
5486
5487     if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5488         && s->pict_type != AV_PICTURE_TYPE_I) {
5489         av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5490         goto err;
5491     }
5492
5493     // process pulldown flags
5494     s->current_picture_ptr->f.repeat_pict = 0;
5495     // Pulldown flags are only valid when 'broadcast' has been set.
5496     // So ticks_per_frame will be 2
5497     if (v->rff) {
5498         // repeat field
5499         s->current_picture_ptr->f.repeat_pict = 1;
5500     } else if (v->rptfrm) {
5501         // repeat frames
5502         s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
5503     }
5504
5505     // for skipping the frame
5506     s->current_picture.f.pict_type = s->pict_type;
5507     s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5508
5509     /* skip B-frames if we don't have reference frames */
5510     if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
5511         goto err;
5512     }
5513     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5514         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
5515          avctx->skip_frame >= AVDISCARD_ALL) {
5516         goto end;
5517     }
5518
5519     if (s->next_p_frame_damaged) {
5520         if (s->pict_type == AV_PICTURE_TYPE_B)
5521             goto end;
5522         else
5523             s->next_p_frame_damaged = 0;
5524     }
5525
5526     if (ff_MPV_frame_start(s, avctx) < 0) {
5527         goto err;
5528     }
5529
5530     s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
5531     s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
5532
5533     if ((CONFIG_VC1_VDPAU_DECODER)
5534         &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5535         ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
5536     else if (avctx->hwaccel) {
5537         if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
5538             goto err;
5539         if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
5540             goto err;
5541         if (avctx->hwaccel->end_frame(avctx) < 0)
5542             goto err;
5543     } else {
5544         ff_er_frame_start(s);
5545
5546         v->bits = buf_size * 8;
5547         if (v->field_mode) {
5548             uint8_t *tmp[2];
5549             s->current_picture.f.linesize[0] <<= 1;
5550             s->current_picture.f.linesize[1] <<= 1;
5551             s->current_picture.f.linesize[2] <<= 1;
5552             s->linesize                      <<= 1;
5553             s->uvlinesize                    <<= 1;
5554             tmp[0]          = v->mv_f_last[0];
5555             tmp[1]          = v->mv_f_last[1];
5556             v->mv_f_last[0] = v->mv_f_next[0];
5557             v->mv_f_last[1] = v->mv_f_next[1];
5558             v->mv_f_next[0] = v->mv_f[0];
5559             v->mv_f_next[1] = v->mv_f[1];
5560             v->mv_f[0] = tmp[0];
5561             v->mv_f[1] = tmp[1];
5562         }
5563         mb_height = s->mb_height >> v->field_mode;
5564         for (i = 0; i <= n_slices; i++) {
5565             if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
5566                 if (v->field_mode <= 0) {
5567                     av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
5568                            "picture boundary (%d >= %d)\n", i,
5569                            slices[i - 1].mby_start, mb_height);
5570                     continue;
5571                 }
5572                 v->second_field = 1;
5573                 v->blocks_off   = s->mb_width  * s->mb_height << 1;
5574                 v->mb_off       = s->mb_stride * s->mb_height >> 1;
5575             } else {
5576                 v->second_field = 0;
5577                 v->blocks_off   = 0;
5578                 v->mb_off       = 0;
5579             }
5580             if (i) {
5581                 v->pic_header_flag = 0;
5582                 if (v->field_mode && i == n_slices1 + 2) {
5583                     if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5584                         av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
5585                         continue;
5586                     }
5587                 } else if (get_bits1(&s->gb)) {
5588                     v->pic_header_flag = 1;
5589                     if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5590                         av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
5591                         continue;
5592                     }
5593                 }
5594             }
5595             s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5596             if (!v->field_mode || v->second_field)
5597                 s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5598             else
5599                 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5600             vc1_decode_blocks(v);
5601             if (i != n_slices)
5602                 s->gb = slices[i].gb;
5603         }
5604         if (v->field_mode) {
5605             v->second_field = 0;
5606             if (s->pict_type == AV_PICTURE_TYPE_B) {
5607                 memcpy(v->mv_f_base, v->mv_f_next_base,
5608                        2 * (s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2));
5609             }
5610             s->current_picture.f.linesize[0] >>= 1;
5611             s->current_picture.f.linesize[1] >>= 1;
5612             s->current_picture.f.linesize[2] >>= 1;
5613             s->linesize                      >>= 1;
5614             s->uvlinesize                    >>= 1;
5615         }
5616 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
5617 //  if (get_bits_count(&s->gb) > buf_size * 8)
5618 //      return -1;
5619         ff_er_frame_end(s);
5620     }
5621
5622     ff_MPV_frame_end(s);
5623
5624     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5625 image:
5626         avctx->width  = avctx->coded_width  = v->output_width;
5627         avctx->height = avctx->coded_height = v->output_height;
5628         if (avctx->skip_frame >= AVDISCARD_NONREF)
5629             goto end;
5630 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
5631         if (vc1_decode_sprites(v, &s->gb))
5632             goto err;
5633 #endif
5634         *pict      = v->sprite_output_frame;
5635         *data_size = sizeof(AVFrame);
5636     } else {
5637         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5638             *pict = s->current_picture_ptr->f;
5639         } else if (s->last_picture_ptr != NULL) {
5640             *pict = s->last_picture_ptr->f;
5641         }
5642         if (s->last_picture_ptr || s->low_delay) {
5643             *data_size = sizeof(AVFrame);
5644             ff_print_debug_info(s, pict);
5645         }
5646     }
5647
5648 end:
5649     av_free(buf2);
5650     for (i = 0; i < n_slices; i++)
5651         av_free(slices[i].buf);
5652     av_free(slices);
5653     return buf_size;
5654
5655 err:
5656     av_free(buf2);
5657     for (i = 0; i < n_slices; i++)
5658         av_free(slices[i].buf);
5659     av_free(slices);
5660     return -1;
5661 }
5662
5663
5664 static const AVProfile profiles[] = {
5665     { FF_PROFILE_VC1_SIMPLE,   "Simple"   },
5666     { FF_PROFILE_VC1_MAIN,     "Main"     },
5667     { FF_PROFILE_VC1_COMPLEX,  "Complex"  },
5668     { FF_PROFILE_VC1_ADVANCED, "Advanced" },
5669     { FF_PROFILE_UNKNOWN },
5670 };
5671
5672 AVCodec ff_vc1_decoder = {
5673     .name           = "vc1",
5674     .type           = AVMEDIA_TYPE_VIDEO,
5675     .id             = AV_CODEC_ID_VC1,
5676     .priv_data_size = sizeof(VC1Context),
5677     .init           = vc1_decode_init,
5678     .close          = vc1_decode_end,
5679     .decode         = vc1_decode_frame,
5680     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5681     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
5682     .pix_fmts       = ff_hwaccel_pixfmt_list_420,
5683     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
5684 };
5685
5686 #if CONFIG_WMV3_DECODER
5687 AVCodec ff_wmv3_decoder = {
5688     .name           = "wmv3",
5689     .type           = AVMEDIA_TYPE_VIDEO,
5690     .id             = AV_CODEC_ID_WMV3,
5691     .priv_data_size = sizeof(VC1Context),
5692     .init           = vc1_decode_init,
5693     .close          = vc1_decode_end,
5694     .decode         = vc1_decode_frame,
5695     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5696     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
5697     .pix_fmts       = ff_hwaccel_pixfmt_list_420,
5698     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
5699 };
5700 #endif
5701
5702 #if CONFIG_WMV3_VDPAU_DECODER
5703 AVCodec ff_wmv3_vdpau_decoder = {
5704     .name           = "wmv3_vdpau",
5705     .type           = AVMEDIA_TYPE_VIDEO,
5706     .id             = AV_CODEC_ID_WMV3,
5707     .priv_data_size = sizeof(VC1Context),
5708     .init           = vc1_decode_init,
5709     .close          = vc1_decode_end,
5710     .decode         = vc1_decode_frame,
5711     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5712     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5713     .pix_fmts       = (const enum PixelFormat[]){ PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE },
5714     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
5715 };
5716 #endif
5717
5718 #if CONFIG_VC1_VDPAU_DECODER
5719 AVCodec ff_vc1_vdpau_decoder = {
5720     .name           = "vc1_vdpau",
5721     .type           = AVMEDIA_TYPE_VIDEO,
5722     .id             = AV_CODEC_ID_VC1,
5723     .priv_data_size = sizeof(VC1Context),
5724     .init           = vc1_decode_init,
5725     .close          = vc1_decode_end,
5726     .decode         = vc1_decode_frame,
5727     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5728     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5729     .pix_fmts       = (const enum PixelFormat[]){ PIX_FMT_VDPAU_VC1, PIX_FMT_NONE },
5730     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
5731 };
5732 #endif
5733
5734 #if CONFIG_WMV3IMAGE_DECODER
5735 AVCodec ff_wmv3image_decoder = {
5736     .name           = "wmv3image",
5737     .type           = AVMEDIA_TYPE_VIDEO,
5738     .id             = AV_CODEC_ID_WMV3IMAGE,
5739     .priv_data_size = sizeof(VC1Context),
5740     .init           = vc1_decode_init,
5741     .close          = vc1_decode_end,
5742     .decode         = vc1_decode_frame,
5743     .capabilities   = CODEC_CAP_DR1,
5744     .flush          = vc1_sprite_flush,
5745     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
5746     .pix_fmts       = ff_pixfmt_list_420
5747 };
5748 #endif
5749
5750 #if CONFIG_VC1IMAGE_DECODER
5751 AVCodec ff_vc1image_decoder = {
5752     .name           = "vc1image",
5753     .type           = AVMEDIA_TYPE_VIDEO,
5754     .id             = AV_CODEC_ID_VC1IMAGE,
5755     .priv_data_size = sizeof(VC1Context),
5756     .init           = vc1_decode_init,
5757     .close          = vc1_decode_end,
5758     .decode         = vc1_decode_frame,
5759     .capabilities   = CODEC_CAP_DR1,
5760     .flush          = vc1_sprite_flush,
5761     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
5762     .pix_fmts       = ff_pixfmt_list_420
5763 };
5764 #endif