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

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