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 static void init_block_index(VC1Context *v)
  64 {
  65     MpegEncContext *s = &v->s;
  66     ff_init_block_index(s);
  67     if (v->field_mode && !(v->second_field ^ v->tff)) {
  68         s->dest[0] += s->current_picture_ptr->f.linesize[0];
  69         s->dest[1] += s->current_picture_ptr->f.linesize[1];
  70         s->dest[2] += s->current_picture_ptr->f.linesize[2];
  71     }
  72 }
  73
  74 /** @} */ //Bitplane group
  75
  76 static void vc1_put_signed_blocks_clamped(VC1Context *v)
  77 {
  78     MpegEncContext *s = &v->s;
  79     int topleft_mb_pos, top_mb_pos;
  80     int stride_y, fieldtx = 0;
  81     int v_dist;
  82
  83     /* The put pixels loop is always one MB row behind the decoding loop,
  84      * because we can only put pixels when overlap filtering is done, and
  85      * for filtering of the bottom edge of a MB, we need the next MB row
  86      * present as well.
  87      * Within the row, the put pixels loop is also one MB col behind the
  88      * decoding loop. The reason for this is again, because for filtering
  89      * of the right MB edge, we need the next MB present. */
  90     if (!s->first_slice_line) {
  91         if (s->mb_x) {
  92             topleft_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x - 1;
  93             if (v->fcm == ILACE_FRAME)
  94                 fieldtx = v->fieldtx_plane[topleft_mb_pos];
  95             stride_y       = s->linesize << fieldtx;
  96             v_dist         = (16 - fieldtx) >> (fieldtx == 0);
  97             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
  98                                              s->dest[0] - 16 * s->linesize - 16,
  99                                              stride_y);
 100             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
 101                                              s->dest[0] - 16 * s->linesize - 8,
 102                                              stride_y);
 103             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
 104                                              s->dest[0] - v_dist * s->linesize - 16,
 105                                              stride_y);
 106             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
 107                                              s->dest[0] - v_dist * s->linesize - 8,
 108                                              stride_y);
 109             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
 110                                              s->dest[1] - 8 * s->uvlinesize - 8,
 111                                              s->uvlinesize);
 112             s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
 113                                              s->dest[2] - 8 * s->uvlinesize - 8,
 114                                              s->uvlinesize);
 115         }
 116         if (s->mb_x == s->mb_width - 1) {
 117             top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
 118             if (v->fcm == ILACE_FRAME)
 119                 fieldtx = v->fieldtx_plane[top_mb_pos];
 120             stride_y   = s->linesize << fieldtx;
 121             v_dist     = fieldtx ? 15 : 8;
 122             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
 123                                              s->dest[0] - 16 * s->linesize,
 124                                              stride_y);
 125             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
 126                                              s->dest[0] - 16 * s->linesize + 8,
 127                                              stride_y);
 128             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
 129                                              s->dest[0] - v_dist * s->linesize,
 130                                              stride_y);
 131             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
 132                                              s->dest[0] - v_dist * s->linesize + 8,
 133                                              stride_y);
 134             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
 135                                              s->dest[1] - 8 * s->uvlinesize,
 136                                              s->uvlinesize);
 137             s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
 138                                              s->dest[2] - 8 * s->uvlinesize,
 139                                              s->uvlinesize);
 140         }
 141     }
 142
 143 #define inc_blk_idx(idx) do { \
 144         idx++; \
 145         if (idx >= v->n_allocated_blks) \
 146             idx = 0; \
 147     } while (0)
 148
 149     inc_blk_idx(v->topleft_blk_idx);
 150     inc_blk_idx(v->top_blk_idx);
 151     inc_blk_idx(v->left_blk_idx);
 152     inc_blk_idx(v->cur_blk_idx);
 153 }
 154
 155 static void vc1_loop_filter_iblk(VC1Context *v, int pq)
 156 {
 157     MpegEncContext *s = &v->s;
 158     int j;
 159     if (!s->first_slice_line) {
 160         v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
 161         if (s->mb_x)
 162             v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
 163         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
 164         for (j = 0; j < 2; j++) {
 165             v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
 166             if (s->mb_x)
 167                 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
 168         }
 169     }
 170     v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
 171
 172     if (s->mb_y == s->end_mb_y - 1) {
 173         if (s->mb_x) {
 174             v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
 175             v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
 176             v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
 177         }
 178         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
 179     }
 180 }
 181
 182 static void vc1_loop_filter_iblk_delayed(VC1Context *v, int pq)
 183 {
 184     MpegEncContext *s = &v->s;
 185     int j;
 186
 187     /* The loopfilter runs 1 row and 1 column behind the overlap filter, which
 188      * means it runs two rows/cols behind the decoding loop. */
 189     if (!s->first_slice_line) {
 190         if (s->mb_x) {
 191             if (s->mb_y >= s->start_mb_y + 2) {
 192                 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
 193
 194                 if (s->mb_x >= 2)
 195                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 16, s->linesize, pq);
 196                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize - 8, s->linesize, pq);
 197                 for (j = 0; j < 2; j++) {
 198                     v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
 199                     if (s->mb_x >= 2) {
 200                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize - 8, s->uvlinesize, pq);
 201                     }
 202                 }
 203             }
 204             v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize - 16, s->linesize, pq);
 205         }
 206
 207         if (s->mb_x == s->mb_width - 1) {
 208             if (s->mb_y >= s->start_mb_y + 2) {
 209                 v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
 210
 211                 if (s->mb_x)
 212                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize, s->linesize, pq);
 213                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 32 * s->linesize + 8, s->linesize, pq);
 214                 for (j = 0; j < 2; j++) {
 215                     v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
 216                     if (s->mb_x >= 2) {
 217                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 16 * s->uvlinesize, s->uvlinesize, pq);
 218                     }
 219                 }
 220             }
 221             v->vc1dsp.vc1_v_loop_filter16(s->dest[0] - 8 * s->linesize, s->linesize, pq);
 222         }
 223
 224         if (s->mb_y == s->end_mb_y) {
 225             if (s->mb_x) {
 226                 if (s->mb_x >= 2)
 227                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 16, s->linesize, pq);
 228                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize - 8, s->linesize, pq);
 229                 if (s->mb_x >= 2) {
 230                     for (j = 0; j < 2; j++) {
 231                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize - 8, s->uvlinesize, pq);
 232                     }
 233                 }
 234             }
 235
 236             if (s->mb_x == s->mb_width - 1) {
 237                 if (s->mb_x)
 238                     v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
 239                 v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
 240                 if (s->mb_x) {
 241                     for (j = 0; j < 2; j++) {
 242                         v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
 243                     }
 244                 }
 245             }
 246         }
 247     }
 248 }
 249
 250 static void vc1_smooth_overlap_filter_iblk(VC1Context *v)
 251 {
 252     MpegEncContext *s = &v->s;
 253     int mb_pos;
 254
 255     if (v->condover == CONDOVER_NONE)
 256         return;
 257
 258     mb_pos = s->mb_x + s->mb_y * s->mb_stride;
 259
 260     /* Within a MB, the horizontal overlap always runs before the vertical.
 261      * To accomplish that, we run the H on left and internal borders of the
 262      * currently decoded MB. Then, we wait for the next overlap iteration
 263      * to do H overlap on the right edge of this MB, before moving over and
 264      * running the V overlap. Therefore, the V overlap makes us trail by one
 265      * MB col and the H overlap filter makes us trail by one MB row. This
 266      * is reflected in the time at which we run the put_pixels loop. */
 267     if (v->condover == CONDOVER_ALL || v->pq >= 9 || v->over_flags_plane[mb_pos]) {
 268         if (s->mb_x && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
 269                         v->over_flags_plane[mb_pos - 1])) {
 270             v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][1],
 271                                       v->block[v->cur_blk_idx][0]);
 272             v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][3],
 273                                       v->block[v->cur_blk_idx][2]);
 274             if (!(s->flags & CODEC_FLAG_GRAY)) {
 275                 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][4],
 276                                           v->block[v->cur_blk_idx][4]);
 277                 v->vc1dsp.vc1_h_s_overlap(v->block[v->left_blk_idx][5],
 278                                           v->block[v->cur_blk_idx][5]);
 279             }
 280         }
 281         v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][0],
 282                                   v->block[v->cur_blk_idx][1]);
 283         v->vc1dsp.vc1_h_s_overlap(v->block[v->cur_blk_idx][2],
 284                                   v->block[v->cur_blk_idx][3]);
 285
 286         if (s->mb_x == s->mb_width - 1) {
 287             if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
 288                                          v->over_flags_plane[mb_pos - s->mb_stride])) {
 289                 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][2],
 290                                           v->block[v->cur_blk_idx][0]);
 291                 v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][3],
 292                                           v->block[v->cur_blk_idx][1]);
 293                 if (!(s->flags & CODEC_FLAG_GRAY)) {
 294                     v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][4],
 295                                               v->block[v->cur_blk_idx][4]);
 296                     v->vc1dsp.vc1_v_s_overlap(v->block[v->top_blk_idx][5],
 297                                               v->block[v->cur_blk_idx][5]);
 298                 }
 299             }
 300             v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][0],
 301                                       v->block[v->cur_blk_idx][2]);
 302             v->vc1dsp.vc1_v_s_overlap(v->block[v->cur_blk_idx][1],
 303                                       v->block[v->cur_blk_idx][3]);
 304         }
 305     }
 306     if (s->mb_x && (v->condover == CONDOVER_ALL || v->over_flags_plane[mb_pos - 1])) {
 307         if (!s->first_slice_line && (v->condover == CONDOVER_ALL || v->pq >= 9 ||
 308                                      v->over_flags_plane[mb_pos - s->mb_stride - 1])) {
 309             v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][2],
 310                                       v->block[v->left_blk_idx][0]);
 311             v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][3],
 312                                       v->block[v->left_blk_idx][1]);
 313             if (!(s->flags & CODEC_FLAG_GRAY)) {
 314                 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][4],
 315                                           v->block[v->left_blk_idx][4]);
 316                 v->vc1dsp.vc1_v_s_overlap(v->block[v->topleft_blk_idx][5],
 317                                           v->block[v->left_blk_idx][5]);
 318             }
 319         }
 320         v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][0],
 321                                   v->block[v->left_blk_idx][2]);
 322         v->vc1dsp.vc1_v_s_overlap(v->block[v->left_blk_idx][1],
 323                                   v->block[v->left_blk_idx][3]);
 324     }
 325 }
 326
 327 /** Do motion compensation over 1 macroblock
 328  * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
 329  */
 330 static void vc1_mc_1mv(VC1Context *v, int dir)
 331 {
 332     MpegEncContext *s = &v->s;
 333     H264ChromaContext *h264chroma = &v->h264chroma;
 334     uint8_t *srcY, *srcU, *srcV;
 335     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
 336     int v_edge_pos = s->v_edge_pos >> v->field_mode;
 337     int i;
 338     uint8_t (*luty)[256], (*lutuv)[256];
 339     int use_ic;
 340
 341     if ((!v->field_mode ||
 342          (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
 343         !v->s.last_picture.f.data[0])
 344         return;
 345
 346     mx = s->mv[dir][0][0];
 347     my = s->mv[dir][0][1];
 348
 349     // store motion vectors for further use in B frames
 350     if (s->pict_type == AV_PICTURE_TYPE_P) {
 351         for (i = 0; i < 4; i++) {
 352             s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][0] = mx;
 353             s->current_picture.motion_val[1][s->block_index[i] + v->blocks_off][1] = my;
 354         }
 355     }
 356
 357     uvmx = (mx + ((mx & 3) == 3)) >> 1;
 358     uvmy = (my + ((my & 3) == 3)) >> 1;
 359     v->luma_mv[s->mb_x][0] = uvmx;
 360     v->luma_mv[s->mb_x][1] = uvmy;
 361
 362     if (v->field_mode &&
 363         v->cur_field_type != v->ref_field_type[dir]) {
 364         my   = my   - 2 + 4 * v->cur_field_type;
 365         uvmy = uvmy - 2 + 4 * v->cur_field_type;
 366     }
 367
 368     // fastuvmc shall be ignored for interlaced frame picture
 369     if (v->fastuvmc && (v->fcm != ILACE_FRAME)) {
 370         uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
 371         uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
 372     }
 373     if (!dir) {
 374         if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
 375             srcY = s->current_picture.f.data[0];
 376             srcU = s->current_picture.f.data[1];
 377             srcV = s->current_picture.f.data[2];
 378             luty  = v->curr_luty;
 379             lutuv = v->curr_lutuv;
 380             use_ic = v->curr_use_ic;
 381         } else {
 382             srcY = s->last_picture.f.data[0];
 383             srcU = s->last_picture.f.data[1];
 384             srcV = s->last_picture.f.data[2];
 385             luty  = v->last_luty;
 386             lutuv = v->last_lutuv;
 387             use_ic = v->last_use_ic;
 388         }
 389     } else {
 390         srcY = s->next_picture.f.data[0];
 391         srcU = s->next_picture.f.data[1];
 392         srcV = s->next_picture.f.data[2];
 393         luty  = v->next_luty;
 394         lutuv = v->next_lutuv;
 395         use_ic = v->next_use_ic;
 396     }
 397
 398     if (!srcY || !srcU) {
 399         av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
 400         return;
 401     }
 402
 403     src_x   = s->mb_x * 16 + (mx   >> 2);
 404     src_y   = s->mb_y * 16 + (my   >> 2);
 405     uvsrc_x = s->mb_x *  8 + (uvmx >> 2);
 406     uvsrc_y = s->mb_y *  8 + (uvmy >> 2);
 407
 408     if (v->profile != PROFILE_ADVANCED) {
 409         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
 410         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
 411         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
 412         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
 413     } else {
 414         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
 415         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
 416         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
 417         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
 418     }
 419
 420     srcY += src_y   * s->linesize   + src_x;
 421     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
 422     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
 423
 424     if (v->field_mode && v->ref_field_type[dir]) {
 425         srcY += s->current_picture_ptr->f.linesize[0];
 426         srcU += s->current_picture_ptr->f.linesize[1];
 427         srcV += s->current_picture_ptr->f.linesize[2];
 428     }
 429
 430     /* for grayscale we should not try to read from unknown area */
 431     if (s->flags & CODEC_FLAG_GRAY) {
 432         srcU = s->edge_emu_buffer + 18 * s->linesize;
 433         srcV = s->edge_emu_buffer + 18 * s->linesize;
 434     }
 435
 436     if (v->rangeredfrm || use_ic
 437         || s->h_edge_pos < 22 || v_edge_pos < 22
 438         || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
 439         || (unsigned)(src_y - 1)        > v_edge_pos    - (my&3) - 16 - 3) {
 440         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
 441
 442         srcY -= s->mspel * (1 + s->linesize);
 443         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
 444                                  s->linesize, s->linesize,
 445                                  17 + s->mspel * 2, 17 + s->mspel * 2,
 446                                  src_x - s->mspel, src_y - s->mspel,
 447                                  s->h_edge_pos, v_edge_pos);
 448         srcY = s->edge_emu_buffer;
 449         s->vdsp.emulated_edge_mc(uvbuf, srcU,
 450                                  s->uvlinesize, s->uvlinesize,
 451                                  8 + 1, 8 + 1,
 452                                  uvsrc_x, uvsrc_y,
 453                                  s->h_edge_pos >> 1, v_edge_pos >> 1);
 454         s->vdsp.emulated_edge_mc(uvbuf + 16, srcV,
 455                                  s->uvlinesize, s->uvlinesize,
 456                                  8 + 1, 8 + 1,
 457                                  uvsrc_x, uvsrc_y,
 458                                  s->h_edge_pos >> 1, v_edge_pos >> 1);
 459         srcU = uvbuf;
 460         srcV = uvbuf + 16;
 461         /* if we deal with range reduction we need to scale source blocks */
 462         if (v->rangeredfrm) {
 463             int i, j;
 464             uint8_t *src, *src2;
 465
 466             src = srcY;
 467             for (j = 0; j < 17 + s->mspel * 2; j++) {
 468                 for (i = 0; i < 17 + s->mspel * 2; i++)
 469                     src[i] = ((src[i] - 128) >> 1) + 128;
 470                 src += s->linesize;
 471             }
 472             src  = srcU;
 473             src2 = srcV;
 474             for (j = 0; j < 9; j++) {
 475                 for (i = 0; i < 9; i++) {
 476                     src[i]  = ((src[i]  - 128) >> 1) + 128;
 477                     src2[i] = ((src2[i] - 128) >> 1) + 128;
 478                 }
 479                 src  += s->uvlinesize;
 480                 src2 += s->uvlinesize;
 481             }
 482         }
 483         /* if we deal with intensity compensation we need to scale source blocks */
 484         if (use_ic) {
 485             int i, j;
 486             uint8_t *src, *src2;
 487
 488             src = srcY;
 489             for (j = 0; j < 17 + s->mspel * 2; j++) {
 490                 int f = v->field_mode ? v->ref_field_type[dir] : ((j + src_y - s->mspel) & 1) ;
 491                 for (i = 0; i < 17 + s->mspel * 2; i++)
 492                     src[i] = luty[f][src[i]];
 493                 src += s->linesize;
 494             }
 495             src  = srcU;
 496             src2 = srcV;
 497             for (j = 0; j < 9; j++) {
 498                 int f = v->field_mode ? v->ref_field_type[dir] : ((j + uvsrc_y) & 1);
 499                 for (i = 0; i < 9; i++) {
 500                     src[i]  = lutuv[f][src[i]];
 501                     src2[i] = lutuv[f][src2[i]];
 502                 }
 503                 src  += s->uvlinesize;
 504                 src2 += s->uvlinesize;
 505             }
 506         }
 507         srcY += s->mspel * (1 + s->linesize);
 508     }
 509
 510     if (s->mspel) {
 511         dxy = ((my & 3) << 2) | (mx & 3);
 512         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0]    , srcY    , s->linesize, v->rnd);
 513         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
 514         srcY += s->linesize * 8;
 515         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
 516         v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
 517     } else { // hpel mc - always used for luma
 518         dxy = (my & 2) | ((mx & 2) >> 1);
 519         if (!v->rnd)
 520             s->hdsp.put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
 521         else
 522             s->hdsp.put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
 523     }
 524
 525     if (s->flags & CODEC_FLAG_GRAY) return;
 526     /* Chroma MC always uses qpel bilinear */
 527     uvmx = (uvmx & 3) << 1;
 528     uvmy = (uvmy & 3) << 1;
 529     if (!v->rnd) {
 530         h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
 531         h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
 532     } else {
 533         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
 534         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
 535     }
 536 }
 537
 538 static inline int median4(int a, int b, int c, int d)
 539 {
 540     if (a < b) {
 541         if (c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
 542         else       return (FFMIN(b, c) + FFMAX(a, d)) / 2;
 543     } else {
 544         if (c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
 545         else       return (FFMIN(a, c) + FFMAX(b, d)) / 2;
 546     }
 547 }
 548
 549 /** Do motion compensation for 4-MV macroblock - luminance block
 550  */
 551 static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
 552 {
 553     MpegEncContext *s = &v->s;
 554     uint8_t *srcY;
 555     int dxy, mx, my, src_x, src_y;
 556     int off;
 557     int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
 558     int v_edge_pos = s->v_edge_pos >> v->field_mode;
 559     uint8_t (*luty)[256];
 560     int use_ic;
 561
 562     if ((!v->field_mode ||
 563          (v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
 564         !v->s.last_picture.f.data[0])
 565         return;
 566
 567     mx = s->mv[dir][n][0];
 568     my = s->mv[dir][n][1];
 569
 570     if (!dir) {
 571         if (v->field_mode && (v->cur_field_type != v->ref_field_type[dir]) && v->second_field) {
 572             srcY = s->current_picture.f.data[0];
 573             luty = v->curr_luty;
 574             use_ic = v->curr_use_ic;
 575         } else {
 576             srcY = s->last_picture.f.data[0];
 577             luty = v->last_luty;
 578             use_ic = v->last_use_ic;
 579         }
 580     } else {
 581         srcY = s->next_picture.f.data[0];
 582         luty = v->next_luty;
 583         use_ic = v->next_use_ic;
 584     }
 585
 586     if (!srcY) {
 587         av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
 588         return;
 589     }
 590
 591     if (v->field_mode) {
 592         if (v->cur_field_type != v->ref_field_type[dir])
 593             my = my - 2 + 4 * v->cur_field_type;
 594     }
 595
 596     if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
 597         int same_count = 0, opp_count = 0, k;
 598         int chosen_mv[2][4][2], f;
 599         int tx, ty;
 600         for (k = 0; k < 4; k++) {
 601             f = v->mv_f[0][s->block_index[k] + v->blocks_off];
 602             chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
 603             chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
 604             opp_count  += f;
 605             same_count += 1 - f;
 606         }
 607         f = opp_count > same_count;
 608         switch (f ? opp_count : same_count) {
 609         case 4:
 610             tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
 611                          chosen_mv[f][2][0], chosen_mv[f][3][0]);
 612             ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
 613                          chosen_mv[f][2][1], chosen_mv[f][3][1]);
 614             break;
 615         case 3:
 616             tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
 617             ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
 618             break;
 619         case 2:
 620             tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
 621             ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
 622             break;
 623         default:
 624             av_assert0(0);
 625         }
 626         s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
 627         s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
 628         for (k = 0; k < 4; k++)
 629             v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
 630     }
 631
 632     if (v->fcm == ILACE_FRAME) {  // not sure if needed for other types of picture
 633         int qx, qy;
 634         int width  = s->avctx->coded_width;
 635         int height = s->avctx->coded_height >> 1;
 636         if (s->pict_type == AV_PICTURE_TYPE_P) {
 637             s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][0] = mx;
 638             s->current_picture.motion_val[1][s->block_index[n] + v->blocks_off][1] = my;
 639         }
 640         qx = (s->mb_x * 16) + (mx >> 2);
 641         qy = (s->mb_y *  8) + (my >> 3);
 642
 643         if (qx < -17)
 644             mx -= 4 * (qx + 17);
 645         else if (qx > width)
 646             mx -= 4 * (qx - width);
 647         if (qy < -18)
 648             my -= 8 * (qy + 18);
 649         else if (qy > height + 1)
 650             my -= 8 * (qy - height - 1);
 651     }
 652
 653     if ((v->fcm == ILACE_FRAME) && fieldmv)
 654         off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
 655     else
 656         off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
 657
 658     src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
 659     if (!fieldmv)
 660         src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
 661     else
 662         src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
 663
 664     if (v->profile != PROFILE_ADVANCED) {
 665         src_x = av_clip(src_x, -16, s->mb_width  * 16);
 666         src_y = av_clip(src_y, -16, s->mb_height * 16);
 667     } else {
 668         src_x = av_clip(src_x, -17, s->avctx->coded_width);
 669         if (v->fcm == ILACE_FRAME) {
 670             if (src_y & 1)
 671                 src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
 672             else
 673                 src_y = av_clip(src_y, -18, s->avctx->coded_height);
 674         } else {
 675             src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
 676         }
 677     }
 678
 679     srcY += src_y * s->linesize + src_x;
 680     if (v->field_mode && v->ref_field_type[dir])
 681         srcY += s->current_picture_ptr->f.linesize[0];
 682
 683     if (fieldmv && !(src_y & 1))
 684         v_edge_pos--;
 685     if (fieldmv && (src_y & 1) && src_y < 4)
 686         src_y--;
 687     if (v->rangeredfrm || use_ic
 688         || s->h_edge_pos < 13 || v_edge_pos < 23
 689         || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
 690         || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
 691         srcY -= s->mspel * (1 + (s->linesize << fieldmv));
 692         /* check emulate edge stride and offset */
 693         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
 694                                  s->linesize, s->linesize,
 695                                  9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
 696                                  src_x - s->mspel, src_y - (s->mspel << fieldmv),
 697                                  s->h_edge_pos, v_edge_pos);
 698         srcY = s->edge_emu_buffer;
 699         /* if we deal with range reduction we need to scale source blocks */
 700         if (v->rangeredfrm) {
 701             int i, j;
 702             uint8_t *src;
 703
 704             src = srcY;
 705             for (j = 0; j < 9 + s->mspel * 2; j++) {
 706                 for (i = 0; i < 9 + s->mspel * 2; i++)
 707                     src[i] = ((src[i] - 128) >> 1) + 128;
 708                 src += s->linesize << fieldmv;
 709             }
 710         }
 711         /* if we deal with intensity compensation we need to scale source blocks */
 712         if (use_ic) {
 713             int i, j;
 714             uint8_t *src;
 715
 716             src = srcY;
 717             for (j = 0; j < 9 + s->mspel * 2; j++) {
 718                 int f = v->field_mode ? v->ref_field_type[dir] : (((j<<fieldmv)+src_y - (s->mspel << fieldmv)) & 1);
 719                 for (i = 0; i < 9 + s->mspel * 2; i++)
 720                     src[i] = luty[f][src[i]];
 721                 src += s->linesize << fieldmv;
 722             }
 723         }
 724         srcY += s->mspel * (1 + (s->linesize << fieldmv));
 725     }
 726
 727     if (s->mspel) {
 728         dxy = ((my & 3) << 2) | (mx & 3);
 729         if (avg)
 730             v->vc1dsp.avg_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
 731         else
 732             v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
 733     } else { // hpel mc - always used for luma
 734         dxy = (my & 2) | ((mx & 2) >> 1);
 735         if (!v->rnd)
 736             s->hdsp.put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
 737         else
 738             s->hdsp.put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
 739     }
 740 }
 741
 742 static av_always_inline int get_chroma_mv(int *mvx, int *mvy, int *a, int flag, int *tx, int *ty)
 743 {
 744     int idx, i;
 745     static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
 746
 747     idx =  ((a[3] != flag) << 3)
 748          | ((a[2] != flag) << 2)
 749          | ((a[1] != flag) << 1)
 750          |  (a[0] != flag);
 751     if (!idx) {
 752         *tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
 753         *ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
 754         return 4;
 755     } else if (count[idx] == 1) {
 756         switch (idx) {
 757         case 0x1:
 758             *tx = mid_pred(mvx[1], mvx[2], mvx[3]);
 759             *ty = mid_pred(mvy[1], mvy[2], mvy[3]);
 760             return 3;
 761         case 0x2:
 762             *tx = mid_pred(mvx[0], mvx[2], mvx[3]);
 763             *ty = mid_pred(mvy[0], mvy[2], mvy[3]);
 764             return 3;
 765         case 0x4:
 766             *tx = mid_pred(mvx[0], mvx[1], mvx[3]);
 767             *ty = mid_pred(mvy[0], mvy[1], mvy[3]);
 768             return 3;
 769         case 0x8:
 770             *tx = mid_pred(mvx[0], mvx[1], mvx[2]);
 771             *ty = mid_pred(mvy[0], mvy[1], mvy[2]);
 772             return 3;
 773         }
 774     } else if (count[idx] == 2) {
 775         int t1 = 0, t2 = 0;
 776         for (i = 0; i < 3; i++)
 777             if (!a[i]) {
 778                 t1 = i;
 779                 break;
 780             }
 781         for (i = t1 + 1; i < 4; i++)
 782             if (!a[i]) {
 783                 t2 = i;
 784                 break;
 785             }
 786         *tx = (mvx[t1] + mvx[t2]) / 2;
 787         *ty = (mvy[t1] + mvy[t2]) / 2;
 788         return 2;
 789     } else {
 790         return 0;
 791     }
 792     return -1;
 793 }
 794
 795 /** Do motion compensation for 4-MV macroblock - both chroma blocks
 796  */
 797 static void vc1_mc_4mv_chroma(VC1Context *v, int dir)
 798 {
 799     MpegEncContext *s = &v->s;
 800     H264ChromaContext *h264chroma = &v->h264chroma;
 801     uint8_t *srcU, *srcV;
 802     int uvmx, uvmy, uvsrc_x, uvsrc_y;
 803     int k, tx = 0, ty = 0;
 804     int mvx[4], mvy[4], intra[4], mv_f[4];
 805     int valid_count;
 806     int chroma_ref_type = v->cur_field_type;
 807     int v_edge_pos = s->v_edge_pos >> v->field_mode;
 808     uint8_t (*lutuv)[256];
 809     int use_ic;
 810
 811     if (!v->field_mode && !v->s.last_picture.f.data[0])
 812         return;
 813     if (s->flags & CODEC_FLAG_GRAY)
 814         return;
 815
 816     for (k = 0; k < 4; k++) {
 817         mvx[k] = s->mv[dir][k][0];
 818         mvy[k] = s->mv[dir][k][1];
 819         intra[k] = v->mb_type[0][s->block_index[k]];
 820         if (v->field_mode)
 821             mv_f[k] = v->mv_f[dir][s->block_index[k] + v->blocks_off];
 822     }
 823
 824     /* calculate chroma MV vector from four luma MVs */
 825     if (!v->field_mode || (v->field_mode && !v->numref)) {
 826         valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
 827         chroma_ref_type = v->reffield;
 828         if (!valid_count) {
 829             s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
 830             s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
 831             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
 832             return; //no need to do MC for intra blocks
 833         }
 834     } else {
 835         int dominant = 0;
 836         if (mv_f[0] + mv_f[1] + mv_f[2] + mv_f[3] > 2)
 837             dominant = 1;
 838         valid_count = get_chroma_mv(mvx, mvy, mv_f, dominant, &tx, &ty);
 839         if (dominant)
 840             chroma_ref_type = !v->cur_field_type;
 841     }
 842     if (v->field_mode && chroma_ref_type == 1 && v->cur_field_type == 1 && !v->s.last_picture.f.data[0])
 843         return;
 844     s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
 845     s->current_picture.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
 846     uvmx = (tx + ((tx & 3) == 3)) >> 1;
 847     uvmy = (ty + ((ty & 3) == 3)) >> 1;
 848
 849     v->luma_mv[s->mb_x][0] = uvmx;
 850     v->luma_mv[s->mb_x][1] = uvmy;
 851
 852     if (v->fastuvmc) {
 853         uvmx = uvmx + ((uvmx < 0) ? (uvmx & 1) : -(uvmx & 1));
 854         uvmy = uvmy + ((uvmy < 0) ? (uvmy & 1) : -(uvmy & 1));
 855     }
 856     // Field conversion bias
 857     if (v->cur_field_type != chroma_ref_type)
 858         uvmy += 2 - 4 * chroma_ref_type;
 859
 860     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
 861     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
 862
 863     if (v->profile != PROFILE_ADVANCED) {
 864         uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width  * 8);
 865         uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
 866     } else {
 867         uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width  >> 1);
 868         uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
 869     }
 870
 871     if (!dir) {
 872         if (v->field_mode && (v->cur_field_type != chroma_ref_type) && v->second_field) {
 873             srcU = s->current_picture.f.data[1];
 874             srcV = s->current_picture.f.data[2];
 875             lutuv = v->curr_lutuv;
 876             use_ic = v->curr_use_ic;
 877         } else {
 878             srcU = s->last_picture.f.data[1];
 879             srcV = s->last_picture.f.data[2];
 880             lutuv = v->last_lutuv;
 881             use_ic = v->last_use_ic;
 882         }
 883     } else {
 884         srcU = s->next_picture.f.data[1];
 885         srcV = s->next_picture.f.data[2];
 886         lutuv = v->next_lutuv;
 887         use_ic = v->next_use_ic;
 888     }
 889
 890     if (!srcU) {
 891         av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
 892         return;
 893     }
 894
 895     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
 896     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
 897
 898     if (v->field_mode) {
 899         if (chroma_ref_type) {
 900             srcU += s->current_picture_ptr->f.linesize[1];
 901             srcV += s->current_picture_ptr->f.linesize[2];
 902         }
 903     }
 904
 905     if (v->rangeredfrm || use_ic
 906         || s->h_edge_pos < 18 || v_edge_pos < 18
 907         || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
 908         || (unsigned)uvsrc_y > (v_edge_pos    >> 1) - 9) {
 909         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU,
 910                                  s->uvlinesize, s->uvlinesize,
 911                                  8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
 912                                  s->h_edge_pos >> 1, v_edge_pos >> 1);
 913         s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV,
 914                                  s->uvlinesize, s->uvlinesize,
 915                                  8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
 916                                  s->h_edge_pos >> 1, v_edge_pos >> 1);
 917         srcU = s->edge_emu_buffer;
 918         srcV = s->edge_emu_buffer + 16;
 919
 920         /* if we deal with range reduction we need to scale source blocks */
 921         if (v->rangeredfrm) {
 922             int i, j;
 923             uint8_t *src, *src2;
 924
 925             src  = srcU;
 926             src2 = srcV;
 927             for (j = 0; j < 9; j++) {
 928                 for (i = 0; i < 9; i++) {
 929                     src[i]  = ((src[i]  - 128) >> 1) + 128;
 930                     src2[i] = ((src2[i] - 128) >> 1) + 128;
 931                 }
 932                 src  += s->uvlinesize;
 933                 src2 += s->uvlinesize;
 934             }
 935         }
 936         /* if we deal with intensity compensation we need to scale source blocks */
 937         if (use_ic) {
 938             int i, j;
 939             uint8_t *src, *src2;
 940
 941             src  = srcU;
 942             src2 = srcV;
 943             for (j = 0; j < 9; j++) {
 944                 int f = v->field_mode ? chroma_ref_type : ((j + uvsrc_y) & 1);
 945                 for (i = 0; i < 9; i++) {
 946                     src[i]  = lutuv[f][src[i]];
 947                     src2[i] = lutuv[f][src2[i]];
 948                 }
 949                 src  += s->uvlinesize;
 950                 src2 += s->uvlinesize;
 951             }
 952         }
 953     }
 954
 955     /* Chroma MC always uses qpel bilinear */
 956     uvmx = (uvmx & 3) << 1;
 957     uvmy = (uvmy & 3) << 1;
 958     if (!v->rnd) {
 959         h264chroma->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
 960         h264chroma->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
 961     } else {
 962         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
 963         v->vc1dsp.put_no_rnd_vc1_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
 964     }
 965 }
 966
 967 /** Do motion compensation for 4-MV interlaced frame chroma macroblock (both U and V)
 968  */
 969 static void vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)
 970 {
 971     MpegEncContext *s = &v->s;
 972     H264ChromaContext *h264chroma = &v->h264chroma;
 973     uint8_t *srcU, *srcV;
 974     int uvsrc_x, uvsrc_y;
 975     int uvmx_field[4], uvmy_field[4];
 976     int i, off, tx, ty;
 977     int fieldmv = v->blk_mv_type[s->block_index[0]];
 978     static const int s_rndtblfield[16] = { 0, 0, 1, 2, 4, 4, 5, 6, 2, 2, 3, 8, 6, 6, 7, 12 };
 979     int v_dist = fieldmv ? 1 : 4; // vertical offset for lower sub-blocks
 980     int v_edge_pos = s->v_edge_pos >> 1;
 981     int use_ic;
 982     uint8_t (*lutuv)[256];
 983
 984     if (s->flags & CODEC_FLAG_GRAY)
 985         return;
 986
 987     for (i = 0; i < 4; i++) {
 988         int d = i < 2 ? dir: dir2;
 989         tx = s->mv[d][i][0];
 990         uvmx_field[i] = (tx + ((tx & 3) == 3)) >> 1;
 991         ty = s->mv[d][i][1];
 992         if (fieldmv)
 993             uvmy_field[i] = (ty >> 4) * 8 + s_rndtblfield[ty & 0xF];
 994         else
 995             uvmy_field[i] = (ty + ((ty & 3) == 3)) >> 1;
 996     }
 997
 998     for (i = 0; i < 4; i++) {
 999         off = (i & 1) * 4 + ((i & 2) ? v_dist * s->uvlinesize : 0);
1000         uvsrc_x = s->mb_x * 8 +  (i & 1) * 4           + (uvmx_field[i] >> 2);
1001         uvsrc_y = s->mb_y * 8 + ((i & 2) ? v_dist : 0) + (uvmy_field[i] >> 2);
1002         // FIXME: implement proper pull-back (see vc1cropmv.c, vc1CROPMV_ChromaPullBack())
1003         uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width  >> 1);
1004         uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1005         if (i < 2 ? dir : dir2) {
1006             srcU = s->next_picture.f.data[1];
1007             srcV = s->next_picture.f.data[2];
1008             lutuv  = v->next_lutuv;
1009             use_ic = v->next_use_ic;
1010         } else {
1011             srcU = s->last_picture.f.data[1];
1012             srcV = s->last_picture.f.data[2];
1013             lutuv  = v->last_lutuv;
1014             use_ic = v->last_use_ic;
1015         }
1016         if (!srcU)
1017             return;
1018         srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1019         srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1020         uvmx_field[i] = (uvmx_field[i] & 3) << 1;
1021         uvmy_field[i] = (uvmy_field[i] & 3) << 1;
1022
1023         if (fieldmv && !(uvsrc_y & 1))
1024             v_edge_pos = (s->v_edge_pos >> 1) - 1;
1025
1026         if (fieldmv && (uvsrc_y & 1) && uvsrc_y < 2)
1027             uvsrc_y--;
1028         if (use_ic
1029             || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
1030             || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
1031             || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
1032             s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU,
1033                                      s->uvlinesize, s->uvlinesize,
1034                                      5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1035                                      s->h_edge_pos >> 1, v_edge_pos);
1036             s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV,
1037                                      s->uvlinesize, s->uvlinesize,
1038                                      5, (5 << fieldmv), uvsrc_x, uvsrc_y,
1039                                      s->h_edge_pos >> 1, v_edge_pos);
1040             srcU = s->edge_emu_buffer;
1041             srcV = s->edge_emu_buffer + 16;
1042
1043             /* if we deal with intensity compensation we need to scale source blocks */
1044             if (use_ic) {
1045                 int i, j;
1046                 uint8_t *src, *src2;
1047
1048                 src  = srcU;
1049                 src2 = srcV;
1050                 for (j = 0; j < 5; j++) {
1051                     int f = (uvsrc_y + (j << fieldmv)) & 1;
1052                     for (i = 0; i < 5; i++) {
1053                         src[i]  = lutuv[f][src[i]];
1054                         src2[i] = lutuv[f][src2[i]];
1055                     }
1056                     src  += s->uvlinesize << fieldmv;
1057                     src2 += s->uvlinesize << fieldmv;
1058                 }
1059             }
1060         }
1061         if (avg) {
1062             if (!v->rnd) {
1063                 h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1064                 h264chroma->avg_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1065             } else {
1066                 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1067                 v->vc1dsp.avg_no_rnd_vc1_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1068             }
1069         } else {
1070             if (!v->rnd) {
1071                 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[1] + off, srcU, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1072                 h264chroma->put_h264_chroma_pixels_tab[1](s->dest[2] + off, srcV, s->uvlinesize << fieldmv, 4, uvmx_field[i], uvmy_field[i]);
1073             } else {
1074                 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]);
1075                 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]);
1076             }
1077         }
1078     }
1079 }
1080
1081 /***********************************************************************/
1082 /**
1083  * @name VC-1 Block-level functions
1084  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1085  * @{
1086  */
1087
1088 /**
1089  * @def GET_MQUANT
1090  * @brief Get macroblock-level quantizer scale
1091  */
1092 #define GET_MQUANT()                                           \
1093     if (v->dquantfrm) {                                        \
1094         int edges = 0;                                         \
1095         if (v->dqprofile == DQPROFILE_ALL_MBS) {               \
1096             if (v->dqbilevel) {                                \
1097                 mquant = (get_bits1(gb)) ? v->altpq : v->pq;   \
1098             } else {                                           \
1099                 mqdiff = get_bits(gb, 3);                      \
1100                 if (mqdiff != 7)                               \
1101                     mquant = v->pq + mqdiff;                   \
1102                 else                                           \
1103                     mquant = get_bits(gb, 5);                  \
1104             }                                                  \
1105         }                                                      \
1106         if (v->dqprofile == DQPROFILE_SINGLE_EDGE)             \
1107             edges = 1 << v->dqsbedge;                          \
1108         else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES)       \
1109             edges = (3 << v->dqsbedge) % 15;                   \
1110         else if (v->dqprofile == DQPROFILE_FOUR_EDGES)         \
1111             edges = 15;                                        \
1112         if ((edges&1) && !s->mb_x)                             \
1113             mquant = v->altpq;                                 \
1114         if ((edges&2) && s->first_slice_line)                  \
1115             mquant = v->altpq;                                 \
1116         if ((edges&4) && s->mb_x == (s->mb_width - 1))         \
1117             mquant = v->altpq;                                 \
1118         if ((edges&8) && s->mb_y == (s->mb_height - 1))        \
1119             mquant = v->altpq;                                 \
1120         if (!mquant || mquant > 31) {                          \
1121             av_log(v->s.avctx, AV_LOG_ERROR,                   \
1122                    "Overriding invalid mquant %d\n", mquant);  \
1123             mquant = 1;                                        \
1124         }                                                      \
1125     }
1126
1127 /**
1128  * @def GET_MVDATA(_dmv_x, _dmv_y)
1129  * @brief Get MV differentials
1130  * @see MVDATA decoding from 8.3.5.2, p(1)20
1131  * @param _dmv_x Horizontal differential for decoded MV
1132  * @param _dmv_y Vertical differential for decoded MV
1133  */
1134 #define GET_MVDATA(_dmv_x, _dmv_y)                                      \
1135     index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table, \
1136                          VC1_MV_DIFF_VLC_BITS, 2);                      \
1137     if (index > 36) {                                                   \
1138         mb_has_coeffs = 1;                                              \
1139         index -= 37;                                                    \
1140     } else                                                              \
1141         mb_has_coeffs = 0;                                              \
1142     s->mb_intra = 0;                                                    \
1143     if (!index) {                                                       \
1144         _dmv_x = _dmv_y = 0;                                            \
1145     } else if (index == 35) {                                           \
1146         _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1147         _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1148     } else if (index == 36) {                                           \
1149         _dmv_x = 0;                                                     \
1150         _dmv_y = 0;                                                     \
1151         s->mb_intra = 1;                                                \
1152     } else {                                                            \
1153         index1 = index % 6;                                             \
1154         if (!s->quarter_sample && index1 == 5) val = 1;                 \
1155         else                                   val = 0;                 \
1156         if (size_table[index1] - val > 0)                               \
1157             val = get_bits(gb, size_table[index1] - val);               \
1158         else                                   val = 0;                 \
1159         sign = 0 - (val&1);                                             \
1160         _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1161                                                                         \
1162         index1 = index / 6;                                             \
1163         if (!s->quarter_sample && index1 == 5) val = 1;                 \
1164         else                                   val = 0;                 \
1165         if (size_table[index1] - val > 0)                               \
1166             val = get_bits(gb, size_table[index1] - val);               \
1167         else                                   val = 0;                 \
1168         sign = 0 - (val & 1);                                           \
1169         _dmv_y = (sign ^ ((val >> 1) + offset_table[index1])) - sign;   \
1170     }
1171
1172 static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x,
1173                                                    int *dmv_y, int *pred_flag)
1174 {
1175     int index, index1;
1176     int extend_x = 0, extend_y = 0;
1177     GetBitContext *gb = &v->s.gb;
1178     int bits, esc;
1179     int val, sign;
1180     const int* offs_tab;
1181
1182     if (v->numref) {
1183         bits = VC1_2REF_MVDATA_VLC_BITS;
1184         esc  = 125;
1185     } else {
1186         bits = VC1_1REF_MVDATA_VLC_BITS;
1187         esc  = 71;
1188     }
1189     switch (v->dmvrange) {
1190     case 1:
1191         extend_x = 1;
1192         break;
1193     case 2:
1194         extend_y = 1;
1195         break;
1196     case 3:
1197         extend_x = extend_y = 1;
1198         break;
1199     }
1200     index = get_vlc2(gb, v->imv_vlc->table, bits, 3);
1201     if (index == esc) {
1202         *dmv_x = get_bits(gb, v->k_x);
1203         *dmv_y = get_bits(gb, v->k_y);
1204         if (v->numref) {
1205             if (pred_flag) {
1206                 *pred_flag = *dmv_y & 1;
1207                 *dmv_y     = (*dmv_y + *pred_flag) >> 1;
1208             } else {
1209                 *dmv_y     = (*dmv_y + (*dmv_y & 1)) >> 1;
1210             }
1211         }
1212     }
1213     else {
1214         av_assert0(index < esc);
1215         if (extend_x)
1216             offs_tab = offset_table2;
1217         else
1218             offs_tab = offset_table1;
1219         index1 = (index + 1) % 9;
1220         if (index1 != 0) {
1221             val    = get_bits(gb, index1 + extend_x);
1222             sign   = 0 -(val & 1);
1223             *dmv_x = (sign ^ ((val >> 1) + offs_tab[index1])) - sign;
1224         } else
1225             *dmv_x = 0;
1226         if (extend_y)
1227             offs_tab = offset_table2;
1228         else
1229             offs_tab = offset_table1;
1230         index1 = (index + 1) / 9;
1231         if (index1 > v->numref) {
1232             val    = get_bits(gb, (index1 + (extend_y << v->numref)) >> v->numref);
1233             sign   = 0 - (val & 1);
1234             *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1235         } else
1236             *dmv_y = 0;
1237         if (v->numref && pred_flag)
1238             *pred_flag = index1 & 1;
1239     }
1240 }
1241
1242 static av_always_inline int scaleforsame_x(VC1Context *v, int n /* MV */, int dir)
1243 {
1244     int scaledvalue, refdist;
1245     int scalesame1, scalesame2;
1246     int scalezone1_x, zone1offset_x;
1247     int table_index = dir ^ v->second_field;
1248
1249     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1250         refdist = v->refdist;
1251     else
1252         refdist = dir ? v->brfd : v->frfd;
1253     if (refdist > 3)
1254         refdist = 3;
1255     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1256     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1257     scalezone1_x  = ff_vc1_field_mvpred_scales[table_index][3][refdist];
1258     zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1259
1260     if (FFABS(n) > 255)
1261         scaledvalue = n;
1262     else {
1263         if (FFABS(n) < scalezone1_x)
1264             scaledvalue = (n * scalesame1) >> 8;
1265         else {
1266             if (n < 0)
1267                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_x;
1268             else
1269                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_x;
1270         }
1271     }
1272     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1273 }
1274
1275 static av_always_inline int scaleforsame_y(VC1Context *v, int i, int n /* MV */, int dir)
1276 {
1277     int scaledvalue, refdist;
1278     int scalesame1, scalesame2;
1279     int scalezone1_y, zone1offset_y;
1280     int table_index = dir ^ v->second_field;
1281
1282     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1283         refdist = v->refdist;
1284     else
1285         refdist = dir ? v->brfd : v->frfd;
1286     if (refdist > 3)
1287         refdist = 3;
1288     scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
1289     scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
1290     scalezone1_y  = ff_vc1_field_mvpred_scales[table_index][4][refdist];
1291     zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1292
1293     if (FFABS(n) > 63)
1294         scaledvalue = n;
1295     else {
1296         if (FFABS(n) < scalezone1_y)
1297             scaledvalue = (n * scalesame1) >> 8;
1298         else {
1299             if (n < 0)
1300                 scaledvalue = ((n * scalesame2) >> 8) - zone1offset_y;
1301             else
1302                 scaledvalue = ((n * scalesame2) >> 8) + zone1offset_y;
1303         }
1304     }
1305
1306     if (v->cur_field_type && !v->ref_field_type[dir])
1307         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1308     else
1309         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1310 }
1311
1312 static av_always_inline int scaleforopp_x(VC1Context *v, int n /* MV */)
1313 {
1314     int scalezone1_x, zone1offset_x;
1315     int scaleopp1, scaleopp2, brfd;
1316     int scaledvalue;
1317
1318     brfd = FFMIN(v->brfd, 3);
1319     scalezone1_x  = ff_vc1_b_field_mvpred_scales[3][brfd];
1320     zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
1321     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
1322     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1323
1324     if (FFABS(n) > 255)
1325         scaledvalue = n;
1326     else {
1327         if (FFABS(n) < scalezone1_x)
1328             scaledvalue = (n * scaleopp1) >> 8;
1329         else {
1330             if (n < 0)
1331                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_x;
1332             else
1333                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_x;
1334         }
1335     }
1336     return av_clip(scaledvalue, -v->range_x, v->range_x - 1);
1337 }
1338
1339 static av_always_inline int scaleforopp_y(VC1Context *v, int n /* MV */, int dir)
1340 {
1341     int scalezone1_y, zone1offset_y;
1342     int scaleopp1, scaleopp2, brfd;
1343     int scaledvalue;
1344
1345     brfd = FFMIN(v->brfd, 3);
1346     scalezone1_y  = ff_vc1_b_field_mvpred_scales[4][brfd];
1347     zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
1348     scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
1349     scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1350
1351     if (FFABS(n) > 63)
1352         scaledvalue = n;
1353     else {
1354         if (FFABS(n) < scalezone1_y)
1355             scaledvalue = (n * scaleopp1) >> 8;
1356         else {
1357             if (n < 0)
1358                 scaledvalue = ((n * scaleopp2) >> 8) - zone1offset_y;
1359             else
1360                 scaledvalue = ((n * scaleopp2) >> 8) + zone1offset_y;
1361         }
1362     }
1363     if (v->cur_field_type && !v->ref_field_type[dir]) {
1364         return av_clip(scaledvalue, -v->range_y / 2 + 1, v->range_y / 2);
1365     } else {
1366         return av_clip(scaledvalue, -v->range_y / 2, v->range_y / 2 - 1);
1367     }
1368 }
1369
1370 static av_always_inline int scaleforsame(VC1Context *v, int i, int n /* MV */,
1371                                          int dim, int dir)
1372 {
1373     int brfd, scalesame;
1374     int hpel = 1 - v->s.quarter_sample;
1375
1376     n >>= hpel;
1377     if (v->s.pict_type != AV_PICTURE_TYPE_B || v->second_field || !dir) {
1378         if (dim)
1379             n = scaleforsame_y(v, i, n, dir) << hpel;
1380         else
1381             n = scaleforsame_x(v, n, dir) << hpel;
1382         return n;
1383     }
1384     brfd      = FFMIN(v->brfd, 3);
1385     scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1386
1387     n = (n * scalesame >> 8) << hpel;
1388     return n;
1389 }
1390
1391 static av_always_inline int scaleforopp(VC1Context *v, int n /* MV */,
1392                                         int dim, int dir)
1393 {
1394     int refdist, scaleopp;
1395     int hpel = 1 - v->s.quarter_sample;
1396
1397     n >>= hpel;
1398     if (v->s.pict_type == AV_PICTURE_TYPE_B && !v->second_field && dir == 1) {
1399         if (dim)
1400             n = scaleforopp_y(v, n, dir) << hpel;
1401         else
1402             n = scaleforopp_x(v, n) << hpel;
1403         return n;
1404     }
1405     if (v->s.pict_type != AV_PICTURE_TYPE_B)
1406         refdist = FFMIN(v->refdist, 3);
1407     else
1408         refdist = dir ? v->brfd : v->frfd;
1409     scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1410
1411     n = (n * scaleopp >> 8) << hpel;
1412     return n;
1413 }
1414
1415 /** Predict and set motion vector
1416  */
1417 static inline void vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
1418                                int mv1, int r_x, int r_y, uint8_t* is_intra,
1419                                int pred_flag, int dir)
1420 {
1421     MpegEncContext *s = &v->s;
1422     int xy, wrap, off = 0;
1423     int16_t *A, *B, *C;
1424     int px, py;
1425     int sum;
1426     int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1427     int opposite, a_f, b_f, c_f;
1428     int16_t field_predA[2];
1429     int16_t field_predB[2];
1430     int16_t field_predC[2];
1431     int a_valid, b_valid, c_valid;
1432     int hybridmv_thresh, y_bias = 0;
1433
1434     if (v->mv_mode == MV_PMODE_MIXED_MV ||
1435         ((v->mv_mode == MV_PMODE_INTENSITY_COMP) && (v->mv_mode2 == MV_PMODE_MIXED_MV)))
1436         mixedmv_pic = 1;
1437     else
1438         mixedmv_pic = 0;
1439     /* scale MV difference to be quad-pel */
1440     dmv_x <<= 1 - s->quarter_sample;
1441     dmv_y <<= 1 - s->quarter_sample;
1442
1443     wrap = s->b8_stride;
1444     xy   = s->block_index[n];
1445
1446     if (s->mb_intra) {
1447         s->mv[0][n][0] = s->current_picture.motion_val[0][xy + v->blocks_off][0] = 0;
1448         s->mv[0][n][1] = s->current_picture.motion_val[0][xy + v->blocks_off][1] = 0;
1449         s->current_picture.motion_val[1][xy + v->blocks_off][0] = 0;
1450         s->current_picture.motion_val[1][xy + v->blocks_off][1] = 0;
1451         if (mv1) { /* duplicate motion data for 1-MV block */
1452             s->current_picture.motion_val[0][xy + 1 + v->blocks_off][0]        = 0;
1453             s->current_picture.motion_val[0][xy + 1 + v->blocks_off][1]        = 0;
1454             s->current_picture.motion_val[0][xy + wrap + v->blocks_off][0]     = 0;
1455             s->current_picture.motion_val[0][xy + wrap + v->blocks_off][1]     = 0;
1456             s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][0] = 0;
1457             s->current_picture.motion_val[0][xy + wrap + 1 + v->blocks_off][1] = 0;
1458             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1459             s->current_picture.motion_val[1][xy + 1 + v->blocks_off][0]        = 0;
1460             s->current_picture.motion_val[1][xy + 1 + v->blocks_off][1]        = 0;
1461             s->current_picture.motion_val[1][xy + wrap][0]                     = 0;
1462             s->current_picture.motion_val[1][xy + wrap + v->blocks_off][1]     = 0;
1463             s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][0] = 0;
1464             s->current_picture.motion_val[1][xy + wrap + 1 + v->blocks_off][1] = 0;
1465         }
1466         return;
1467     }
1468
1469     C = s->current_picture.motion_val[dir][xy -    1 + v->blocks_off];
1470     A = s->current_picture.motion_val[dir][xy - wrap + v->blocks_off];
1471     if (mv1) {
1472         if (v->field_mode && mixedmv_pic)
1473             off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
1474         else
1475             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1476     } else {
1477         //in 4-MV mode different blocks have different B predictor position
1478         switch (n) {
1479         case 0:
1480             off = (s->mb_x > 0) ? -1 : 1;
1481             break;
1482         case 1:
1483             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1484             break;
1485         case 2:
1486             off = 1;
1487             break;
1488         case 3:
1489             off = -1;
1490         }
1491     }
1492     B = s->current_picture.motion_val[dir][xy - wrap + off + v->blocks_off];
1493
1494     a_valid = !s->first_slice_line || (n == 2 || n == 3);
1495     b_valid = a_valid && (s->mb_width > 1);
1496     c_valid = s->mb_x || (n == 1 || n == 3);
1497     if (v->field_mode) {
1498         a_valid = a_valid && !is_intra[xy - wrap];
1499         b_valid = b_valid && !is_intra[xy - wrap + off];
1500         c_valid = c_valid && !is_intra[xy - 1];
1501     }
1502
1503     if (a_valid) {
1504         a_f = v->mv_f[dir][xy - wrap + v->blocks_off];
1505         num_oppfield  += a_f;
1506         num_samefield += 1 - a_f;
1507         field_predA[0] = A[0];
1508         field_predA[1] = A[1];
1509     } else {
1510         field_predA[0] = field_predA[1] = 0;
1511         a_f = 0;
1512     }
1513     if (b_valid) {
1514         b_f = v->mv_f[dir][xy - wrap + off + v->blocks_off];
1515         num_oppfield  += b_f;
1516         num_samefield += 1 - b_f;
1517         field_predB[0] = B[0];
1518         field_predB[1] = B[1];
1519     } else {
1520         field_predB[0] = field_predB[1] = 0;
1521         b_f = 0;
1522     }
1523     if (c_valid) {
1524         c_f = v->mv_f[dir][xy - 1 + v->blocks_off];
1525         num_oppfield  += c_f;
1526         num_samefield += 1 - c_f;
1527         field_predC[0] = C[0];
1528         field_predC[1] = C[1];
1529     } else {
1530         field_predC[0] = field_predC[1] = 0;
1531         c_f = 0;
1532     }
1533
1534     if (v->field_mode) {
1535         if (!v->numref)
1536             // REFFIELD determines if the last field or the second-last field is
1537             // to be used as reference
1538             opposite = 1 - v->reffield;
1539         else {
1540             if (num_samefield <= num_oppfield)
1541                 opposite = 1 - pred_flag;
1542             else
1543                 opposite = pred_flag;
1544         }
1545     } else
1546         opposite = 0;
1547     if (opposite) {
1548         if (a_valid && !a_f) {
1549             field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1550             field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1551         }
1552         if (b_valid && !b_f) {
1553             field_predB[0] = scaleforopp(v, field_predB[0], 0, dir);
1554             field_predB[1] = scaleforopp(v, field_predB[1], 1, dir);
1555         }
1556         if (c_valid && !c_f) {
1557             field_predC[0] = scaleforopp(v, field_predC[0], 0, dir);
1558             field_predC[1] = scaleforopp(v, field_predC[1], 1, dir);
1559         }
1560         v->mv_f[dir][xy + v->blocks_off] = 1;
1561         v->ref_field_type[dir] = !v->cur_field_type;
1562     } else {
1563         if (a_valid && a_f) {
1564             field_predA[0] = scaleforsame(v, n, field_predA[0], 0, dir);
1565             field_predA[1] = scaleforsame(v, n, field_predA[1], 1, dir);
1566         }
1567         if (b_valid && b_f) {
1568             field_predB[0] = scaleforsame(v, n, field_predB[0], 0, dir);
1569             field_predB[1] = scaleforsame(v, n, field_predB[1], 1, dir);
1570         }
1571         if (c_valid && c_f) {
1572             field_predC[0] = scaleforsame(v, n, field_predC[0], 0, dir);
1573             field_predC[1] = scaleforsame(v, n, field_predC[1], 1, dir);
1574         }
1575         v->mv_f[dir][xy + v->blocks_off] = 0;
1576         v->ref_field_type[dir] = v->cur_field_type;
1577     }
1578
1579     if (a_valid) {
1580         px = field_predA[0];
1581         py = field_predA[1];
1582     } else if (c_valid) {
1583         px = field_predC[0];
1584         py = field_predC[1];
1585     } else if (b_valid) {
1586         px = field_predB[0];
1587         py = field_predB[1];
1588     } else {
1589         px = 0;
1590         py = 0;
1591     }
1592
1593     if (num_samefield + num_oppfield > 1) {
1594         px = mid_pred(field_predA[0], field_predB[0], field_predC[0]);
1595         py = mid_pred(field_predA[1], field_predB[1], field_predC[1]);
1596     }
1597
1598     /* Pullback MV as specified in 8.3.5.3.4 */
1599     if (!v->field_mode) {
1600         int qx, qy, X, Y;
1601         qx = (s->mb_x << 6) + ((n == 1 || n == 3) ? 32 : 0);
1602         qy = (s->mb_y << 6) + ((n == 2 || n == 3) ? 32 : 0);
1603         X  = (s->mb_width  << 6) - 4;
1604         Y  = (s->mb_height << 6) - 4;
1605         if (mv1) {
1606             if (qx + px < -60) px = -60 - qx;
1607             if (qy + py < -60) py = -60 - qy;
1608         } else {
1609             if (qx + px < -28) px = -28 - qx;
1610             if (qy + py < -28) py = -28 - qy;
1611         }
1612         if (qx + px > X) px = X - qx;
1613         if (qy + py > Y) py = Y - qy;
1614     }
1615
1616     if (!v->field_mode || s->pict_type != AV_PICTURE_TYPE_B) {
1617         /* Calculate hybrid prediction as specified in 8.3.5.3.5 (also 10.3.5.4.3.5) */
1618         hybridmv_thresh = 32;
1619         if (a_valid && c_valid) {
1620             if (is_intra[xy - wrap])
1621                 sum = FFABS(px) + FFABS(py);
1622             else
1623                 sum = FFABS(px - field_predA[0]) + FFABS(py - field_predA[1]);
1624             if (sum > hybridmv_thresh) {
1625                 if (get_bits1(&s->gb)) {     // read HYBRIDPRED bit
1626                     px = field_predA[0];
1627                     py = field_predA[1];
1628                 } else {
1629                     px = field_predC[0];
1630                     py = field_predC[1];
1631                 }
1632             } else {
1633                 if (is_intra[xy - 1])
1634                     sum = FFABS(px) + FFABS(py);
1635                 else
1636                     sum = FFABS(px - field_predC[0]) + FFABS(py - field_predC[1]);
1637                 if (sum > hybridmv_thresh) {
1638                     if (get_bits1(&s->gb)) {
1639                         px = field_predA[0];
1640                         py = field_predA[1];
1641                     } else {
1642                         px = field_predC[0];
1643                         py = field_predC[1];
1644                     }
1645                 }
1646             }
1647         }
1648     }
1649
1650     if (v->field_mode && v->numref)
1651         r_y >>= 1;
1652     if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1653         y_bias = 1;
1654     /* store MV using signed modulus of MV range defined in 4.11 */
1655     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;
1656     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;
1657     if (mv1) { /* duplicate motion data for 1-MV block */
1658         s->current_picture.motion_val[dir][xy +    1 +     v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1659         s->current_picture.motion_val[dir][xy +    1 +     v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1660         s->current_picture.motion_val[dir][xy + wrap +     v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1661         s->current_picture.motion_val[dir][xy + wrap +     v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1662         s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][0] = s->current_picture.motion_val[dir][xy + v->blocks_off][0];
1663         s->current_picture.motion_val[dir][xy + wrap + 1 + v->blocks_off][1] = s->current_picture.motion_val[dir][xy + v->blocks_off][1];
1664         v->mv_f[dir][xy +    1 + v->blocks_off] = v->mv_f[dir][xy +            v->blocks_off];
1665         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];
1666     }
1667 }
1668
1669 /** Predict and set motion vector for interlaced frame picture MBs
1670  */
1671 static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
1672                                      int mvn, int r_x, int r_y, uint8_t* is_intra, int dir)
1673 {
1674     MpegEncContext *s = &v->s;
1675     int xy, wrap, off = 0;
1676     int A[2], B[2], C[2];
1677     int px = 0, py = 0;
1678     int a_valid = 0, b_valid = 0, c_valid = 0;
1679     int field_a, field_b, field_c; // 0: same, 1: opposit
1680     int total_valid, num_samefield, num_oppfield;
1681     int pos_c, pos_b, n_adj;
1682
1683     wrap = s->b8_stride;
1684     xy = s->block_index[n];
1685
1686     if (s->mb_intra) {
1687         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1688         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1689         s->current_picture.motion_val[1][xy][0] = 0;
1690         s->current_picture.motion_val[1][xy][1] = 0;
1691         if (mvn == 1) { /* duplicate motion data for 1-MV block */
1692             s->current_picture.motion_val[0][xy + 1][0]        = 0;
1693             s->current_picture.motion_val[0][xy + 1][1]        = 0;
1694             s->current_picture.motion_val[0][xy + wrap][0]     = 0;
1695             s->current_picture.motion_val[0][xy + wrap][1]     = 0;
1696             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1697             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1698             v->luma_mv[s->mb_x][0] = v->luma_mv[s->mb_x][1] = 0;
1699             s->current_picture.motion_val[1][xy + 1][0]        = 0;
1700             s->current_picture.motion_val[1][xy + 1][1]        = 0;
1701             s->current_picture.motion_val[1][xy + wrap][0]     = 0;
1702             s->current_picture.motion_val[1][xy + wrap][1]     = 0;
1703             s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
1704             s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
1705         }
1706         return;
1707     }
1708
1709     off = ((n == 0) || (n == 1)) ? 1 : -1;
1710     /* predict A */
1711     if (s->mb_x || (n == 1) || (n == 3)) {
1712         if ((v->blk_mv_type[xy]) // current block (MB) has a field MV
1713             || (!v->blk_mv_type[xy] && !v->blk_mv_type[xy - 1])) { // or both have frame MV
1714             A[0] = s->current_picture.motion_val[dir][xy - 1][0];
1715             A[1] = s->current_picture.motion_val[dir][xy - 1][1];
1716             a_valid = 1;
1717         } else { // current block has frame mv and cand. has field MV (so average)
1718             A[0] = (s->current_picture.motion_val[dir][xy - 1][0]
1719                     + s->current_picture.motion_val[dir][xy - 1 + off * wrap][0] + 1) >> 1;
1720             A[1] = (s->current_picture.motion_val[dir][xy - 1][1]
1721                     + s->current_picture.motion_val[dir][xy - 1 + off * wrap][1] + 1) >> 1;
1722             a_valid = 1;
1723         }
1724         if (!(n & 1) && v->is_intra[s->mb_x - 1]) {
1725             a_valid = 0;
1726             A[0] = A[1] = 0;
1727         }
1728     } else
1729         A[0] = A[1] = 0;
1730     /* Predict B and C */
1731     B[0] = B[1] = C[0] = C[1] = 0;
1732     if (n == 0 || n == 1 || v->blk_mv_type[xy]) {
1733         if (!s->first_slice_line) {
1734             if (!v->is_intra[s->mb_x - s->mb_stride]) {
1735                 b_valid = 1;
1736                 n_adj   = n | 2;
1737                 pos_b   = s->block_index[n_adj] - 2 * wrap;
1738                 if (v->blk_mv_type[pos_b] && v->blk_mv_type[xy]) {
1739                     n_adj = (n & 2) | (n & 1);
1740                 }
1741                 B[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][0];
1742                 B[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap][1];
1743                 if (v->blk_mv_type[pos_b] && !v->blk_mv_type[xy]) {
1744                     B[0] = (B[0] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][0] + 1) >> 1;
1745                     B[1] = (B[1] + s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap][1] + 1) >> 1;
1746                 }
1747             }
1748             if (s->mb_width > 1) {
1749                 if (!v->is_intra[s->mb_x - s->mb_stride + 1]) {
1750                     c_valid = 1;
1751                     n_adj   = 2;
1752                     pos_c   = s->block_index[2] - 2 * wrap + 2;
1753                     if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1754                         n_adj = n & 2;
1755                     }
1756                     C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][0];
1757                     C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap + 2][1];
1758                     if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1759                         C[0] = (1 + C[0] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][0])) >> 1;
1760                         C[1] = (1 + C[1] + (s->current_picture.motion_val[dir][s->block_index[n_adj ^ 2] - 2 * wrap + 2][1])) >> 1;
1761                     }
1762                     if (s->mb_x == s->mb_width - 1) {
1763                         if (!v->is_intra[s->mb_x - s->mb_stride - 1]) {
1764                             c_valid = 1;
1765                             n_adj   = 3;
1766                             pos_c   = s->block_index[3] - 2 * wrap - 2;
1767                             if (v->blk_mv_type[pos_c] && v->blk_mv_type[xy]) {
1768                                 n_adj = n | 1;
1769                             }
1770                             C[0] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][0];
1771                             C[1] = s->current_picture.motion_val[dir][s->block_index[n_adj] - 2 * wrap - 2][1];
1772                             if (v->blk_mv_type[pos_c] && !v->blk_mv_type[xy]) {
1773                                 C[0] = (1 + C[0] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][0]) >> 1;
1774                                 C[1] = (1 + C[1] + s->current_picture.motion_val[dir][s->block_index[1] - 2 * wrap - 2][1]) >> 1;
1775                             }
1776                         } else
1777                             c_valid = 0;
1778                     }
1779                 }
1780             }
1781         }
1782     } else {
1783         pos_b   = s->block_index[1];
1784         b_valid = 1;
1785         B[0]    = s->current_picture.motion_val[dir][pos_b][0];
1786         B[1]    = s->current_picture.motion_val[dir][pos_b][1];
1787         pos_c   = s->block_index[0];
1788         c_valid = 1;
1789         C[0]    = s->current_picture.motion_val[dir][pos_c][0];
1790         C[1]    = s->current_picture.motion_val[dir][pos_c][1];
1791     }
1792
1793     total_valid = a_valid + b_valid + c_valid;
1794     // check if predictor A is out of bounds
1795     if (!s->mb_x && !(n == 1 || n == 3)) {
1796         A[0] = A[1] = 0;
1797     }
1798     // check if predictor B is out of bounds
1799     if ((s->first_slice_line && v->blk_mv_type[xy]) || (s->first_slice_line && !(n & 2))) {
1800         B[0] = B[1] = C[0] = C[1] = 0;
1801     }
1802     if (!v->blk_mv_type[xy]) {
1803         if (s->mb_width == 1) {
1804             px = B[0];
1805             py = B[1];
1806         } else {
1807             if (total_valid >= 2) {
1808                 px = mid_pred(A[0], B[0], C[0]);
1809                 py = mid_pred(A[1], B[1], C[1]);
1810             } else if (total_valid) {
1811                 if      (a_valid) { px = A[0]; py = A[1]; }
1812                 else if (b_valid) { px = B[0]; py = B[1]; }
1813                 else              { px = C[0]; py = C[1]; }
1814             }
1815         }
1816     } else {
1817         if (a_valid)
1818             field_a = (A[1] & 4) ? 1 : 0;
1819         else
1820             field_a = 0;
1821         if (b_valid)
1822             field_b = (B[1] & 4) ? 1 : 0;
1823         else
1824             field_b = 0;
1825         if (c_valid)
1826             field_c = (C[1] & 4) ? 1 : 0;
1827         else
1828             field_c = 0;
1829
1830         num_oppfield  = field_a + field_b + field_c;
1831         num_samefield = total_valid - num_oppfield;
1832         if (total_valid == 3) {
1833             if ((num_samefield == 3) || (num_oppfield == 3)) {
1834                 px = mid_pred(A[0], B[0], C[0]);
1835                 py = mid_pred(A[1], B[1], C[1]);
1836             } else if (num_samefield >= num_oppfield) {
1837                 /* take one MV from same field set depending on priority
1838                 the check for B may not be necessary */
1839                 px = !field_a ? A[0] : B[0];
1840                 py = !field_a ? A[1] : B[1];
1841             } else {
1842                 px =  field_a ? A[0] : B[0];
1843                 py =  field_a ? A[1] : B[1];
1844             }
1845         } else if (total_valid == 2) {
1846             if (num_samefield >= num_oppfield) {
1847                 if (!field_a && a_valid) {
1848                     px = A[0];
1849                     py = A[1];
1850                 } else if (!field_b && b_valid) {
1851                     px = B[0];
1852                     py = B[1];
1853                 } else /*if (c_valid)*/ {
1854                     av_assert1(c_valid);
1855                     px = C[0];
1856                     py = C[1];
1857                 } /*else px = py = 0;*/
1858             } else {
1859                 if (field_a && a_valid) {
1860                     px = A[0];
1861                     py = A[1];
1862                 } else /*if (field_b && b_valid)*/ {
1863                     av_assert1(field_b && b_valid);
1864                     px = B[0];
1865                     py = B[1];
1866                 } /*else if (c_valid) {
1867                     px = C[0];
1868                     py = C[1];
1869                 }*/
1870             }
1871         } else if (total_valid == 1) {
1872             px = (a_valid) ? A[0] : ((b_valid) ? B[0] : C[0]);
1873             py = (a_valid) ? A[1] : ((b_valid) ? B[1] : C[1]);
1874         }
1875     }
1876
1877     /* store MV using signed modulus of MV range defined in 4.11 */
1878     s->mv[dir][n][0] = s->current_picture.motion_val[dir][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1879     s->mv[dir][n][1] = s->current_picture.motion_val[dir][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1880     if (mvn == 1) { /* duplicate motion data for 1-MV block */
1881         s->current_picture.motion_val[dir][xy +    1    ][0] = s->current_picture.motion_val[dir][xy][0];
1882         s->current_picture.motion_val[dir][xy +    1    ][1] = s->current_picture.motion_val[dir][xy][1];
1883         s->current_picture.motion_val[dir][xy + wrap    ][0] = s->current_picture.motion_val[dir][xy][0];
1884         s->current_picture.motion_val[dir][xy + wrap    ][1] = s->current_picture.motion_val[dir][xy][1];
1885         s->current_picture.motion_val[dir][xy + wrap + 1][0] = s->current_picture.motion_val[dir][xy][0];
1886         s->current_picture.motion_val[dir][xy + wrap + 1][1] = s->current_picture.motion_val[dir][xy][1];
1887     } else if (mvn == 2) { /* duplicate motion data for 2-Field MV block */
1888         s->current_picture.motion_val[dir][xy + 1][0] = s->current_picture.motion_val[dir][xy][0];
1889         s->current_picture.motion_val[dir][xy + 1][1] = s->current_picture.motion_val[dir][xy][1];
1890         s->mv[dir][n + 1][0] = s->mv[dir][n][0];
1891         s->mv[dir][n + 1][1] = s->mv[dir][n][1];
1892     }
1893 }
1894
1895 /** Motion compensation for direct or interpolated blocks in B-frames
1896  */
1897 static void vc1_interp_mc(VC1Context *v)
1898 {
1899     MpegEncContext *s = &v->s;
1900     H264ChromaContext *h264chroma = &v->h264chroma;
1901     uint8_t *srcY, *srcU, *srcV;
1902     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1903     int off, off_uv;
1904     int v_edge_pos = s->v_edge_pos >> v->field_mode;
1905     int use_ic = v->next_use_ic;
1906
1907     if (!v->field_mode && !v->s.next_picture.f.data[0])
1908         return;
1909
1910     mx   = s->mv[1][0][0];
1911     my   = s->mv[1][0][1];
1912     uvmx = (mx + ((mx & 3) == 3)) >> 1;
1913     uvmy = (my + ((my & 3) == 3)) >> 1;
1914     if (v->field_mode) {
1915         if (v->cur_field_type != v->ref_field_type[1])
1916             my   = my   - 2 + 4 * v->cur_field_type;
1917             uvmy = uvmy - 2 + 4 * v->cur_field_type;
1918     }
1919     if (v->fastuvmc) {
1920         uvmx = uvmx + ((uvmx < 0) ? -(uvmx & 1) : (uvmx & 1));
1921         uvmy = uvmy + ((uvmy < 0) ? -(uvmy & 1) : (uvmy & 1));
1922     }
1923     srcY = s->next_picture.f.data[0];
1924     srcU = s->next_picture.f.data[1];
1925     srcV = s->next_picture.f.data[2];
1926
1927     src_x   = s->mb_x * 16 + (mx   >> 2);
1928     src_y   = s->mb_y * 16 + (my   >> 2);
1929     uvsrc_x = s->mb_x *  8 + (uvmx >> 2);
1930     uvsrc_y = s->mb_y *  8 + (uvmy >> 2);
1931
1932     if (v->profile != PROFILE_ADVANCED) {
1933         src_x   = av_clip(  src_x, -16, s->mb_width  * 16);
1934         src_y   = av_clip(  src_y, -16, s->mb_height * 16);
1935         uvsrc_x = av_clip(uvsrc_x,  -8, s->mb_width  *  8);
1936         uvsrc_y = av_clip(uvsrc_y,  -8, s->mb_height *  8);
1937     } else {
1938         src_x   = av_clip(  src_x, -17, s->avctx->coded_width);
1939         src_y   = av_clip(  src_y, -18, s->avctx->coded_height + 1);
1940         uvsrc_x = av_clip(uvsrc_x,  -8, s->avctx->coded_width  >> 1);
1941         uvsrc_y = av_clip(uvsrc_y,  -8, s->avctx->coded_height >> 1);
1942     }
1943
1944     srcY += src_y   * s->linesize   + src_x;
1945     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1946     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1947
1948     if (v->field_mode && v->ref_field_type[1]) {
1949         srcY += s->current_picture_ptr->f.linesize[0];
1950         srcU += s->current_picture_ptr->f.linesize[1];
1951         srcV += s->current_picture_ptr->f.linesize[2];
1952     }
1953
1954     /* for grayscale we should not try to read from unknown area */
1955     if (s->flags & CODEC_FLAG_GRAY) {
1956         srcU = s->edge_emu_buffer + 18 * s->linesize;
1957         srcV = s->edge_emu_buffer + 18 * s->linesize;
1958     }
1959
1960     if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22 || use_ic
1961         || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
1962         || (unsigned)(src_y - 1) > v_edge_pos    - (my & 3) - 16 - 3) {
1963         uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1964
1965         srcY -= s->mspel * (1 + s->linesize);
1966         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY,
1967                                  s->linesize, s->linesize,
1968                                  17 + s->mspel * 2, 17 + s->mspel * 2,
1969                                  src_x - s->mspel, src_y - s->mspel,
1970                                  s->h_edge_pos, v_edge_pos);
1971         srcY = s->edge_emu_buffer;
1972         s->vdsp.emulated_edge_mc(uvbuf, srcU,
1973                                  s->uvlinesize, s->uvlinesize,
1974                                  8 + 1, 8 + 1,
1975                                  uvsrc_x, uvsrc_y,
1976                                  s->h_edge_pos >> 1, v_edge_pos >> 1);
1977         s->vdsp.emulated_edge_mc(uvbuf + 16, srcV,
1978                                  s->uvlinesize, s->uvlinesize,
1979                                  8 + 1, 8 + 1,
1980                                  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 int 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 AVERROR_INVALIDDATA;
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         return AVERROR_INVALIDDATA;
5341     }
5342     if (get_bits_count(gb) < gb->size_in_bits - 8)
5343         av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
5344
5345     return 0;
5346 }
5347
5348 static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
5349 {
5350     int i, plane, row, sprite;
5351     int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
5352     uint8_t* src_h[2][2];
5353     int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
5354     int ysub[2];
5355     MpegEncContext *s = &v->s;
5356
5357     for (i = 0; i <= v->two_sprites; i++) {
5358         xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
5359         xadv[i] = sd->coefs[i][0];
5360         if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
5361             xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
5362
5363         yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
5364         yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
5365     }
5366     alpha = av_clip(sd->coefs[1][6], 0, (1<<16) - 1);
5367
5368     for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++) {
5369         int width = v->output_width>>!!plane;
5370
5371         for (row = 0; row < v->output_height>>!!plane; row++) {
5372             uint8_t *dst = v->sprite_output_frame->data[plane] +
5373                            v->sprite_output_frame->linesize[plane] * row;
5374
5375             for (sprite = 0; sprite <= v->two_sprites; sprite++) {
5376                 uint8_t *iplane = s->current_picture.f.data[plane];
5377                 int      iline  = s->current_picture.f.linesize[plane];
5378                 int      ycoord = yoff[sprite] + yadv[sprite] * row;
5379                 int      yline  = ycoord >> 16;
5380                 int      next_line;
5381                 ysub[sprite] = ycoord & 0xFFFF;
5382                 if (sprite) {
5383                     iplane = s->last_picture.f.data[plane];
5384                     iline  = s->last_picture.f.linesize[plane];
5385                 }
5386                 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
5387                 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
5388                         src_h[sprite][0] = iplane + (xoff[sprite] >> 16) +  yline      * iline;
5389                     if (ysub[sprite])
5390                         src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
5391                 } else {
5392                     if (sr_cache[sprite][0] != yline) {
5393                         if (sr_cache[sprite][1] == yline) {
5394                             FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
5395                             FFSWAP(int,        sr_cache[sprite][0],   sr_cache[sprite][1]);
5396                         } else {
5397                             v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
5398                             sr_cache[sprite][0] = yline;
5399                         }
5400                     }
5401                     if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
5402                         v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
5403                                            iplane + next_line, xoff[sprite],
5404                                            xadv[sprite], width);
5405                         sr_cache[sprite][1] = yline + 1;
5406                     }
5407                     src_h[sprite][0] = v->sr_rows[sprite][0];
5408                     src_h[sprite][1] = v->sr_rows[sprite][1];
5409                 }
5410             }
5411
5412             if (!v->two_sprites) {
5413                 if (ysub[0]) {
5414                     v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
5415                 } else {
5416                     memcpy(dst, src_h[0][0], width);
5417                 }
5418             } else {
5419                 if (ysub[0] && ysub[1]) {
5420                     v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
5421                                                        src_h[1][0], src_h[1][1], ysub[1], alpha, width);
5422                 } else if (ysub[0]) {
5423                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
5424                                                        src_h[1][0], alpha, width);
5425                 } else if (ysub[1]) {
5426                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
5427                                                        src_h[0][0], (1<<16)-1-alpha, width);
5428                 } else {
5429                     v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
5430                 }
5431             }
5432         }
5433
5434         if (!plane) {
5435             for (i = 0; i <= v->two_sprites; i++) {
5436                 xoff[i] >>= 1;
5437                 yoff[i] >>= 1;
5438             }
5439         }
5440
5441     }
5442 }
5443
5444
5445 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
5446 {
5447     int ret;
5448     MpegEncContext *s     = &v->s;
5449     AVCodecContext *avctx = s->avctx;
5450     SpriteData sd;
5451
5452     memset(&sd, 0, sizeof(sd));
5453
5454     ret = vc1_parse_sprites(v, gb, &sd);
5455     if (ret < 0)
5456         return ret;
5457
5458     if (!s->current_picture.f.data[0]) {
5459         av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
5460         return -1;
5461     }
5462
5463     if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f.data[0])) {
5464         av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
5465         v->two_sprites = 0;
5466     }
5467
5468     av_frame_unref(v->sprite_output_frame);
5469     if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
5470         return ret;
5471
5472     vc1_draw_sprites(v, &sd);
5473
5474     return 0;
5475 }
5476
5477 static void vc1_sprite_flush(AVCodecContext *avctx)
5478 {
5479     VC1Context *v     = avctx->priv_data;
5480     MpegEncContext *s = &v->s;
5481     AVFrame *f = &s->current_picture.f;
5482     int plane, i;
5483
5484     /* Windows Media Image codecs have a convergence interval of two keyframes.
5485        Since we can't enforce it, clear to black the missing sprite. This is
5486        wrong but it looks better than doing nothing. */
5487
5488     if (f->data[0])
5489         for (plane = 0; plane < (s->flags&CODEC_FLAG_GRAY ? 1 : 3); plane++)
5490             for (i = 0; i < v->sprite_height>>!!plane; i++)
5491                 memset(f->data[plane] + i * f->linesize[plane],
5492                        plane ? 128 : 0, f->linesize[plane]);
5493 }
5494
5495 #endif
5496
5497 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5498 {
5499     MpegEncContext *s = &v->s;
5500     int i;
5501     int mb_height = FFALIGN(s->mb_height, 2);
5502
5503     /* Allocate mb bitplanes */
5504     v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
5505     v->direct_mb_plane  = av_malloc (s->mb_stride * mb_height);
5506     v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
5507     v->fieldtx_plane    = av_mallocz(s->mb_stride * mb_height);
5508     v->acpred_plane     = av_malloc (s->mb_stride * mb_height);
5509     v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
5510
5511     v->n_allocated_blks = s->mb_width + 2;
5512     v->block            = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
5513     v->cbp_base         = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
5514     v->cbp              = v->cbp_base + s->mb_stride;
5515     v->ttblk_base       = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
5516     v->ttblk            = v->ttblk_base + s->mb_stride;
5517     v->is_intra_base    = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
5518     v->is_intra         = v->is_intra_base + s->mb_stride;
5519     v->luma_mv_base     = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
5520     v->luma_mv          = v->luma_mv_base + s->mb_stride;
5521
5522     /* allocate block type info in that way so it could be used with s->block_index[] */
5523     v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5524     v->mb_type[0]   = v->mb_type_base + s->b8_stride + 1;
5525     v->mb_type[1]   = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
5526     v->mb_type[2]   = v->mb_type[1] + s->mb_stride * (mb_height + 1);
5527
5528     /* allocate memory to store block level MV info */
5529     v->blk_mv_type_base = av_mallocz(     s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5530     v->blk_mv_type      = v->blk_mv_type_base + s->b8_stride + 1;
5531     v->mv_f_base        = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
5532     v->mv_f[0]          = v->mv_f_base + s->b8_stride + 1;
5533     v->mv_f[1]          = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5534     v->mv_f_next_base   = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
5535     v->mv_f_next[0]     = v->mv_f_next_base + s->b8_stride + 1;
5536     v->mv_f_next[1]     = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
5537
5538     /* Init coded blocks info */
5539     if (v->profile == PROFILE_ADVANCED) {
5540 //        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
5541 //            return -1;
5542 //        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
5543 //            return -1;
5544     }
5545
5546     ff_intrax8_common_init(&v->x8,s);
5547
5548     if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5549         for (i = 0; i < 4; i++)
5550             if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
5551                 return AVERROR(ENOMEM);
5552     }
5553
5554     if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
5555         !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
5556         !v->mb_type_base) {
5557         av_freep(&v->mv_type_mb_plane);
5558         av_freep(&v->direct_mb_plane);
5559         av_freep(&v->acpred_plane);
5560         av_freep(&v->over_flags_plane);
5561         av_freep(&v->block);
5562         av_freep(&v->cbp_base);
5563         av_freep(&v->ttblk_base);
5564         av_freep(&v->is_intra_base);
5565         av_freep(&v->luma_mv_base);
5566         av_freep(&v->mb_type_base);
5567         return AVERROR(ENOMEM);
5568     }
5569
5570     return 0;
5571 }
5572
5573 av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
5574 {
5575     int i;
5576     for (i = 0; i < 64; i++) {
5577 #define transpose(x) ((x >> 3) | ((x & 7) << 3))
5578         v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
5579         v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
5580         v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
5581         v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
5582         v->zzi_8x8[i]   = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5583     }
5584     v->left_blk_sh = 0;
5585     v->top_blk_sh  = 3;
5586 }
5587
5588 /** Initialize a VC1/WMV3 decoder
5589  * @todo TODO: Handle VC-1 IDUs (Transport level?)
5590  * @todo TODO: Decypher remaining bits in extra_data
5591  */
5592 static av_cold int vc1_decode_init(AVCodecContext *avctx)
5593 {
5594     VC1Context *v = avctx->priv_data;
5595     MpegEncContext *s = &v->s;
5596     GetBitContext gb;
5597     int ret;
5598
5599     /* save the container output size for WMImage */
5600     v->output_width  = avctx->width;
5601     v->output_height = avctx->height;
5602
5603     if (!avctx->extradata_size || !avctx->extradata)
5604         return -1;
5605     if (!(avctx->flags & CODEC_FLAG_GRAY))
5606         avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5607     else
5608         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5609     avctx->hwaccel = ff_find_hwaccel(avctx);
5610     v->s.avctx = avctx;
5611     avctx->flags |= CODEC_FLAG_EMU_EDGE;
5612     v->s.flags   |= CODEC_FLAG_EMU_EDGE;
5613
5614     if ((ret = ff_vc1_init_common(v)) < 0)
5615         return ret;
5616     // ensure static VLC tables are initialized
5617     if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
5618         return ret;
5619     if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
5620         return ret;
5621     // Hack to ensure the above functions will be called
5622     // again once we know all necessary settings.
5623     // That this is necessary might indicate a bug.
5624     ff_vc1_decode_end(avctx);
5625
5626     ff_h264chroma_init(&v->h264chroma, 8);
5627     ff_vc1dsp_init(&v->vc1dsp);
5628
5629     if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5630         int count = 0;
5631
5632         // looks like WMV3 has a sequence header stored in the extradata
5633         // advanced sequence header may be before the first frame
5634         // the last byte of the extradata is a version number, 1 for the
5635         // samples we can decode
5636
5637         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5638
5639         if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
5640           return ret;
5641
5642         count = avctx->extradata_size*8 - get_bits_count(&gb);
5643         if (count > 0) {
5644             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
5645                    count, get_bits(&gb, count));
5646         } else if (count < 0) {
5647             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
5648         }
5649     } else { // VC1/WVC1/WVP2
5650         const uint8_t *start = avctx->extradata;
5651         uint8_t *end = avctx->extradata + avctx->extradata_size;
5652         const uint8_t *next;
5653         int size, buf2_size;
5654         uint8_t *buf2 = NULL;
5655         int seq_initialized = 0, ep_initialized = 0;
5656
5657         if (avctx->extradata_size < 16) {
5658             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
5659             return -1;
5660         }
5661
5662         buf2  = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
5663         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
5664         next  = start;
5665         for (; next < end; start = next) {
5666             next = find_next_marker(start + 4, end);
5667             size = next - start - 4;
5668             if (size <= 0)
5669                 continue;
5670             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
5671             init_get_bits(&gb, buf2, buf2_size * 8);
5672             switch (AV_RB32(start)) {
5673             case VC1_CODE_SEQHDR:
5674                 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
5675                     av_free(buf2);
5676                     return ret;
5677                 }
5678                 seq_initialized = 1;
5679                 break;
5680             case VC1_CODE_ENTRYPOINT:
5681                 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
5682                     av_free(buf2);
5683                     return ret;
5684                 }
5685                 ep_initialized = 1;
5686                 break;
5687             }
5688         }
5689         av_free(buf2);
5690         if (!seq_initialized || !ep_initialized) {
5691             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
5692             return -1;
5693         }
5694         v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
5695     }
5696
5697     v->sprite_output_frame = av_frame_alloc();
5698     if (!v->sprite_output_frame)
5699         return AVERROR(ENOMEM);
5700
5701     avctx->profile = v->profile;
5702     if (v->profile == PROFILE_ADVANCED)
5703         avctx->level = v->level;
5704
5705     avctx->has_b_frames = !!avctx->max_b_frames;
5706
5707     s->mb_width  = (avctx->coded_width  + 15) >> 4;
5708     s->mb_height = (avctx->coded_height + 15) >> 4;
5709
5710     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5711         ff_vc1_init_transposed_scantables(v);
5712     } else {
5713         memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5714         v->left_blk_sh = 3;
5715         v->top_blk_sh  = 0;
5716     }
5717
5718     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5719         v->sprite_width  = avctx->coded_width;
5720         v->sprite_height = avctx->coded_height;
5721
5722         avctx->coded_width  = avctx->width  = v->output_width;
5723         avctx->coded_height = avctx->height = v->output_height;
5724
5725         // prevent 16.16 overflows
5726         if (v->sprite_width  > 1 << 14 ||
5727             v->sprite_height > 1 << 14 ||
5728             v->output_width  > 1 << 14 ||
5729             v->output_height > 1 << 14) return -1;
5730
5731         if ((v->sprite_width&1) || (v->sprite_height&1)) {
5732             avpriv_request_sample(avctx, "odd sprites support");
5733             return AVERROR_PATCHWELCOME;
5734         }
5735     }
5736     return 0;
5737 }
5738
5739 /** Close a VC1/WMV3 decoder
5740  * @warning Initial try at using MpegEncContext stuff
5741  */
5742 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5743 {
5744     VC1Context *v = avctx->priv_data;
5745     int i;
5746
5747     av_frame_free(&v->sprite_output_frame);
5748
5749     for (i = 0; i < 4; i++)
5750         av_freep(&v->sr_rows[i >> 1][i & 1]);
5751     av_freep(&v->hrd_rate);
5752     av_freep(&v->hrd_buffer);
5753     ff_MPV_common_end(&v->s);
5754     av_freep(&v->mv_type_mb_plane);
5755     av_freep(&v->direct_mb_plane);
5756     av_freep(&v->forward_mb_plane);
5757     av_freep(&v->fieldtx_plane);
5758     av_freep(&v->acpred_plane);
5759     av_freep(&v->over_flags_plane);
5760     av_freep(&v->mb_type_base);
5761     av_freep(&v->blk_mv_type_base);
5762     av_freep(&v->mv_f_base);
5763     av_freep(&v->mv_f_next_base);
5764     av_freep(&v->block);
5765     av_freep(&v->cbp_base);
5766     av_freep(&v->ttblk_base);
5767     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
5768     av_freep(&v->luma_mv_base);
5769     ff_intrax8_common_end(&v->x8);
5770     return 0;
5771 }
5772
5773
5774 /** Decode a VC1/WMV3 frame
5775  * @todo TODO: Handle VC-1 IDUs (Transport level?)
5776  */
5777 static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5778                             int *got_frame, AVPacket *avpkt)
5779 {
5780     const uint8_t *buf = avpkt->data;
5781     int buf_size = avpkt->size, n_slices = 0, i, ret;
5782     VC1Context *v = avctx->priv_data;
5783     MpegEncContext *s = &v->s;
5784     AVFrame *pict = data;
5785     uint8_t *buf2 = NULL;
5786     const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
5787     int mb_height, n_slices1=-1;
5788     struct {
5789         uint8_t *buf;
5790         GetBitContext gb;
5791         int mby_start;
5792     } *slices = NULL, *tmp;
5793
5794     v->second_field = 0;
5795
5796     if(s->flags & CODEC_FLAG_LOW_DELAY)
5797         s->low_delay = 1;
5798
5799     /* no supplementary picture */
5800     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5801         /* special case for last picture */
5802         if (s->low_delay == 0 && s->next_picture_ptr) {
5803             if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
5804                 return ret;
5805             s->next_picture_ptr = NULL;
5806
5807             *got_frame = 1;
5808         }
5809
5810         return buf_size;
5811     }
5812
5813     if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5814         if (v->profile < PROFILE_ADVANCED)
5815             avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5816         else
5817             avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5818     }
5819
5820     //for advanced profile we may need to parse and unescape data
5821     if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5822         int buf_size2 = 0;
5823         buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5824         if (!buf2)
5825             return AVERROR(ENOMEM);
5826
5827         if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
5828             const uint8_t *start, *end, *next;
5829             int size;
5830
5831             next = buf;
5832             for (start = buf, end = buf + buf_size; next < end; start = next) {
5833                 next = find_next_marker(start + 4, end);
5834                 size = next - start - 4;
5835                 if (size <= 0) continue;
5836                 switch (AV_RB32(start)) {
5837                 case VC1_CODE_FRAME:
5838                     if (avctx->hwaccel ||
5839                         s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5840                         buf_start = start;
5841                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5842                     break;
5843                 case VC1_CODE_FIELD: {
5844                     int buf_size3;
5845                     if (avctx->hwaccel ||
5846                         s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5847                         buf_start_second_field = start;
5848                     tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5849                     if (!tmp)
5850                         goto err;
5851                     slices = tmp;
5852                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5853                     if (!slices[n_slices].buf)
5854                         goto err;
5855                     buf_size3 = vc1_unescape_buffer(start + 4, size,
5856                                                     slices[n_slices].buf);
5857                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5858                                   buf_size3 << 3);
5859                     /* assuming that the field marker is at the exact middle,
5860                        hope it's correct */
5861                     slices[n_slices].mby_start = s->mb_height + 1 >> 1;
5862                     n_slices1 = n_slices - 1; // index of the last slice of the first field
5863                     n_slices++;
5864                     break;
5865                 }
5866                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5867                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5868                     init_get_bits(&s->gb, buf2, buf_size2 * 8);
5869                     ff_vc1_decode_entry_point(avctx, v, &s->gb);
5870                     break;
5871                 case VC1_CODE_SLICE: {
5872                     int buf_size3;
5873                     tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5874                     if (!tmp)
5875                         goto err;
5876                     slices = tmp;
5877                     slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5878                     if (!slices[n_slices].buf)
5879                         goto err;
5880                     buf_size3 = vc1_unescape_buffer(start + 4, size,
5881                                                     slices[n_slices].buf);
5882                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5883                                   buf_size3 << 3);
5884                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
5885                     n_slices++;
5886                     break;
5887                 }
5888                 }
5889             }
5890         } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
5891             const uint8_t *divider;
5892             int buf_size3;
5893
5894             divider = find_next_marker(buf, buf + buf_size);
5895             if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
5896                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
5897                 goto err;
5898             } else { // found field marker, unescape second field
5899                 if (avctx->hwaccel ||
5900                     s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
5901                     buf_start_second_field = divider;
5902                 tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5903                 if (!tmp)
5904                     goto err;
5905                 slices = tmp;
5906                 slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5907                 if (!slices[n_slices].buf)
5908                     goto err;
5909                 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
5910                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
5911                               buf_size3 << 3);
5912                 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
5913                 n_slices1 = n_slices - 1;
5914                 n_slices++;
5915             }
5916             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
5917         } else {
5918             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
5919         }
5920         init_get_bits(&s->gb, buf2, buf_size2*8);
5921     } else
5922         init_get_bits(&s->gb, buf, buf_size*8);
5923
5924     if (v->res_sprite) {
5925         v->new_sprite  = !get_bits1(&s->gb);
5926         v->two_sprites =  get_bits1(&s->gb);
5927         /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5928            we're using the sprite compositor. These are intentionally kept separate
5929            so you can get the raw sprites by using the wmv3 decoder for WMVP or
5930            the vc1 one for WVP2 */
5931         if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5932             if (v->new_sprite) {
5933                 // switch AVCodecContext parameters to those of the sprites
5934                 avctx->width  = avctx->coded_width  = v->sprite_width;
5935                 avctx->height = avctx->coded_height = v->sprite_height;
5936             } else {
5937                 goto image;
5938             }
5939         }
5940     }
5941
5942     if (s->context_initialized &&
5943         (s->width  != avctx->coded_width ||
5944          s->height != avctx->coded_height)) {
5945         ff_vc1_decode_end(avctx);
5946     }
5947
5948     if (!s->context_initialized) {
5949         if (ff_msmpeg4_decode_init(avctx) < 0)
5950             goto err;
5951         if (ff_vc1_decode_init_alloc_tables(v) < 0) {
5952             ff_MPV_common_end(s);
5953             goto err;
5954         }
5955
5956         s->low_delay = !avctx->has_b_frames || v->res_sprite;
5957
5958         if (v->profile == PROFILE_ADVANCED) {
5959             if(avctx->coded_width<=1 || avctx->coded_height<=1)
5960                 goto err;
5961             s->h_edge_pos = avctx->coded_width;
5962             s->v_edge_pos = avctx->coded_height;
5963         }
5964     }
5965
5966     // do parse frame header
5967     v->pic_header_flag = 0;
5968     v->first_pic_header_flag = 1;
5969     if (v->profile < PROFILE_ADVANCED) {
5970         if (ff_vc1_parse_frame_header(v, &s->gb) < 0) {
5971             goto err;
5972         }
5973     } else {
5974         if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
5975             goto err;
5976         }
5977     }
5978     v->first_pic_header_flag = 0;
5979
5980     if (avctx->debug & FF_DEBUG_PICT_INFO)
5981         av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
5982
5983     if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5984         && s->pict_type != AV_PICTURE_TYPE_I) {
5985         av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5986         goto err;
5987     }
5988
5989     if ((s->mb_height >> v->field_mode) == 0) {
5990         av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
5991         goto err;
5992     }
5993
5994     // for skipping the frame
5995     s->current_picture.f.pict_type = s->pict_type;
5996     s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5997
5998     /* skip B-frames if we don't have reference frames */
5999     if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
6000         goto err;
6001     }
6002     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
6003         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
6004          avctx->skip_frame >= AVDISCARD_ALL) {
6005         goto end;
6006     }
6007
6008     if (s->next_p_frame_damaged) {
6009         if (s->pict_type == AV_PICTURE_TYPE_B)
6010             goto end;
6011         else
6012             s->next_p_frame_damaged = 0;
6013     }
6014
6015     if (ff_MPV_frame_start(s, avctx) < 0) {
6016         goto err;
6017     }
6018
6019     v->s.current_picture_ptr->f.interlaced_frame = (v->fcm != PROGRESSIVE);
6020     v->s.current_picture_ptr->f.top_field_first  = v->tff;
6021
6022     // process pulldown flags
6023     s->current_picture_ptr->f.repeat_pict = 0;
6024     // Pulldown flags are only valid when 'broadcast' has been set.
6025     // So ticks_per_frame will be 2
6026     if (v->rff) {
6027         // repeat field
6028         s->current_picture_ptr->f.repeat_pict = 1;
6029     } else if (v->rptfrm) {
6030         // repeat frames
6031         s->current_picture_ptr->f.repeat_pict = v->rptfrm * 2;
6032     }
6033
6034     s->me.qpel_put = s->dsp.put_qpel_pixels_tab;
6035     s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;
6036
6037     if ((CONFIG_VC1_VDPAU_DECODER)
6038         &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
6039         if (v->field_mode && buf_start_second_field) {
6040             ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
6041             ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
6042         } else {
6043             ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
6044         }
6045     } else if (avctx->hwaccel) {
6046         if (v->field_mode && buf_start_second_field) {
6047             // decode first field
6048             s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
6049             if (avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6050                 goto err;
6051             if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start) < 0)
6052                 goto err;
6053             if (avctx->hwaccel->end_frame(avctx) < 0)
6054                 goto err;
6055
6056             // decode second field
6057             s->gb = slices[n_slices1 + 1].gb;
6058             s->picture_structure = PICT_TOP_FIELD + v->tff;
6059             v->second_field = 1;
6060             v->pic_header_flag = 0;
6061             if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
6062                 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
6063                 goto err;
6064             }
6065             v->s.current_picture_ptr->f.pict_type = v->s.pict_type;
6066
6067             if (avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6068                 goto err;
6069             if (avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field) < 0)
6070                 goto err;
6071             if (avctx->hwaccel->end_frame(avctx) < 0)
6072                 goto err;
6073         } else {
6074             s->picture_structure = PICT_FRAME;
6075             if (avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6076                 goto err;
6077             if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
6078                 goto err;
6079             if (avctx->hwaccel->end_frame(avctx) < 0)
6080                 goto err;
6081         }
6082     } else {
6083         int header_ret = 0;
6084
6085         ff_mpeg_er_frame_start(s);
6086
6087         v->bits = buf_size * 8;
6088         v->end_mb_x = s->mb_width;
6089         if (v->field_mode) {
6090             s->current_picture.f.linesize[0] <<= 1;
6091             s->current_picture.f.linesize[1] <<= 1;
6092             s->current_picture.f.linesize[2] <<= 1;
6093             s->linesize                      <<= 1;
6094             s->uvlinesize                    <<= 1;
6095         }
6096         mb_height = s->mb_height >> v->field_mode;
6097
6098         av_assert0 (mb_height > 0);
6099
6100         for (i = 0; i <= n_slices; i++) {
6101             if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
6102                 if (v->field_mode <= 0) {
6103                     av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
6104                            "picture boundary (%d >= %d)\n", i,
6105                            slices[i - 1].mby_start, mb_height);
6106                     continue;
6107                 }
6108                 v->second_field = 1;
6109                 av_assert0((s->mb_height & 1) == 0);
6110                 v->blocks_off   = s->b8_stride * (s->mb_height&~1);
6111                 v->mb_off       = s->mb_stride * s->mb_height >> 1;
6112             } else {
6113                 v->second_field = 0;
6114                 v->blocks_off   = 0;
6115                 v->mb_off       = 0;
6116             }
6117             if (i) {
6118                 v->pic_header_flag = 0;
6119                 if (v->field_mode && i == n_slices1 + 2) {
6120                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6121                         av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
6122                         if (avctx->err_recognition & AV_EF_EXPLODE)
6123                             goto err;
6124                         continue;
6125                     }
6126                 } else if (get_bits1(&s->gb)) {
6127                     v->pic_header_flag = 1;
6128                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
6129                         av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
6130                         if (avctx->err_recognition & AV_EF_EXPLODE)
6131                             goto err;
6132                         continue;
6133                     }
6134                 }
6135             }
6136             if (header_ret < 0)
6137                 continue;
6138             s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
6139             if (!v->field_mode || v->second_field)
6140                 s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6141             else {
6142                 if (i >= n_slices) {
6143                     av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
6144                     continue;
6145                 }
6146                 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
6147             }
6148             if (s->end_mb_y <= s->start_mb_y) {
6149                 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
6150                 continue;
6151             }
6152             if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
6153                 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
6154                 continue;
6155             }
6156             ff_vc1_decode_blocks(v);
6157             if (i != n_slices)
6158                 s->gb = slices[i].gb;
6159         }
6160         if (v->field_mode) {
6161             v->second_field = 0;
6162             s->current_picture.f.linesize[0] >>= 1;
6163             s->current_picture.f.linesize[1] >>= 1;
6164             s->current_picture.f.linesize[2] >>= 1;
6165             s->linesize                      >>= 1;
6166             s->uvlinesize                    >>= 1;
6167             if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
6168                 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
6169                 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
6170             }
6171         }
6172         av_dlog(s->avctx, "Consumed %i/%i bits\n",
6173                 get_bits_count(&s->gb), s->gb.size_in_bits);
6174 //  if (get_bits_count(&s->gb) > buf_size * 8)
6175 //      return -1;
6176         if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B)
6177             goto err;
6178         if (!v->field_mode)
6179             ff_er_frame_end(&s->er);
6180     }
6181
6182     ff_MPV_frame_end(s);
6183
6184     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
6185 image:
6186         avctx->width  = avctx->coded_width  = v->output_width;
6187         avctx->height = avctx->coded_height = v->output_height;
6188         if (avctx->skip_frame >= AVDISCARD_NONREF)
6189             goto end;
6190 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
6191         if (vc1_decode_sprites(v, &s->gb))
6192             goto err;
6193 #endif
6194         if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
6195             goto err;
6196         *got_frame = 1;
6197     } else {
6198         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
6199             if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
6200                 goto err;
6201             ff_print_debug_info(s, s->current_picture_ptr, pict);
6202             *got_frame = 1;
6203         } else if (s->last_picture_ptr != NULL) {
6204             if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
6205                 goto err;
6206             ff_print_debug_info(s, s->last_picture_ptr, pict);
6207             *got_frame = 1;
6208         }
6209     }
6210
6211 end:
6212     av_free(buf2);
6213     for (i = 0; i < n_slices; i++)
6214         av_free(slices[i].buf);
6215     av_free(slices);
6216     return buf_size;
6217
6218 err:
6219     av_free(buf2);
6220     for (i = 0; i < n_slices; i++)
6221         av_free(slices[i].buf);
6222     av_free(slices);
6223     return -1;
6224 }
6225
6226
6227 static const AVProfile profiles[] = {
6228     { FF_PROFILE_VC1_SIMPLE,   "Simple"   },
6229     { FF_PROFILE_VC1_MAIN,     "Main"     },
6230     { FF_PROFILE_VC1_COMPLEX,  "Complex"  },
6231     { FF_PROFILE_VC1_ADVANCED, "Advanced" },
6232     { FF_PROFILE_UNKNOWN },
6233 };
6234
6235 static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
6236 #if CONFIG_DXVA2
6237     AV_PIX_FMT_DXVA2_VLD,
6238 #endif
6239 #if CONFIG_VAAPI
6240     AV_PIX_FMT_VAAPI_VLD,
6241 #endif
6242 #if CONFIG_VDPAU
6243     AV_PIX_FMT_VDPAU,
6244 #endif
6245     AV_PIX_FMT_YUV420P,
6246     AV_PIX_FMT_NONE
6247 };
6248
6249 AVCodec ff_vc1_decoder = {
6250     .name           = "vc1",
6251     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
6252     .type           = AVMEDIA_TYPE_VIDEO,
6253     .id             = AV_CODEC_ID_VC1,
6254     .priv_data_size = sizeof(VC1Context),
6255     .init           = vc1_decode_init,
6256     .close          = ff_vc1_decode_end,
6257     .decode         = vc1_decode_frame,
6258     .flush          = ff_mpeg_flush,
6259     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6260     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
6261     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
6262 };
6263
6264 #if CONFIG_WMV3_DECODER
6265 AVCodec ff_wmv3_decoder = {
6266     .name           = "wmv3",
6267     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
6268     .type           = AVMEDIA_TYPE_VIDEO,
6269     .id             = AV_CODEC_ID_WMV3,
6270     .priv_data_size = sizeof(VC1Context),
6271     .init           = vc1_decode_init,
6272     .close          = ff_vc1_decode_end,
6273     .decode         = vc1_decode_frame,
6274     .flush          = ff_mpeg_flush,
6275     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
6276     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
6277     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
6278 };
6279 #endif
6280
6281 #if CONFIG_WMV3_VDPAU_DECODER
6282 AVCodec ff_wmv3_vdpau_decoder = {
6283     .name           = "wmv3_vdpau",
6284     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
6285     .type           = AVMEDIA_TYPE_VIDEO,
6286     .id             = AV_CODEC_ID_WMV3,
6287     .priv_data_size = sizeof(VC1Context),
6288     .init           = vc1_decode_init,
6289     .close          = ff_vc1_decode_end,
6290     .decode         = vc1_decode_frame,
6291     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6292     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
6293     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
6294 };
6295 #endif
6296
6297 #if CONFIG_VC1_VDPAU_DECODER
6298 AVCodec ff_vc1_vdpau_decoder = {
6299     .name           = "vc1_vdpau",
6300     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
6301     .type           = AVMEDIA_TYPE_VIDEO,
6302     .id             = AV_CODEC_ID_VC1,
6303     .priv_data_size = sizeof(VC1Context),
6304     .init           = vc1_decode_init,
6305     .close          = ff_vc1_decode_end,
6306     .decode         = vc1_decode_frame,
6307     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
6308     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
6309     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
6310 };
6311 #endif
6312
6313 #if CONFIG_WMV3IMAGE_DECODER
6314 AVCodec ff_wmv3image_decoder = {
6315     .name           = "wmv3image",
6316     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
6317     .type           = AVMEDIA_TYPE_VIDEO,
6318     .id             = AV_CODEC_ID_WMV3IMAGE,
6319     .priv_data_size = sizeof(VC1Context),
6320     .init           = vc1_decode_init,
6321     .close          = ff_vc1_decode_end,
6322     .decode         = vc1_decode_frame,
6323     .capabilities   = CODEC_CAP_DR1,
6324     .flush          = vc1_sprite_flush,
6325     .pix_fmts       = ff_pixfmt_list_420
6326 };
6327 #endif
6328
6329 #if CONFIG_VC1IMAGE_DECODER
6330 AVCodec ff_vc1image_decoder = {
6331     .name           = "vc1image",
6332     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
6333     .type           = AVMEDIA_TYPE_VIDEO,
6334     .id             = AV_CODEC_ID_VC1IMAGE,
6335     .priv_data_size = sizeof(VC1Context),
6336     .init           = vc1_decode_init,
6337     .close          = ff_vc1_decode_end,
6338     .decode         = vc1_decode_frame,
6339     .capabilities   = CODEC_CAP_DR1,
6340     .flush          = vc1_sprite_flush,
6341     .pix_fmts       = ff_pixfmt_list_420
6342 };
6343 #endif