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