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