git.sesse.net Git - ffmpeg/blob - libavcodec/vc1dec.c

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