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