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

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