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