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

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