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