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

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