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