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