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