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

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