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