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

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