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