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

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