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