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