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