8c698087258e134fc483ffc063162dc86b653137
[ffmpeg.git] / libavcodec / vc1.c
1 /*
2  * VC-1 and WMV3 decoder
3  * Copyright (c) 2006 Konstantin Shishkov
4  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  *
22  */
23
24 /**
25  * @file vc1.c
26  * VC-1 and WMV3 decoder
27  *
28  */
29 #include "common.h"
30 #include "dsputil.h"
31 #include "avcodec.h"
32 #include "mpegvideo.h"
33 #include "vc1data.h"
34 #include "vc1acdata.h"
35
36 #undef NDEBUG
37 #include <assert.h>
38
39 extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];
40 extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];
41 extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];
42 #define MB_INTRA_VLC_BITS 9
43 extern VLC ff_msmp4_mb_i_vlc;
44 extern const uint16_t ff_msmp4_mb_i_table[64][2];
45 #define DC_VLC_BITS 9
46 #define AC_VLC_BITS 9
47 static const uint16_t table_mb_intra[64][2];
48
49 /** Markers used if VC-1 AP frame data */
50 //@{
51 enum VC1Code{
52     VC1_CODE_RES0       = 0x00000100,
53     VC1_CODE_ENDOFSEQ   = 0x0000010A,
54     VC1_CODE_SLICE,
55     VC1_CODE_FIELD,
56     VC1_CODE_FRAME,
57     VC1_CODE_ENTRYPOINT,
58     VC1_CODE_SEQHDR,
59 };
60 //@}
61
62 /** Available Profiles */
63 //@{
64 enum Profile {
65     PROFILE_SIMPLE,
66     PROFILE_MAIN,
67     PROFILE_COMPLEX, ///< TODO: WMV9 specific
68     PROFILE_ADVANCED
69 };
70 //@}
71
72 /** Sequence quantizer mode */
73 //@{
74 enum QuantMode {
75     QUANT_FRAME_IMPLICIT,    ///< Implicitly specified at frame level
76     QUANT_FRAME_EXPLICIT,    ///< Explicitly specified at frame level
77     QUANT_NON_UNIFORM,       ///< Non-uniform quant used for all frames
78     QUANT_UNIFORM            ///< Uniform quant used for all frames
79 };
80 //@}
81
82 /** Where quant can be changed */
83 //@{
84 enum DQProfile {
85     DQPROFILE_FOUR_EDGES,
86     DQPROFILE_DOUBLE_EDGES,
87     DQPROFILE_SINGLE_EDGE,
88     DQPROFILE_ALL_MBS
89 };
90 //@}
91
92 /** @name Where quant can be changed
93  */
94 //@{
95 enum DQSingleEdge {
96     DQSINGLE_BEDGE_LEFT,
97     DQSINGLE_BEDGE_TOP,
98     DQSINGLE_BEDGE_RIGHT,
99     DQSINGLE_BEDGE_BOTTOM
100 };
101 //@}
102
103 /** Which pair of edges is quantized with ALTPQUANT */
104 //@{
105 enum DQDoubleEdge {
106     DQDOUBLE_BEDGE_TOPLEFT,
107     DQDOUBLE_BEDGE_TOPRIGHT,
108     DQDOUBLE_BEDGE_BOTTOMRIGHT,
109     DQDOUBLE_BEDGE_BOTTOMLEFT
110 };
111 //@}
112
113 /** MV modes for P frames */
114 //@{
115 enum MVModes {
116     MV_PMODE_1MV_HPEL_BILIN,
117     MV_PMODE_1MV,
118     MV_PMODE_1MV_HPEL,
119     MV_PMODE_MIXED_MV,
120     MV_PMODE_INTENSITY_COMP
121 };
122 //@}
123
124 /** @name MV types for B frames */
125 //@{
126 enum BMVTypes {
127     BMV_TYPE_BACKWARD,
128     BMV_TYPE_FORWARD,
129     BMV_TYPE_INTERPOLATED
130 };
131 //@}
132
133 /** @name Block types for P/B frames */
134 //@{
135 enum TransformTypes {
136     TT_8X8,
137     TT_8X4_BOTTOM,
138     TT_8X4_TOP,
139     TT_8X4, //Both halves
140     TT_4X8_RIGHT,
141     TT_4X8_LEFT,
142     TT_4X8, //Both halves
143     TT_4X4
144 };
145 //@}
146
147 /** Table for conversion between TTBLK and TTMB */
148 static const int ttblk_to_tt[3][8] = {
149   { TT_8X4, TT_4X8, TT_8X8, TT_4X4, TT_8X4_TOP, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT },
150   { TT_8X8, TT_4X8_RIGHT, TT_4X8_LEFT, TT_4X4, TT_8X4, TT_4X8, TT_8X4_BOTTOM, TT_8X4_TOP },
151   { TT_8X8, TT_4X8, TT_4X4, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT, TT_8X4, TT_8X4_TOP }
152 };
153
154 static const int ttfrm_to_tt[4] = { TT_8X8, TT_8X4, TT_4X8, TT_4X4 };
155
156 /** MV P mode - the 5th element is only used for mode 1 */
157 static const uint8_t mv_pmode_table[2][5] = {
158   { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV },
159   { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN }
160 };
161 static const uint8_t mv_pmode_table2[2][4] = {
162   { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV },
163   { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN }
164 };
165
166 /** One more frame type */
167 #define BI_TYPE 7
168
169 static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
170   fps_dr[2] = { 1000, 1001 };
171 static const uint8_t pquant_table[3][32] = {
172   {  /* Implicit quantizer */
173      0,  1,  2,  3,  4,  5,  6,  7,  8,  6,  7,  8,  9, 10, 11, 12,
174     13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
175   },
176   {  /* Explicit quantizer, pquantizer uniform */
177      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
178     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
179   },
180   {  /* Explicit quantizer, pquantizer non-uniform */
181      0,  1,  1,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,
182     14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
183   }
184 };
185
186 /** @name VC-1 VLC tables and defines
187  *  @todo TODO move this into the context
188  */
189 //@{
190 #define VC1_BFRACTION_VLC_BITS 7
191 static VLC vc1_bfraction_vlc;
192 #define VC1_IMODE_VLC_BITS 4
193 static VLC vc1_imode_vlc;
194 #define VC1_NORM2_VLC_BITS 3
195 static VLC vc1_norm2_vlc;
196 #define VC1_NORM6_VLC_BITS 9
197 static VLC vc1_norm6_vlc;
198 /* Could be optimized, one table only needs 8 bits */
199 #define VC1_TTMB_VLC_BITS 9 //12
200 static VLC vc1_ttmb_vlc[3];
201 #define VC1_MV_DIFF_VLC_BITS 9 //15
202 static VLC vc1_mv_diff_vlc[4];
203 #define VC1_CBPCY_P_VLC_BITS 9 //14
204 static VLC vc1_cbpcy_p_vlc[4];
205 #define VC1_4MV_BLOCK_PATTERN_VLC_BITS 6
206 static VLC vc1_4mv_block_pattern_vlc[4];
207 #define VC1_TTBLK_VLC_BITS 5
208 static VLC vc1_ttblk_vlc[3];
209 #define VC1_SUBBLKPAT_VLC_BITS 6
210 static VLC vc1_subblkpat_vlc[3];
211
212 static VLC vc1_ac_coeff_table[8];
213 //@}
214
215 enum CodingSet {
216     CS_HIGH_MOT_INTRA = 0,
217     CS_HIGH_MOT_INTER,
218     CS_LOW_MOT_INTRA,
219     CS_LOW_MOT_INTER,
220     CS_MID_RATE_INTRA,
221     CS_MID_RATE_INTER,
222     CS_HIGH_RATE_INTRA,
223     CS_HIGH_RATE_INTER
224 };
225
226 /** @name Overlap conditions for Advanced Profile */
227 //@{
228 enum COTypes {
229     CONDOVER_NONE = 0,
230     CONDOVER_ALL,
231     CONDOVER_SELECT
232 };
233 //@}
234
235
236 /** The VC1 Context
237  * @fixme Change size wherever another size is more efficient
238  * Many members are only used for Advanced Profile
239  */
240 typedef struct VC1Context{
241     MpegEncContext s;
242
243     int bits;
244
245     /** Simple/Main Profile sequence header */
246     //@{
247     int res_sm;           ///< reserved, 2b
248     int res_x8;           ///< reserved
249     int multires;         ///< frame-level RESPIC syntax element present
250     int res_fasttx;       ///< reserved, always 1
251     int res_transtab;     ///< reserved, always 0
252     int rangered;         ///< RANGEREDFRM (range reduction) syntax element present
253                           ///< at frame level
254     int res_rtm_flag;     ///< reserved, set to 1
255     int reserved;         ///< reserved
256     //@}
257
258     /** Advanced Profile */
259     //@{
260     int level;            ///< 3bits, for Advanced/Simple Profile, provided by TS layer
261     int chromaformat;     ///< 2bits, 2=4:2:0, only defined
262     int postprocflag;     ///< Per-frame processing suggestion flag present
263     int broadcast;        ///< TFF/RFF present
264     int interlace;        ///< Progressive/interlaced (RPTFTM syntax element)
265     int tfcntrflag;       ///< TFCNTR present
266     int panscanflag;      ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
267     int extended_dmv;     ///< Additional extended dmv range at P/B frame-level
268     int color_prim;       ///< 8bits, chroma coordinates of the color primaries
269     int transfer_char;    ///< 8bits, Opto-electronic transfer characteristics
270     int matrix_coef;      ///< 8bits, Color primaries->YCbCr transform matrix
271     int hrd_param_flag;   ///< Presence of Hypothetical Reference
272                           ///< Decoder parameters
273     int psf;              ///< Progressive Segmented Frame
274     //@}
275
276     /** Sequence header data for all Profiles
277      * TODO: choose between ints, uint8_ts and monobit flags
278      */
279     //@{
280     int profile;          ///< 2bits, Profile
281     int frmrtq_postproc;  ///< 3bits,
282     int bitrtq_postproc;  ///< 5bits, quantized framerate-based postprocessing strength
283     int fastuvmc;         ///< Rounding of qpel vector to hpel ? (not in Simple)
284     int extended_mv;      ///< Ext MV in P/B (not in Simple)
285     int dquant;           ///< How qscale varies with MBs, 2bits (not in Simple)
286     int vstransform;      ///< variable-size [48]x[48] transform type + info
287     int overlap;          ///< overlapped transforms in use
288     int quantizer_mode;   ///< 2bits, quantizer mode used for sequence, see QUANT_*
289     int finterpflag;      ///< INTERPFRM present
290     //@}
291
292     /** Frame decoding info for all profiles */
293     //@{
294     uint8_t mv_mode;      ///< MV coding monde
295     uint8_t mv_mode2;     ///< Secondary MV coding mode (B frames)
296     int k_x;              ///< Number of bits for MVs (depends on MV range)
297     int k_y;              ///< Number of bits for MVs (depends on MV range)
298     int range_x, range_y; ///< MV range
299     uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale
300     /** pquant parameters */
301     //@{
302     uint8_t dquantfrm;
303     uint8_t dqprofile;
304     uint8_t dqsbedge;
305     uint8_t dqbilevel;
306     //@}
307     /** AC coding set indexes
308      * @see 8.1.1.10, p(1)10
309      */
310     //@{
311     int c_ac_table_index; ///< Chroma index from ACFRM element
312     int y_ac_table_index; ///< Luma index from AC2FRM element
313     //@}
314     int ttfrm;            ///< Transform type info present at frame level
315     uint8_t ttmbf;        ///< Transform type flag
316     uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
317     int codingset;        ///< index of current table set from 11.8 to use for luma block decoding
318     int codingset2;       ///< index of current table set from 11.8 to use for chroma block decoding
319     int pqindex;          ///< raw pqindex used in coding set selection
320     int a_avail, c_avail;
321     uint8_t *mb_type_base, *mb_type[3];
322
323
324     /** Luma compensation parameters */
325     //@{
326     uint8_t lumscale;
327     uint8_t lumshift;
328     //@}
329     int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs
330     uint8_t halfpq;       ///< Uniform quant over image and qp+.5
331     uint8_t respic;       ///< Frame-level flag for resized images
332     int buffer_fullness;  ///< HRD info
333     /** Ranges:
334      * -# 0 -> [-64n 63.f] x [-32, 31.f]
335      * -# 1 -> [-128, 127.f] x [-64, 63.f]
336      * -# 2 -> [-512, 511.f] x [-128, 127.f]
337      * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
338      */
339     uint8_t mvrange;
340     uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use
341     VLC *cbpcy_vlc;               ///< CBPCY VLC table
342     int tt_index;                 ///< Index for Transform Type tables
343     uint8_t* mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)
344     uint8_t* direct_mb_plane;     ///< bitplane for "direct" MBs
345     int mv_type_is_raw;           ///< mv type mb plane is not coded
346     int dmb_is_raw;               ///< direct mb plane is raw
347     int skip_is_raw;              ///< skip mb plane is not coded
348     uint8_t luty[256], lutuv[256]; // lookup tables used for intensity compensation
349     int use_ic;                   ///< use intensity compensation in B-frames
350     int rnd;                      ///< rounding control
351
352     /** Frame decoding info for S/M profiles only */
353     //@{
354     uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
355     uint8_t interpfrm;
356     //@}
357
358     /** Frame decoding info for Advanced profile */
359     //@{
360     uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
361     uint8_t numpanscanwin;
362     uint8_t tfcntr;
363     uint8_t rptfrm, tff, rff;
364     uint16_t topleftx;
365     uint16_t toplefty;
366     uint16_t bottomrightx;
367     uint16_t bottomrighty;
368     uint8_t uvsamp;
369     uint8_t postproc;
370     int hrd_num_leaky_buckets;
371     uint8_t bit_rate_exponent;
372     uint8_t buffer_size_exponent;
373     uint8_t* acpred_plane;       ///< AC prediction flags bitplane
374     int acpred_is_raw;
375     uint8_t* over_flags_plane;   ///< Overflags bitplane
376     int overflg_is_raw;
377     uint8_t condover;
378     uint16_t *hrd_rate, *hrd_buffer;
379     uint8_t *hrd_fullness;
380     uint8_t range_mapy_flag;
381     uint8_t range_mapuv_flag;
382     uint8_t range_mapy;
383     uint8_t range_mapuv;
384     //@}
385
386     int p_frame_skipped;
387     int bi_type;
388 } VC1Context;
389
390 /**
391  * Get unary code of limited length
392  * @fixme FIXME Slow and ugly
393  * @param gb GetBitContext
394  * @param[in] stop The bitstop value (unary code of 1's or 0's)
395  * @param[in] len Maximum length
396  * @return Unary length/index
397  */
398 static int get_prefix(GetBitContext *gb, int stop, int len)
399 {
400 #if 1
401     int i;
402
403     for(i = 0; i < len && get_bits1(gb) != stop; i++);
404     return i;
405 /*  int i = 0, tmp = !stop;
406
407   while (i != len && tmp != stop)
408   {
409     tmp = get_bits(gb, 1);
410     i++;
411   }
412   if (i == len && tmp != stop) return len+1;
413   return i;*/
414 #else
415   unsigned int buf;
416   int log;
417
418   OPEN_READER(re, gb);
419   UPDATE_CACHE(re, gb);
420   buf=GET_CACHE(re, gb); //Still not sure
421   if (stop) buf = ~buf;
422
423   log= av_log2(-buf); //FIXME: -?
424   if (log < limit){
425     LAST_SKIP_BITS(re, gb, log+1);
426     CLOSE_READER(re, gb);
427     return log;
428   }
429
430   LAST_SKIP_BITS(re, gb, limit);
431   CLOSE_READER(re, gb);
432   return limit;
433 #endif
434 }
435
436 static inline int decode210(GetBitContext *gb){
437     int n;
438     n = get_bits1(gb);
439     if (n == 1)
440         return 0;
441     else
442         return 2 - get_bits1(gb);
443 }
444
445 /**
446  * Init VC-1 specific tables and VC1Context members
447  * @param v The VC1Context to initialize
448  * @return Status
449  */
450 static int vc1_init_common(VC1Context *v)
451 {
452     static int done = 0;
453     int i = 0;
454
455     v->hrd_rate = v->hrd_buffer = NULL;
456
457     /* VLC tables */
458     if(!done)
459     {
460         done = 1;
461         init_vlc(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
462                  vc1_bfraction_bits, 1, 1,
463                  vc1_bfraction_codes, 1, 1, 1);
464         init_vlc(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
465                  vc1_norm2_bits, 1, 1,
466                  vc1_norm2_codes, 1, 1, 1);
467         init_vlc(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
468                  vc1_norm6_bits, 1, 1,
469                  vc1_norm6_codes, 2, 2, 1);
470         init_vlc(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
471                  vc1_imode_bits, 1, 1,
472                  vc1_imode_codes, 1, 1, 1);
473         for (i=0; i<3; i++)
474         {
475             init_vlc(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
476                      vc1_ttmb_bits[i], 1, 1,
477                      vc1_ttmb_codes[i], 2, 2, 1);
478             init_vlc(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
479                      vc1_ttblk_bits[i], 1, 1,
480                      vc1_ttblk_codes[i], 1, 1, 1);
481             init_vlc(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
482                      vc1_subblkpat_bits[i], 1, 1,
483                      vc1_subblkpat_codes[i], 1, 1, 1);
484         }
485         for(i=0; i<4; i++)
486         {
487             init_vlc(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
488                      vc1_4mv_block_pattern_bits[i], 1, 1,
489                      vc1_4mv_block_pattern_codes[i], 1, 1, 1);
490             init_vlc(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
491                      vc1_cbpcy_p_bits[i], 1, 1,
492                      vc1_cbpcy_p_codes[i], 2, 2, 1);
493             init_vlc(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
494                      vc1_mv_diff_bits[i], 1, 1,
495                      vc1_mv_diff_codes[i], 2, 2, 1);
496         }
497         for(i=0; i<8; i++)
498             init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
499                      &vc1_ac_tables[i][0][1], 8, 4,
500                      &vc1_ac_tables[i][0][0], 8, 4, 1);
501         init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
502                  &ff_msmp4_mb_i_table[0][1], 4, 2,
503                  &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
504     }
505
506     /* Other defaults */
507     v->pq = -1;
508     v->mvrange = 0; /* 7.1.1.18, p80 */
509
510     return 0;
511 }
512
513 /***********************************************************************/
514 /**
515  * @defgroup bitplane VC9 Bitplane decoding
516  * @see 8.7, p56
517  * @{
518  */
519
520 /** @addtogroup bitplane
521  * Imode types
522  * @{
523  */
524 enum Imode {
525     IMODE_RAW,
526     IMODE_NORM2,
527     IMODE_DIFF2,
528     IMODE_NORM6,
529     IMODE_DIFF6,
530     IMODE_ROWSKIP,
531     IMODE_COLSKIP
532 };
533 /** @} */ //imode defines
534
535 /** Decode rows by checking if they are skipped
536  * @param plane Buffer to store decoded bits
537  * @param[in] width Width of this buffer
538  * @param[in] height Height of this buffer
539  * @param[in] stride of this buffer
540  */
541 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
542     int x, y;
543
544     for (y=0; y<height; y++){
545         if (!get_bits(gb, 1)) //rowskip
546             memset(plane, 0, width);
547         else
548             for (x=0; x<width; x++)
549                 plane[x] = get_bits(gb, 1);
550         plane += stride;
551     }
552 }
553
554 /** Decode columns by checking if they are skipped
555  * @param plane Buffer to store decoded bits
556  * @param[in] width Width of this buffer
557  * @param[in] height Height of this buffer
558  * @param[in] stride of this buffer
559  * @fixme FIXME: Optimize
560  */
561 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
562     int x, y;
563
564     for (x=0; x<width; x++){
565         if (!get_bits(gb, 1)) //colskip
566             for (y=0; y<height; y++)
567                 plane[y*stride] = 0;
568         else
569             for (y=0; y<height; y++)
570                 plane[y*stride] = get_bits(gb, 1);
571         plane ++;
572     }
573 }
574
575 /** Decode a bitplane's bits
576  * @param bp Bitplane where to store the decode bits
577  * @param v VC-1 context for bit reading and logging
578  * @return Status
579  * @fixme FIXME: Optimize
580  */
581 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
582 {
583     GetBitContext *gb = &v->s.gb;
584
585     int imode, x, y, code, offset;
586     uint8_t invert, *planep = data;
587     int width, height, stride;
588
589     width = v->s.mb_width;
590     height = v->s.mb_height;
591     stride = v->s.mb_stride;
592     invert = get_bits(gb, 1);
593     imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
594
595     *raw_flag = 0;
596     switch (imode)
597     {
598     case IMODE_RAW:
599         //Data is actually read in the MB layer (same for all tests == "raw")
600         *raw_flag = 1; //invert ignored
601         return invert;
602     case IMODE_DIFF2:
603     case IMODE_NORM2:
604         if ((height * width) & 1)
605         {
606             *planep++ = get_bits(gb, 1);
607             offset = 1;
608         }
609         else offset = 0;
610         // decode bitplane as one long line
611         for (y = offset; y < height * width; y += 2) {
612             code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
613             *planep++ = code & 1;
614             offset++;
615             if(offset == width) {
616                 offset = 0;
617                 planep += stride - width;
618             }
619             *planep++ = code >> 1;
620             offset++;
621             if(offset == width) {
622                 offset = 0;
623                 planep += stride - width;
624             }
625         }
626         break;
627     case IMODE_DIFF6:
628     case IMODE_NORM6:
629         if(!(height % 3) && (width % 3)) { // use 2x3 decoding
630             for(y = 0; y < height; y+= 3) {
631                 for(x = width & 1; x < width; x += 2) {
632                     code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
633                     if(code < 0){
634                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
635                         return -1;
636                     }
637                     planep[x + 0] = (code >> 0) & 1;
638                     planep[x + 1] = (code >> 1) & 1;
639                     planep[x + 0 + stride] = (code >> 2) & 1;
640                     planep[x + 1 + stride] = (code >> 3) & 1;
641                     planep[x + 0 + stride * 2] = (code >> 4) & 1;
642                     planep[x + 1 + stride * 2] = (code >> 5) & 1;
643                 }
644                 planep += stride * 3;
645             }
646             if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
647         } else { // 3x2
648             planep += (height & 1) * stride;
649             for(y = height & 1; y < height; y += 2) {
650                 for(x = width % 3; x < width; x += 3) {
651                     code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
652                     if(code < 0){
653                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
654                         return -1;
655                     }
656                     planep[x + 0] = (code >> 0) & 1;
657                     planep[x + 1] = (code >> 1) & 1;
658                     planep[x + 2] = (code >> 2) & 1;
659                     planep[x + 0 + stride] = (code >> 3) & 1;
660                     planep[x + 1 + stride] = (code >> 4) & 1;
661                     planep[x + 2 + stride] = (code >> 5) & 1;
662                 }
663                 planep += stride * 2;
664             }
665             x = width % 3;
666             if(x) decode_colskip(data  ,             x, height    , stride, &v->s.gb);
667             if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
668         }
669         break;
670     case IMODE_ROWSKIP:
671         decode_rowskip(data, width, height, stride, &v->s.gb);
672         break;
673     case IMODE_COLSKIP:
674         decode_colskip(data, width, height, stride, &v->s.gb);
675         break;
676     default: break;
677     }
678
679     /* Applying diff operator */
680     if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
681     {
682         planep = data;
683         planep[0] ^= invert;
684         for (x=1; x<width; x++)
685             planep[x] ^= planep[x-1];
686         for (y=1; y<height; y++)
687         {
688             planep += stride;
689             planep[0] ^= planep[-stride];
690             for (x=1; x<width; x++)
691             {
692                 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
693                 else                                 planep[x] ^= planep[x-1];
694             }
695         }
696     }
697     else if (invert)
698     {
699         planep = data;
700         for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
701     }
702     return (imode<<1) + invert;
703 }
704
705 /** @} */ //Bitplane group
706
707 /***********************************************************************/
708 /** VOP Dquant decoding
709  * @param v VC-1 Context
710  */
711 static int vop_dquant_decoding(VC1Context *v)
712 {
713     GetBitContext *gb = &v->s.gb;
714     int pqdiff;
715
716     //variable size
717     if (v->dquant == 2)
718     {
719         pqdiff = get_bits(gb, 3);
720         if (pqdiff == 7) v->altpq = get_bits(gb, 5);
721         else v->altpq = v->pq + pqdiff + 1;
722     }
723     else
724     {
725         v->dquantfrm = get_bits(gb, 1);
726         if ( v->dquantfrm )
727         {
728             v->dqprofile = get_bits(gb, 2);
729             switch (v->dqprofile)
730             {
731             case DQPROFILE_SINGLE_EDGE:
732             case DQPROFILE_DOUBLE_EDGES:
733                 v->dqsbedge = get_bits(gb, 2);
734                 break;
735             case DQPROFILE_ALL_MBS:
736                 v->dqbilevel = get_bits(gb, 1);
737             default: break; //Forbidden ?
738             }
739             if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
740             {
741                 pqdiff = get_bits(gb, 3);
742                 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
743                 else v->altpq = v->pq + pqdiff + 1;
744             }
745         }
746     }
747     return 0;
748 }
749
750 /** Put block onto picture
751  */
752 static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
753 {
754     uint8_t *Y;
755     int ys, us, vs;
756     DSPContext *dsp = &v->s.dsp;
757
758     if(v->rangeredfrm) {
759         int i, j, k;
760         for(k = 0; k < 6; k++)
761             for(j = 0; j < 8; j++)
762                 for(i = 0; i < 8; i++)
763                     block[k][i + j*8] = ((block[k][i + j*8] - 128) << 1) + 128;
764
765     }
766     ys = v->s.current_picture.linesize[0];
767     us = v->s.current_picture.linesize[1];
768     vs = v->s.current_picture.linesize[2];
769     Y = v->s.dest[0];
770
771     dsp->put_pixels_clamped(block[0], Y, ys);
772     dsp->put_pixels_clamped(block[1], Y + 8, ys);
773     Y += ys * 8;
774     dsp->put_pixels_clamped(block[2], Y, ys);
775     dsp->put_pixels_clamped(block[3], Y + 8, ys);
776
777     if(!(v->s.flags & CODEC_FLAG_GRAY)) {
778         dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
779         dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
780     }
781 }
782
783 /** Do motion compensation over 1 macroblock
784  * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
785  */
786 static void vc1_mc_1mv(VC1Context *v, int dir)
787 {
788     MpegEncContext *s = &v->s;
789     DSPContext *dsp = &v->s.dsp;
790     uint8_t *srcY, *srcU, *srcV;
791     int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
792
793     if(!v->s.last_picture.data[0])return;
794
795     mx = s->mv[dir][0][0];
796     my = s->mv[dir][0][1];
797
798     // store motion vectors for further use in B frames
799     if(s->pict_type == P_TYPE) {
800         s->current_picture.motion_val[1][s->block_index[0]][0] = mx;
801         s->current_picture.motion_val[1][s->block_index[0]][1] = my;
802     }
803     uvmx = (mx + ((mx & 3) == 3)) >> 1;
804     uvmy = (my + ((my & 3) == 3)) >> 1;
805     if(v->fastuvmc) {
806         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
807         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
808     }
809     if(!dir) {
810         srcY = s->last_picture.data[0];
811         srcU = s->last_picture.data[1];
812         srcV = s->last_picture.data[2];
813     } else {
814         srcY = s->next_picture.data[0];
815         srcU = s->next_picture.data[1];
816         srcV = s->next_picture.data[2];
817     }
818
819     src_x = s->mb_x * 16 + (mx >> 2);
820     src_y = s->mb_y * 16 + (my >> 2);
821     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
822     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
823
824     src_x   = clip(  src_x, -16, s->mb_width  * 16);
825     src_y   = clip(  src_y, -16, s->mb_height * 16);
826     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
827     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
828
829     srcY += src_y * s->linesize + src_x;
830     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
831     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
832
833     /* for grayscale we should not try to read from unknown area */
834     if(s->flags & CODEC_FLAG_GRAY) {
835         srcU = s->edge_emu_buffer + 18 * s->linesize;
836         srcV = s->edge_emu_buffer + 18 * s->linesize;
837     }
838
839     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
840        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
841        || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
842         uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
843
844         srcY -= s->mspel * (1 + s->linesize);
845         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
846                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
847         srcY = s->edge_emu_buffer;
848         ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
849                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
850         ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
851                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
852         srcU = uvbuf;
853         srcV = uvbuf + 16;
854         /* if we deal with range reduction we need to scale source blocks */
855         if(v->rangeredfrm) {
856             int i, j;
857             uint8_t *src, *src2;
858
859             src = srcY;
860             for(j = 0; j < 17 + s->mspel*2; j++) {
861                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
862                 src += s->linesize;
863             }
864             src = srcU; src2 = srcV;
865             for(j = 0; j < 9; j++) {
866                 for(i = 0; i < 9; i++) {
867                     src[i] = ((src[i] - 128) >> 1) + 128;
868                     src2[i] = ((src2[i] - 128) >> 1) + 128;
869                 }
870                 src += s->uvlinesize;
871                 src2 += s->uvlinesize;
872             }
873         }
874         /* if we deal with intensity compensation we need to scale source blocks */
875         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
876             int i, j;
877             uint8_t *src, *src2;
878
879             src = srcY;
880             for(j = 0; j < 17 + s->mspel*2; j++) {
881                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
882                 src += s->linesize;
883             }
884             src = srcU; src2 = srcV;
885             for(j = 0; j < 9; j++) {
886                 for(i = 0; i < 9; i++) {
887                     src[i] = v->lutuv[src[i]];
888                     src2[i] = v->lutuv[src2[i]];
889                 }
890                 src += s->uvlinesize;
891                 src2 += s->uvlinesize;
892             }
893         }
894         srcY += s->mspel * (1 + s->linesize);
895     }
896
897     if(s->mspel) {
898         dxy = ((my & 3) << 2) | (mx & 3);
899         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0]    , srcY    , s->linesize, v->rnd);
900         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
901         srcY += s->linesize * 8;
902         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
903         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
904     } else { // hpel mc - always used for luma
905         dxy = (my & 2) | ((mx & 2) >> 1);
906
907         if(!v->rnd)
908             dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
909         else
910             dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
911     }
912
913     if(s->flags & CODEC_FLAG_GRAY) return;
914     /* Chroma MC always uses qpel bilinear */
915     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
916     uvmx = (uvmx&3)<<1;
917     uvmy = (uvmy&3)<<1;
918     if(!v->rnd){
919         dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
920         dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
921     }else{
922         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
923         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
924     }
925 }
926
927 /** Do motion compensation for 4-MV macroblock - luminance block
928  */
929 static void vc1_mc_4mv_luma(VC1Context *v, int n)
930 {
931     MpegEncContext *s = &v->s;
932     DSPContext *dsp = &v->s.dsp;
933     uint8_t *srcY;
934     int dxy, mx, my, src_x, src_y;
935     int off;
936
937     if(!v->s.last_picture.data[0])return;
938     mx = s->mv[0][n][0];
939     my = s->mv[0][n][1];
940     srcY = s->last_picture.data[0];
941
942     off = s->linesize * 4 * (n&2) + (n&1) * 8;
943
944     src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
945     src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
946
947     src_x   = clip(  src_x, -16, s->mb_width  * 16);
948     src_y   = clip(  src_y, -16, s->mb_height * 16);
949
950     srcY += src_y * s->linesize + src_x;
951
952     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
953        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
954        || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
955         srcY -= s->mspel * (1 + s->linesize);
956         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
957                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
958         srcY = s->edge_emu_buffer;
959         /* if we deal with range reduction we need to scale source blocks */
960         if(v->rangeredfrm) {
961             int i, j;
962             uint8_t *src;
963
964             src = srcY;
965             for(j = 0; j < 9 + s->mspel*2; j++) {
966                 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
967                 src += s->linesize;
968             }
969         }
970         /* if we deal with intensity compensation we need to scale source blocks */
971         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
972             int i, j;
973             uint8_t *src;
974
975             src = srcY;
976             for(j = 0; j < 9 + s->mspel*2; j++) {
977                 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
978                 src += s->linesize;
979             }
980         }
981         srcY += s->mspel * (1 + s->linesize);
982     }
983
984     if(s->mspel) {
985         dxy = ((my & 3) << 2) | (mx & 3);
986         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
987     } else { // hpel mc - always used for luma
988         dxy = (my & 2) | ((mx & 2) >> 1);
989         if(!v->rnd)
990             dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
991         else
992             dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
993     }
994 }
995
996 static inline int median4(int a, int b, int c, int d)
997 {
998     if(a < b) {
999         if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
1000         else      return (FFMIN(b, c) + FFMAX(a, d)) / 2;
1001     } else {
1002         if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
1003         else      return (FFMIN(a, c) + FFMAX(b, d)) / 2;
1004     }
1005 }
1006
1007
1008 /** Do motion compensation for 4-MV macroblock - both chroma blocks
1009  */
1010 static void vc1_mc_4mv_chroma(VC1Context *v)
1011 {
1012     MpegEncContext *s = &v->s;
1013     DSPContext *dsp = &v->s.dsp;
1014     uint8_t *srcU, *srcV;
1015     int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1016     int i, idx, tx = 0, ty = 0;
1017     int mvx[4], mvy[4], intra[4];
1018     static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1019
1020     if(!v->s.last_picture.data[0])return;
1021     if(s->flags & CODEC_FLAG_GRAY) return;
1022
1023     for(i = 0; i < 4; i++) {
1024         mvx[i] = s->mv[0][i][0];
1025         mvy[i] = s->mv[0][i][1];
1026         intra[i] = v->mb_type[0][s->block_index[i]];
1027     }
1028
1029     /* calculate chroma MV vector from four luma MVs */
1030     idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1031     if(!idx) { // all blocks are inter
1032         tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1033         ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1034     } else if(count[idx] == 1) { // 3 inter blocks
1035         switch(idx) {
1036         case 0x1:
1037             tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1038             ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1039             break;
1040         case 0x2:
1041             tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1042             ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1043             break;
1044         case 0x4:
1045             tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1046             ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1047             break;
1048         case 0x8:
1049             tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1050             ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1051             break;
1052         }
1053     } else if(count[idx] == 2) {
1054         int t1 = 0, t2 = 0;
1055         for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1056         for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1057         tx = (mvx[t1] + mvx[t2]) / 2;
1058         ty = (mvy[t1] + mvy[t2]) / 2;
1059     } else
1060         return; //no need to do MC for inter blocks
1061
1062     s->current_picture.motion_val[1][s->block_index[0]][0] = tx;
1063     s->current_picture.motion_val[1][s->block_index[0]][1] = ty;
1064     uvmx = (tx + ((tx&3) == 3)) >> 1;
1065     uvmy = (ty + ((ty&3) == 3)) >> 1;
1066     if(v->fastuvmc) {
1067         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1068         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1069     }
1070
1071     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1072     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1073
1074     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
1075     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
1076     srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1077     srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1078     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1079        || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
1080        || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
1081         ff_emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize, 8+1, 8+1,
1082                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1083         ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1084                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1085         srcU = s->edge_emu_buffer;
1086         srcV = s->edge_emu_buffer + 16;
1087
1088         /* if we deal with range reduction we need to scale source blocks */
1089         if(v->rangeredfrm) {
1090             int i, j;
1091             uint8_t *src, *src2;
1092
1093             src = srcU; src2 = srcV;
1094             for(j = 0; j < 9; j++) {
1095                 for(i = 0; i < 9; i++) {
1096                     src[i] = ((src[i] - 128) >> 1) + 128;
1097                     src2[i] = ((src2[i] - 128) >> 1) + 128;
1098                 }
1099                 src += s->uvlinesize;
1100                 src2 += s->uvlinesize;
1101             }
1102         }
1103         /* if we deal with intensity compensation we need to scale source blocks */
1104         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1105             int i, j;
1106             uint8_t *src, *src2;
1107
1108             src = srcU; src2 = srcV;
1109             for(j = 0; j < 9; j++) {
1110                 for(i = 0; i < 9; i++) {
1111                     src[i] = v->lutuv[src[i]];
1112                     src2[i] = v->lutuv[src2[i]];
1113                 }
1114                 src += s->uvlinesize;
1115                 src2 += s->uvlinesize;
1116             }
1117         }
1118     }
1119
1120     /* Chroma MC always uses qpel bilinear */
1121     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
1122     uvmx = (uvmx&3)<<1;
1123     uvmy = (uvmy&3)<<1;
1124     if(!v->rnd){
1125         dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1126         dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1127     }else{
1128         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1129         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1130     }
1131 }
1132
1133 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
1134
1135 /**
1136  * Decode Simple/Main Profiles sequence header
1137  * @see Figure 7-8, p16-17
1138  * @param avctx Codec context
1139  * @param gb GetBit context initialized from Codec context extra_data
1140  * @return Status
1141  */
1142 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1143 {
1144     VC1Context *v = avctx->priv_data;
1145
1146     av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
1147     v->profile = get_bits(gb, 2);
1148     if (v->profile == 2)
1149     {
1150         av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1151         return -1;
1152     }
1153
1154     if (v->profile == PROFILE_ADVANCED)
1155     {
1156         return decode_sequence_header_adv(v, gb);
1157     }
1158     else
1159     {
1160         v->res_sm = get_bits(gb, 2); //reserved
1161         if (v->res_sm)
1162         {
1163             av_log(avctx, AV_LOG_ERROR,
1164                    "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1165             return -1;
1166         }
1167     }
1168
1169     // (fps-2)/4 (->30)
1170     v->frmrtq_postproc = get_bits(gb, 3); //common
1171     // (bitrate-32kbps)/64kbps
1172     v->bitrtq_postproc = get_bits(gb, 5); //common
1173     v->s.loop_filter = get_bits(gb, 1); //common
1174     if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1175     {
1176         av_log(avctx, AV_LOG_ERROR,
1177                "LOOPFILTER shell not be enabled in simple profile\n");
1178     }
1179
1180     v->res_x8 = get_bits(gb, 1); //reserved
1181     if (v->res_x8)
1182     {
1183         av_log(avctx, AV_LOG_ERROR,
1184                "1 for reserved RES_X8 is forbidden\n");
1185         //return -1;
1186     }
1187     v->multires = get_bits(gb, 1);
1188     v->res_fasttx = get_bits(gb, 1);
1189     if (!v->res_fasttx)
1190     {
1191         av_log(avctx, AV_LOG_ERROR,
1192                "0 for reserved RES_FASTTX is forbidden\n");
1193         //return -1;
1194     }
1195
1196     v->fastuvmc =  get_bits(gb, 1); //common
1197     if (!v->profile && !v->fastuvmc)
1198     {
1199         av_log(avctx, AV_LOG_ERROR,
1200                "FASTUVMC unavailable in Simple Profile\n");
1201         return -1;
1202     }
1203     v->extended_mv =  get_bits(gb, 1); //common
1204     if (!v->profile && v->extended_mv)
1205     {
1206         av_log(avctx, AV_LOG_ERROR,
1207                "Extended MVs unavailable in Simple Profile\n");
1208         return -1;
1209     }
1210     v->dquant =  get_bits(gb, 2); //common
1211     v->vstransform =  get_bits(gb, 1); //common
1212
1213     v->res_transtab = get_bits(gb, 1);
1214     if (v->res_transtab)
1215     {
1216         av_log(avctx, AV_LOG_ERROR,
1217                "1 for reserved RES_TRANSTAB is forbidden\n");
1218         return -1;
1219     }
1220
1221     v->overlap = get_bits(gb, 1); //common
1222
1223     v->s.resync_marker = get_bits(gb, 1);
1224     v->rangered = get_bits(gb, 1);
1225     if (v->rangered && v->profile == PROFILE_SIMPLE)
1226     {
1227         av_log(avctx, AV_LOG_INFO,
1228                "RANGERED should be set to 0 in simple profile\n");
1229     }
1230
1231     v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1232     v->quantizer_mode = get_bits(gb, 2); //common
1233
1234     v->finterpflag = get_bits(gb, 1); //common
1235     v->res_rtm_flag = get_bits(gb, 1); //reserved
1236     if (!v->res_rtm_flag)
1237     {
1238 //            av_log(avctx, AV_LOG_ERROR,
1239 //                   "0 for reserved RES_RTM_FLAG is forbidden\n");
1240         av_log(avctx, AV_LOG_ERROR,
1241                "Old WMV3 version detected, only I-frames will be decoded\n");
1242         //return -1;
1243     }
1244     av_log(avctx, AV_LOG_DEBUG,
1245                "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1246                "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1247                "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1248                "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1249                v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1250                v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1251                v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1252                v->dquant, v->quantizer_mode, avctx->max_b_frames
1253                );
1254     return 0;
1255 }
1256
1257 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
1258 {
1259     v->res_rtm_flag = 1;
1260     v->level = get_bits(gb, 3);
1261     if(v->level >= 5)
1262     {
1263         av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1264     }
1265     v->chromaformat = get_bits(gb, 2);
1266     if (v->chromaformat != 1)
1267     {
1268         av_log(v->s.avctx, AV_LOG_ERROR,
1269                "Only 4:2:0 chroma format supported\n");
1270         return -1;
1271     }
1272
1273     // (fps-2)/4 (->30)
1274     v->frmrtq_postproc = get_bits(gb, 3); //common
1275     // (bitrate-32kbps)/64kbps
1276     v->bitrtq_postproc = get_bits(gb, 5); //common
1277     v->postprocflag = get_bits(gb, 1); //common
1278
1279     v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
1280     v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
1281     v->broadcast = get_bits1(gb);
1282     v->interlace = get_bits1(gb);
1283     if(v->interlace){
1284         av_log(v->s.avctx, AV_LOG_ERROR, "Interlaced mode not supported (yet)\n");
1285         return -1;
1286     }
1287     v->tfcntrflag = get_bits1(gb);
1288     v->finterpflag = get_bits1(gb);
1289     get_bits1(gb); // reserved
1290
1291     av_log(v->s.avctx, AV_LOG_DEBUG,
1292                "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1293                "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
1294                "TFCTRflag=%i, FINTERPflag=%i\n",
1295                v->level, v->frmrtq_postproc, v->bitrtq_postproc,
1296                v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
1297                v->tfcntrflag, v->finterpflag
1298                );
1299
1300     v->psf = get_bits1(gb);
1301     if(v->psf) { //PsF, 6.1.13
1302         av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
1303         return -1;
1304     }
1305     if(get_bits1(gb)) { //Display Info - decoding is not affected by it
1306         int w, h, ar = 0;
1307         av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
1308         v->s.avctx->width  = v->s.width  = w = get_bits(gb, 14) + 1;
1309         v->s.avctx->height = v->s.height = h = get_bits(gb, 14) + 1;
1310         av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
1311         if(get_bits1(gb))
1312             ar = get_bits(gb, 4);
1313         if(ar && ar < 14){
1314             v->s.avctx->sample_aspect_ratio = vc1_pixel_aspect[ar];
1315         }else if(ar == 15){
1316             w = get_bits(gb, 8);
1317             h = get_bits(gb, 8);
1318             v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
1319         }
1320
1321         if(get_bits1(gb)){ //framerate stuff
1322             if(get_bits1(gb)) {
1323                 v->s.avctx->time_base.num = 32;
1324                 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
1325             } else {
1326                 int nr, dr;
1327                 nr = get_bits(gb, 8);
1328                 dr = get_bits(gb, 4);
1329                 if(nr && nr < 8 && dr && dr < 3){
1330                     v->s.avctx->time_base.num = fps_dr[dr - 1];
1331                     v->s.avctx->time_base.den = fps_nr[nr - 1] * 1000;
1332                 }
1333             }
1334         }
1335
1336         if(get_bits1(gb)){
1337             v->color_prim = get_bits(gb, 8);
1338             v->transfer_char = get_bits(gb, 8);
1339             v->matrix_coef = get_bits(gb, 8);
1340         }
1341     }
1342
1343     v->hrd_param_flag = get_bits1(gb);
1344     if(v->hrd_param_flag) {
1345         int i;
1346         v->hrd_num_leaky_buckets = get_bits(gb, 5);
1347         get_bits(gb, 4); //bitrate exponent
1348         get_bits(gb, 4); //buffer size exponent
1349         for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1350             get_bits(gb, 16); //hrd_rate[n]
1351             get_bits(gb, 16); //hrd_buffer[n]
1352         }
1353     }
1354     return 0;
1355 }
1356
1357 static int decode_entry_point(AVCodecContext *avctx, GetBitContext *gb)
1358 {
1359     VC1Context *v = avctx->priv_data;
1360     int i, blink, refdist;
1361
1362     av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
1363     blink = get_bits1(gb); // broken link
1364     avctx->max_b_frames = 1 - get_bits1(gb); // 'closed entry' also signalize possible B-frames
1365     v->panscanflag = get_bits1(gb);
1366     refdist = get_bits1(gb); // refdist flag
1367     v->s.loop_filter = get_bits1(gb);
1368     v->fastuvmc = get_bits1(gb);
1369     v->extended_mv = get_bits1(gb);
1370     v->dquant = get_bits(gb, 2);
1371     v->vstransform = get_bits1(gb);
1372     v->overlap = get_bits1(gb);
1373     v->quantizer_mode = get_bits(gb, 2);
1374
1375     if(v->hrd_param_flag){
1376         for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1377             get_bits(gb, 8); //hrd_full[n]
1378         }
1379     }
1380
1381     if(get_bits1(gb)){
1382         avctx->coded_width = (get_bits(gb, 12)+1)<<1;
1383         avctx->coded_height = (get_bits(gb, 12)+1)<<1;
1384     }
1385     if(v->extended_mv)
1386         v->extended_dmv = get_bits1(gb);
1387     if(get_bits1(gb)) {
1388         av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
1389         skip_bits(gb, 3); // Y range, ignored for now
1390     }
1391     if(get_bits1(gb)) {
1392         av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
1393         skip_bits(gb, 3); // UV range, ignored for now
1394     }
1395
1396     av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
1397         "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1398         "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1399         "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1400         blink, 1 - avctx->max_b_frames, v->panscanflag, refdist, v->s.loop_filter,
1401         v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
1402
1403     return 0;
1404 }
1405
1406 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1407 {
1408     int pqindex, lowquant, status;
1409
1410     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1411     skip_bits(gb, 2); //framecnt unused
1412     v->rangeredfrm = 0;
1413     if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1414     v->s.pict_type = get_bits(gb, 1);
1415     if (v->s.avctx->max_b_frames) {
1416         if (!v->s.pict_type) {
1417             if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1418             else v->s.pict_type = B_TYPE;
1419         } else v->s.pict_type = P_TYPE;
1420     } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1421
1422     v->bi_type = 0;
1423     if(v->s.pict_type == B_TYPE) {
1424         v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1425         v->bfraction = vc1_bfraction_lut[v->bfraction];
1426         if(v->bfraction == 0) {
1427             v->s.pict_type = BI_TYPE;
1428         }
1429     }
1430     if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1431         get_bits(gb, 7); // skip buffer fullness
1432
1433     /* calculate RND */
1434     if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1435         v->rnd = 1;
1436     if(v->s.pict_type == P_TYPE)
1437         v->rnd ^= 1;
1438
1439     /* Quantizer stuff */
1440     pqindex = get_bits(gb, 5);
1441     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1442         v->pq = pquant_table[0][pqindex];
1443     else
1444         v->pq = pquant_table[1][pqindex];
1445
1446     v->pquantizer = 1;
1447     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1448         v->pquantizer = pqindex < 9;
1449     if (v->quantizer_mode == QUANT_NON_UNIFORM)
1450         v->pquantizer = 0;
1451     v->pqindex = pqindex;
1452     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1453     else v->halfpq = 0;
1454     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1455         v->pquantizer = get_bits(gb, 1);
1456     v->dquantfrm = 0;
1457     if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1458     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1459     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1460     v->range_x = 1 << (v->k_x - 1);
1461     v->range_y = 1 << (v->k_y - 1);
1462     if (v->profile == PROFILE_ADVANCED)
1463     {
1464         if (v->postprocflag) v->postproc = get_bits(gb, 1);
1465     }
1466     else
1467         if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1468
1469 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1470 //        (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1471
1472     if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
1473
1474     switch(v->s.pict_type) {
1475     case P_TYPE:
1476         if (v->pq < 5) v->tt_index = 0;
1477         else if(v->pq < 13) v->tt_index = 1;
1478         else v->tt_index = 2;
1479
1480         lowquant = (v->pq > 12) ? 0 : 1;
1481         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1482         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1483         {
1484             int scale, shift, i;
1485             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1486             v->lumscale = get_bits(gb, 6);
1487             v->lumshift = get_bits(gb, 6);
1488             v->use_ic = 1;
1489             /* fill lookup tables for intensity compensation */
1490             if(!v->lumscale) {
1491                 scale = -64;
1492                 shift = (255 - v->lumshift * 2) << 6;
1493                 if(v->lumshift > 31)
1494                     shift += 128 << 6;
1495             } else {
1496                 scale = v->lumscale + 32;
1497                 if(v->lumshift > 31)
1498                     shift = (v->lumshift - 64) << 6;
1499                 else
1500                     shift = v->lumshift << 6;
1501             }
1502             for(i = 0; i < 256; i++) {
1503                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1504                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1505             }
1506         }
1507         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1508             v->s.quarter_sample = 0;
1509         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1510             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1511                 v->s.quarter_sample = 0;
1512             else
1513                 v->s.quarter_sample = 1;
1514         } else
1515             v->s.quarter_sample = 1;
1516         v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1517
1518         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1519                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1520                 || v->mv_mode == MV_PMODE_MIXED_MV)
1521         {
1522             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1523             if (status < 0) return -1;
1524             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1525                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1526         } else {
1527             v->mv_type_is_raw = 0;
1528             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1529         }
1530         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1531         if (status < 0) return -1;
1532         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1533                "Imode: %i, Invert: %i\n", status>>1, status&1);
1534
1535         /* Hopefully this is correct for P frames */
1536         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1537         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1538
1539         if (v->dquant)
1540         {
1541             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1542             vop_dquant_decoding(v);
1543         }
1544
1545         v->ttfrm = 0; //FIXME Is that so ?
1546         if (v->vstransform)
1547         {
1548             v->ttmbf = get_bits(gb, 1);
1549             if (v->ttmbf)
1550             {
1551                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1552             }
1553         } else {
1554             v->ttmbf = 1;
1555             v->ttfrm = TT_8X8;
1556         }
1557         break;
1558     case B_TYPE:
1559         if (v->pq < 5) v->tt_index = 0;
1560         else if(v->pq < 13) v->tt_index = 1;
1561         else v->tt_index = 2;
1562
1563         lowquant = (v->pq > 12) ? 0 : 1;
1564         v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1565         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1566         v->s.mspel = v->s.quarter_sample;
1567
1568         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1569         if (status < 0) return -1;
1570         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1571                "Imode: %i, Invert: %i\n", status>>1, status&1);
1572         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1573         if (status < 0) return -1;
1574         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1575                "Imode: %i, Invert: %i\n", status>>1, status&1);
1576
1577         v->s.mv_table_index = get_bits(gb, 2);
1578         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1579
1580         if (v->dquant)
1581         {
1582             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1583             vop_dquant_decoding(v);
1584         }
1585
1586         v->ttfrm = 0;
1587         if (v->vstransform)
1588         {
1589             v->ttmbf = get_bits(gb, 1);
1590             if (v->ttmbf)
1591             {
1592                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1593             }
1594         } else {
1595             v->ttmbf = 1;
1596             v->ttfrm = TT_8X8;
1597         }
1598         break;
1599     }
1600
1601     /* AC Syntax */
1602     v->c_ac_table_index = decode012(gb);
1603     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1604     {
1605         v->y_ac_table_index = decode012(gb);
1606     }
1607     /* DC Syntax */
1608     v->s.dc_table_index = get_bits(gb, 1);
1609
1610     if(v->s.pict_type == BI_TYPE) {
1611         v->s.pict_type = B_TYPE;
1612         v->bi_type = 1;
1613     }
1614     return 0;
1615 }
1616
1617 static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
1618 {
1619     int fcm;
1620     int pqindex, lowquant;
1621     int status;
1622
1623     v->p_frame_skipped = 0;
1624
1625     if(v->interlace)
1626         fcm = decode012(gb);
1627     switch(get_prefix(gb, 0, 4)) {
1628     case 0:
1629         v->s.pict_type = P_TYPE;
1630         break;
1631     case 1:
1632         v->s.pict_type = B_TYPE;
1633         break;
1634     case 2:
1635         v->s.pict_type = I_TYPE;
1636         break;
1637     case 3:
1638         v->s.pict_type = BI_TYPE;
1639         break;
1640     case 4:
1641         v->s.pict_type = P_TYPE; // skipped pic
1642         v->p_frame_skipped = 1;
1643         return 0;
1644     }
1645     if(v->tfcntrflag)
1646         get_bits(gb, 8);
1647     if(v->broadcast) {
1648         if(!v->interlace || v->panscanflag) {
1649             get_bits(gb, 2);
1650         } else {
1651             get_bits1(gb);
1652             get_bits1(gb);
1653         }
1654     }
1655     if(v->panscanflag) {
1656         //...
1657     }
1658     v->rnd = get_bits1(gb);
1659     if(v->interlace)
1660         v->uvsamp = get_bits1(gb);
1661     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1662     if(v->s.pict_type == B_TYPE) {
1663         v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1664         v->bfraction = vc1_bfraction_lut[v->bfraction];
1665         if(v->bfraction == 0) {
1666             v->s.pict_type = BI_TYPE; /* XXX: should not happen here */
1667         }
1668     }
1669     pqindex = get_bits(gb, 5);
1670     v->pqindex = pqindex;
1671     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1672         v->pq = pquant_table[0][pqindex];
1673     else
1674         v->pq = pquant_table[1][pqindex];
1675
1676     v->pquantizer = 1;
1677     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1678         v->pquantizer = pqindex < 9;
1679     if (v->quantizer_mode == QUANT_NON_UNIFORM)
1680         v->pquantizer = 0;
1681     v->pqindex = pqindex;
1682     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1683     else v->halfpq = 0;
1684     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1685         v->pquantizer = get_bits(gb, 1);
1686
1687     switch(v->s.pict_type) {
1688     case I_TYPE:
1689     case BI_TYPE:
1690         status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1691         if (status < 0) return -1;
1692         av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1693                 "Imode: %i, Invert: %i\n", status>>1, status&1);
1694         v->condover = CONDOVER_NONE;
1695         if(v->overlap && v->pq <= 8) {
1696             v->condover = decode012(gb);
1697             if(v->condover == CONDOVER_SELECT) {
1698                 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1699                 if (status < 0) return -1;
1700                 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1701                         "Imode: %i, Invert: %i\n", status>>1, status&1);
1702             }
1703         }
1704         break;
1705     case P_TYPE:
1706         if(v->postprocflag)
1707             v->postproc = get_bits1(gb);
1708         if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1709         else v->mvrange = 0;
1710         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1711         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1712         v->range_x = 1 << (v->k_x - 1);
1713         v->range_y = 1 << (v->k_y - 1);
1714
1715         if (v->pq < 5) v->tt_index = 0;
1716         else if(v->pq < 13) v->tt_index = 1;
1717         else v->tt_index = 2;
1718
1719         lowquant = (v->pq > 12) ? 0 : 1;
1720         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1721         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1722         {
1723             int scale, shift, i;
1724             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1725             v->lumscale = get_bits(gb, 6);
1726             v->lumshift = get_bits(gb, 6);
1727             /* fill lookup tables for intensity compensation */
1728             if(!v->lumscale) {
1729                 scale = -64;
1730                 shift = (255 - v->lumshift * 2) << 6;
1731                 if(v->lumshift > 31)
1732                     shift += 128 << 6;
1733             } else {
1734                 scale = v->lumscale + 32;
1735                 if(v->lumshift > 31)
1736                     shift = (v->lumshift - 64) << 6;
1737                 else
1738                     shift = v->lumshift << 6;
1739             }
1740             for(i = 0; i < 256; i++) {
1741                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1742                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1743             }
1744         }
1745         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1746             v->s.quarter_sample = 0;
1747         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1748             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1749                 v->s.quarter_sample = 0;
1750             else
1751                 v->s.quarter_sample = 1;
1752         } else
1753             v->s.quarter_sample = 1;
1754         v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1755
1756         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1757                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1758                 || v->mv_mode == MV_PMODE_MIXED_MV)
1759         {
1760             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1761             if (status < 0) return -1;
1762             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1763                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1764         } else {
1765             v->mv_type_is_raw = 0;
1766             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1767         }
1768         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1769         if (status < 0) return -1;
1770         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1771                "Imode: %i, Invert: %i\n", status>>1, status&1);
1772
1773         /* Hopefully this is correct for P frames */
1774         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1775         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1776         if (v->dquant)
1777         {
1778             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1779             vop_dquant_decoding(v);
1780         }
1781
1782         v->ttfrm = 0; //FIXME Is that so ?
1783         if (v->vstransform)
1784         {
1785             v->ttmbf = get_bits(gb, 1);
1786             if (v->ttmbf)
1787             {
1788                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1789             }
1790         } else {
1791             v->ttmbf = 1;
1792             v->ttfrm = TT_8X8;
1793         }
1794         break;
1795     case B_TYPE:
1796         if(v->postprocflag)
1797             v->postproc = get_bits1(gb);
1798         if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1799         else v->mvrange = 0;
1800         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1801         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1802         v->range_x = 1 << (v->k_x - 1);
1803         v->range_y = 1 << (v->k_y - 1);
1804
1805         if (v->pq < 5) v->tt_index = 0;
1806         else if(v->pq < 13) v->tt_index = 1;
1807         else v->tt_index = 2;
1808
1809         lowquant = (v->pq > 12) ? 0 : 1;
1810         v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1811         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1812         v->s.mspel = v->s.quarter_sample;
1813
1814         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1815         if (status < 0) return -1;
1816         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1817                "Imode: %i, Invert: %i\n", status>>1, status&1);
1818         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1819         if (status < 0) return -1;
1820         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1821                "Imode: %i, Invert: %i\n", status>>1, status&1);
1822
1823         v->s.mv_table_index = get_bits(gb, 2);
1824         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1825
1826         if (v->dquant)
1827         {
1828             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1829             vop_dquant_decoding(v);
1830         }
1831
1832         v->ttfrm = 0;
1833         if (v->vstransform)
1834         {
1835             v->ttmbf = get_bits(gb, 1);
1836             if (v->ttmbf)
1837             {
1838                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1839             }
1840         } else {
1841             v->ttmbf = 1;
1842             v->ttfrm = TT_8X8;
1843         }
1844         break;
1845     }
1846
1847     /* AC Syntax */
1848     v->c_ac_table_index = decode012(gb);
1849     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1850     {
1851         v->y_ac_table_index = decode012(gb);
1852     }
1853     /* DC Syntax */
1854     v->s.dc_table_index = get_bits(gb, 1);
1855     if ((v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE) && v->dquant) {
1856         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1857         vop_dquant_decoding(v);
1858     }
1859
1860     v->bi_type = 0;
1861     if(v->s.pict_type == BI_TYPE) {
1862         v->s.pict_type = B_TYPE;
1863         v->bi_type = 1;
1864     }
1865     return 0;
1866 }
1867
1868 /***********************************************************************/
1869 /**
1870  * @defgroup block VC-1 Block-level functions
1871  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1872  * @{
1873  */
1874
1875 /**
1876  * @def GET_MQUANT
1877  * @brief Get macroblock-level quantizer scale
1878  */
1879 #define GET_MQUANT()                                           \
1880   if (v->dquantfrm)                                            \
1881   {                                                            \
1882     int edges = 0;                                             \
1883     if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1884     {                                                          \
1885       if (v->dqbilevel)                                        \
1886       {                                                        \
1887         mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
1888       }                                                        \
1889       else                                                     \
1890       {                                                        \
1891         mqdiff = get_bits(gb, 3);                              \
1892         if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1893         else mquant = get_bits(gb, 5);                         \
1894       }                                                        \
1895     }                                                          \
1896     if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
1897         edges = 1 << v->dqsbedge;                              \
1898     else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1899         edges = (3 << v->dqsbedge) % 15;                       \
1900     else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1901         edges = 15;                                            \
1902     if((edges&1) && !s->mb_x)                                  \
1903         mquant = v->altpq;                                     \
1904     if((edges&2) && s->first_slice_line)                       \
1905         mquant = v->altpq;                                     \
1906     if((edges&4) && s->mb_x == (s->mb_width - 1))              \
1907         mquant = v->altpq;                                     \
1908     if((edges&8) && s->mb_y == (s->mb_height - 1))             \
1909         mquant = v->altpq;                                     \
1910   }
1911
1912 /**
1913  * @def GET_MVDATA(_dmv_x, _dmv_y)
1914  * @brief Get MV differentials
1915  * @see MVDATA decoding from 8.3.5.2, p(1)20
1916  * @param _dmv_x Horizontal differential for decoded MV
1917  * @param _dmv_y Vertical differential for decoded MV
1918  */
1919 #define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1920   index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1921                        VC1_MV_DIFF_VLC_BITS, 2);                    \
1922   if (index > 36)                                                   \
1923   {                                                                 \
1924     mb_has_coeffs = 1;                                              \
1925     index -= 37;                                                    \
1926   }                                                                 \
1927   else mb_has_coeffs = 0;                                           \
1928   s->mb_intra = 0;                                                  \
1929   if (!index) { _dmv_x = _dmv_y = 0; }                              \
1930   else if (index == 35)                                             \
1931   {                                                                 \
1932     _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1933     _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1934   }                                                                 \
1935   else if (index == 36)                                             \
1936   {                                                                 \
1937     _dmv_x = 0;                                                     \
1938     _dmv_y = 0;                                                     \
1939     s->mb_intra = 1;                                                \
1940   }                                                                 \
1941   else                                                              \
1942   {                                                                 \
1943     index1 = index%6;                                               \
1944     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1945     else                                   val = 0;                 \
1946     if(size_table[index1] - val > 0)                                \
1947         val = get_bits(gb, size_table[index1] - val);               \
1948     else                                   val = 0;                 \
1949     sign = 0 - (val&1);                                             \
1950     _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1951                                                                     \
1952     index1 = index/6;                                               \
1953     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1954     else                                   val = 0;                 \
1955     if(size_table[index1] - val > 0)                                \
1956         val = get_bits(gb, size_table[index1] - val);               \
1957     else                                   val = 0;                 \
1958     sign = 0 - (val&1);                                             \
1959     _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1960   }
1961
1962 /** Predict and set motion vector
1963  */
1964 static inline void vc1_pred_mv(MpegEncContext *s, int n, int dmv_x, int dmv_y, int mv1, int r_x, int r_y, uint8_t* is_intra)
1965 {
1966     int xy, wrap, off = 0;
1967     int16_t *A, *B, *C;
1968     int px, py;
1969     int sum;
1970
1971     /* scale MV difference to be quad-pel */
1972     dmv_x <<= 1 - s->quarter_sample;
1973     dmv_y <<= 1 - s->quarter_sample;
1974
1975     wrap = s->b8_stride;
1976     xy = s->block_index[n];
1977
1978     if(s->mb_intra){
1979         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1980         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1981         if(mv1) { /* duplicate motion data for 1-MV block */
1982             s->current_picture.motion_val[0][xy + 1][0] = 0;
1983             s->current_picture.motion_val[0][xy + 1][1] = 0;
1984             s->current_picture.motion_val[0][xy + wrap][0] = 0;
1985             s->current_picture.motion_val[0][xy + wrap][1] = 0;
1986             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1987             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1988         }
1989         return;
1990     }
1991
1992     C = s->current_picture.motion_val[0][xy - 1];
1993     A = s->current_picture.motion_val[0][xy - wrap];
1994     if(mv1)
1995         off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1996     else {
1997         //in 4-MV mode different blocks have different B predictor position
1998         switch(n){
1999         case 0:
2000             off = (s->mb_x > 0) ? -1 : 1;
2001             break;
2002         case 1:
2003             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
2004             break;
2005         case 2:
2006             off = 1;
2007             break;
2008         case 3:
2009             off = -1;
2010         }
2011     }
2012     B = s->current_picture.motion_val[0][xy - wrap + off];
2013
2014     if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
2015         if(s->mb_width == 1) {
2016             px = A[0];
2017             py = A[1];
2018         } else {
2019             px = mid_pred(A[0], B[0], C[0]);
2020             py = mid_pred(A[1], B[1], C[1]);
2021         }
2022     } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
2023         px = C[0];
2024         py = C[1];
2025     } else {
2026         px = py = 0;
2027     }
2028     /* Pullback MV as specified in 8.3.5.3.4 */
2029     {
2030         int qx, qy, X, Y;
2031         qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
2032         qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
2033         X = (s->mb_width << 6) - 4;
2034         Y = (s->mb_height << 6) - 4;
2035         if(mv1) {
2036             if(qx + px < -60) px = -60 - qx;
2037             if(qy + py < -60) py = -60 - qy;
2038         } else {
2039             if(qx + px < -28) px = -28 - qx;
2040             if(qy + py < -28) py = -28 - qy;
2041         }
2042         if(qx + px > X) px = X - qx;
2043         if(qy + py > Y) py = Y - qy;
2044     }
2045     /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2046     if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
2047         if(is_intra[xy - wrap])
2048             sum = FFABS(px) + FFABS(py);
2049         else
2050             sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2051         if(sum > 32) {
2052             if(get_bits1(&s->gb)) {
2053                 px = A[0];
2054                 py = A[1];
2055             } else {
2056                 px = C[0];
2057                 py = C[1];
2058             }
2059         } else {
2060             if(is_intra[xy - 1])
2061                 sum = FFABS(px) + FFABS(py);
2062             else
2063                 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2064             if(sum > 32) {
2065                 if(get_bits1(&s->gb)) {
2066                     px = A[0];
2067                     py = A[1];
2068                 } else {
2069                     px = C[0];
2070                     py = C[1];
2071                 }
2072             }
2073         }
2074     }
2075     /* store MV using signed modulus of MV range defined in 4.11 */
2076     s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
2077     s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
2078     if(mv1) { /* duplicate motion data for 1-MV block */
2079         s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
2080         s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
2081         s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
2082         s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
2083         s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
2084         s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
2085     }
2086 }
2087
2088 /** Motion compensation for direct or interpolated blocks in B-frames
2089  */
2090 static void vc1_interp_mc(VC1Context *v)
2091 {
2092     MpegEncContext *s = &v->s;
2093     DSPContext *dsp = &v->s.dsp;
2094     uint8_t *srcY, *srcU, *srcV;
2095     int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
2096
2097     if(!v->s.next_picture.data[0])return;
2098
2099     mx = s->mv[1][0][0];
2100     my = s->mv[1][0][1];
2101     uvmx = (mx + ((mx & 3) == 3)) >> 1;
2102     uvmy = (my + ((my & 3) == 3)) >> 1;
2103     if(v->fastuvmc) {
2104         uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
2105         uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
2106     }
2107     srcY = s->next_picture.data[0];
2108     srcU = s->next_picture.data[1];
2109     srcV = s->next_picture.data[2];
2110
2111     src_x = s->mb_x * 16 + (mx >> 2);
2112     src_y = s->mb_y * 16 + (my >> 2);
2113     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
2114     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
2115
2116     src_x   = clip(  src_x, -16, s->mb_width  * 16);
2117     src_y   = clip(  src_y, -16, s->mb_height * 16);
2118     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
2119     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
2120
2121     srcY += src_y * s->linesize + src_x;
2122     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
2123     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
2124
2125     /* for grayscale we should not try to read from unknown area */
2126     if(s->flags & CODEC_FLAG_GRAY) {
2127         srcU = s->edge_emu_buffer + 18 * s->linesize;
2128         srcV = s->edge_emu_buffer + 18 * s->linesize;
2129     }
2130
2131     if(v->rangeredfrm
2132        || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
2133        || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
2134         uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
2135
2136         srcY -= s->mspel * (1 + s->linesize);
2137         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
2138                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
2139         srcY = s->edge_emu_buffer;
2140         ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
2141                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2142         ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
2143                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2144         srcU = uvbuf;
2145         srcV = uvbuf + 16;
2146         /* if we deal with range reduction we need to scale source blocks */
2147         if(v->rangeredfrm) {
2148             int i, j;
2149             uint8_t *src, *src2;
2150
2151             src = srcY;
2152             for(j = 0; j < 17 + s->mspel*2; j++) {
2153                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
2154                 src += s->linesize;
2155             }
2156             src = srcU; src2 = srcV;
2157             for(j = 0; j < 9; j++) {
2158                 for(i = 0; i < 9; i++) {
2159                     src[i] = ((src[i] - 128) >> 1) + 128;
2160                     src2[i] = ((src2[i] - 128) >> 1) + 128;
2161                 }
2162                 src += s->uvlinesize;
2163                 src2 += s->uvlinesize;
2164             }
2165         }
2166         srcY += s->mspel * (1 + s->linesize);
2167     }
2168
2169     mx >>= 1;
2170     my >>= 1;
2171     dxy = ((my & 1) << 1) | (mx & 1);
2172
2173     dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
2174
2175     if(s->flags & CODEC_FLAG_GRAY) return;
2176     /* Chroma MC always uses qpel blilinear */
2177     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
2178     uvmx = (uvmx&3)<<1;
2179     uvmy = (uvmy&3)<<1;
2180     dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
2181     dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
2182 }
2183
2184 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2185 {
2186     int n = bfrac;
2187
2188 #if B_FRACTION_DEN==256
2189     if(inv)
2190         n -= 256;
2191     if(!qs)
2192         return 2 * ((value * n + 255) >> 9);
2193     return (value * n + 128) >> 8;
2194 #else
2195     if(inv)
2196         n -= B_FRACTION_DEN;
2197     if(!qs)
2198         return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2199     return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2200 #endif
2201 }
2202
2203 /** Reconstruct motion vector for B-frame and do motion compensation
2204  */
2205 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
2206 {
2207     if(v->use_ic) {
2208         v->mv_mode2 = v->mv_mode;
2209         v->mv_mode = MV_PMODE_INTENSITY_COMP;
2210     }
2211     if(direct) {
2212         vc1_mc_1mv(v, 0);
2213         vc1_interp_mc(v);
2214         if(v->use_ic) v->mv_mode = v->mv_mode2;
2215         return;
2216     }
2217     if(mode == BMV_TYPE_INTERPOLATED) {
2218         vc1_mc_1mv(v, 0);
2219         vc1_interp_mc(v);
2220         if(v->use_ic) v->mv_mode = v->mv_mode2;
2221         return;
2222     }
2223
2224     if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
2225     vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2226     if(v->use_ic) v->mv_mode = v->mv_mode2;
2227 }
2228
2229 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
2230 {
2231     MpegEncContext *s = &v->s;
2232     int xy, wrap, off = 0;
2233     int16_t *A, *B, *C;
2234     int px, py;
2235     int sum;
2236     int r_x, r_y;
2237     const uint8_t *is_intra = v->mb_type[0];
2238
2239     r_x = v->range_x;
2240     r_y = v->range_y;
2241     /* scale MV difference to be quad-pel */
2242     dmv_x[0] <<= 1 - s->quarter_sample;
2243     dmv_y[0] <<= 1 - s->quarter_sample;
2244     dmv_x[1] <<= 1 - s->quarter_sample;
2245     dmv_y[1] <<= 1 - s->quarter_sample;
2246
2247     wrap = s->b8_stride;
2248     xy = s->block_index[0];
2249
2250     if(s->mb_intra) {
2251         s->current_picture.motion_val[0][xy][0] =
2252         s->current_picture.motion_val[0][xy][1] =
2253         s->current_picture.motion_val[1][xy][0] =
2254         s->current_picture.motion_val[1][xy][1] = 0;
2255         return;
2256     }
2257     s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2258     s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2259     s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2260     s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2261     if(direct) {
2262         s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2263         s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2264         s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2265         s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2266         return;
2267     }
2268
2269     if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2270         C = s->current_picture.motion_val[0][xy - 2];
2271         A = s->current_picture.motion_val[0][xy - wrap*2];
2272         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2273         B = s->current_picture.motion_val[0][xy - wrap*2 + off];
2274
2275         if(!s->first_slice_line) { // predictor A is not out of bounds
2276             if(s->mb_width == 1) {
2277                 px = A[0];
2278                 py = A[1];
2279             } else {
2280                 px = mid_pred(A[0], B[0], C[0]);
2281                 py = mid_pred(A[1], B[1], C[1]);
2282             }
2283         } else if(s->mb_x) { // predictor C is not out of bounds
2284             px = C[0];
2285             py = C[1];
2286         } else {
2287             px = py = 0;
2288         }
2289         /* Pullback MV as specified in 8.3.5.3.4 */
2290         {
2291             int qx, qy, X, Y;
2292             if(v->profile < PROFILE_ADVANCED) {
2293                 qx = (s->mb_x << 5);
2294                 qy = (s->mb_y << 5);
2295                 X = (s->mb_width << 5) - 4;
2296                 Y = (s->mb_height << 5) - 4;
2297                 if(qx + px < -28) px = -28 - qx;
2298                 if(qy + py < -28) py = -28 - qy;
2299                 if(qx + px > X) px = X - qx;
2300                 if(qy + py > Y) py = Y - qy;
2301             } else {
2302                 qx = (s->mb_x << 6);
2303                 qy = (s->mb_y << 6);
2304                 X = (s->mb_width << 6) - 4;
2305                 Y = (s->mb_height << 6) - 4;
2306                 if(qx + px < -60) px = -60 - qx;
2307                 if(qy + py < -60) py = -60 - qy;
2308                 if(qx + px > X) px = X - qx;
2309                 if(qy + py > Y) py = Y - qy;
2310             }
2311         }
2312         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2313         if(0 && !s->first_slice_line && s->mb_x) {
2314             if(is_intra[xy - wrap])
2315                 sum = FFABS(px) + FFABS(py);
2316             else
2317                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2318             if(sum > 32) {
2319                 if(get_bits1(&s->gb)) {
2320                     px = A[0];
2321                     py = A[1];
2322                 } else {
2323                     px = C[0];
2324                     py = C[1];
2325                 }
2326             } else {
2327                 if(is_intra[xy - 2])
2328                     sum = FFABS(px) + FFABS(py);
2329                 else
2330                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2331                 if(sum > 32) {
2332                     if(get_bits1(&s->gb)) {
2333                         px = A[0];
2334                         py = A[1];
2335                     } else {
2336                         px = C[0];
2337                         py = C[1];
2338                     }
2339                 }
2340             }
2341         }
2342         /* store MV using signed modulus of MV range defined in 4.11 */
2343         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2344         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2345     }
2346     if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2347         C = s->current_picture.motion_val[1][xy - 2];
2348         A = s->current_picture.motion_val[1][xy - wrap*2];
2349         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2350         B = s->current_picture.motion_val[1][xy - wrap*2 + off];
2351
2352         if(!s->first_slice_line) { // predictor A is not out of bounds
2353             if(s->mb_width == 1) {
2354                 px = A[0];
2355                 py = A[1];
2356             } else {
2357                 px = mid_pred(A[0], B[0], C[0]);
2358                 py = mid_pred(A[1], B[1], C[1]);
2359             }
2360         } else if(s->mb_x) { // predictor C is not out of bounds
2361             px = C[0];
2362             py = C[1];
2363         } else {
2364             px = py = 0;
2365         }
2366         /* Pullback MV as specified in 8.3.5.3.4 */
2367         {
2368             int qx, qy, X, Y;
2369             if(v->profile < PROFILE_ADVANCED) {
2370                 qx = (s->mb_x << 5);
2371                 qy = (s->mb_y << 5);
2372                 X = (s->mb_width << 5) - 4;
2373                 Y = (s->mb_height << 5) - 4;
2374                 if(qx + px < -28) px = -28 - qx;
2375                 if(qy + py < -28) py = -28 - qy;
2376                 if(qx + px > X) px = X - qx;
2377                 if(qy + py > Y) py = Y - qy;
2378             } else {
2379                 qx = (s->mb_x << 6);
2380                 qy = (s->mb_y << 6);
2381                 X = (s->mb_width << 6) - 4;
2382                 Y = (s->mb_height << 6) - 4;
2383                 if(qx + px < -60) px = -60 - qx;
2384                 if(qy + py < -60) py = -60 - qy;
2385                 if(qx + px > X) px = X - qx;
2386                 if(qy + py > Y) py = Y - qy;
2387             }
2388         }
2389         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2390         if(0 && !s->first_slice_line && s->mb_x) {
2391             if(is_intra[xy - wrap])
2392                 sum = FFABS(px) + FFABS(py);
2393             else
2394                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2395             if(sum > 32) {
2396                 if(get_bits1(&s->gb)) {
2397                     px = A[0];
2398                     py = A[1];
2399                 } else {
2400                     px = C[0];
2401                     py = C[1];
2402                 }
2403             } else {
2404                 if(is_intra[xy - 2])
2405                     sum = FFABS(px) + FFABS(py);
2406                 else
2407                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2408                 if(sum > 32) {
2409                     if(get_bits1(&s->gb)) {
2410                         px = A[0];
2411                         py = A[1];
2412                     } else {
2413                         px = C[0];
2414                         py = C[1];
2415                     }
2416                 }
2417             }
2418         }
2419         /* store MV using signed modulus of MV range defined in 4.11 */
2420
2421         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2422         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2423     }
2424     s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2425     s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2426     s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2427     s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2428 }
2429
2430 /** Get predicted DC value for I-frames only
2431  * prediction dir: left=0, top=1
2432  * @param s MpegEncContext
2433  * @param[in] n block index in the current MB
2434  * @param dc_val_ptr Pointer to DC predictor
2435  * @param dir_ptr Prediction direction for use in AC prediction
2436  */
2437 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2438                               int16_t **dc_val_ptr, int *dir_ptr)
2439 {
2440     int a, b, c, wrap, pred, scale;
2441     int16_t *dc_val;
2442     static const uint16_t dcpred[32] = {
2443     -1, 1024,  512,  341,  256,  205,  171,  146,  128,
2444          114,  102,   93,   85,   79,   73,   68,   64,
2445           60,   57,   54,   51,   49,   47,   45,   43,
2446           41,   39,   38,   37,   35,   34,   33
2447     };
2448
2449     /* find prediction - wmv3_dc_scale always used here in fact */
2450     if (n < 4)     scale = s->y_dc_scale;
2451     else           scale = s->c_dc_scale;
2452
2453     wrap = s->block_wrap[n];
2454     dc_val= s->dc_val[0] + s->block_index[n];
2455
2456     /* B A
2457      * C X
2458      */
2459     c = dc_val[ - 1];
2460     b = dc_val[ - 1 - wrap];
2461     a = dc_val[ - wrap];
2462
2463     if (pq < 9 || !overlap)
2464     {
2465         /* Set outer values */
2466         if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
2467         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
2468     }
2469     else
2470     {
2471         /* Set outer values */
2472         if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
2473         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
2474     }
2475
2476     if (abs(a - b) <= abs(b - c)) {
2477         pred = c;
2478         *dir_ptr = 1;//left
2479     } else {
2480         pred = a;
2481         *dir_ptr = 0;//top
2482     }
2483
2484     /* update predictor */
2485     *dc_val_ptr = &dc_val[0];
2486     return pred;
2487 }
2488
2489
2490 /** Get predicted DC value
2491  * prediction dir: left=0, top=1
2492  * @param s MpegEncContext
2493  * @param[in] n block index in the current MB
2494  * @param dc_val_ptr Pointer to DC predictor
2495  * @param dir_ptr Prediction direction for use in AC prediction
2496  */
2497 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2498                               int a_avail, int c_avail,
2499                               int16_t **dc_val_ptr, int *dir_ptr)
2500 {
2501     int a, b, c, wrap, pred, scale;
2502     int16_t *dc_val;
2503     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2504     int q1, q2 = 0;
2505
2506     /* find prediction - wmv3_dc_scale always used here in fact */
2507     if (n < 4)     scale = s->y_dc_scale;
2508     else           scale = s->c_dc_scale;
2509
2510     wrap = s->block_wrap[n];
2511     dc_val= s->dc_val[0] + s->block_index[n];
2512
2513     /* B A
2514      * C X
2515      */
2516     c = dc_val[ - 1];
2517     b = dc_val[ - 1 - wrap];
2518     a = dc_val[ - wrap];
2519     /* scale predictors if needed */
2520     q1 = s->current_picture.qscale_table[mb_pos];
2521     if(c_avail && (n!= 1 && n!=3)) {
2522         q2 = s->current_picture.qscale_table[mb_pos - 1];
2523         if(q2 && q2 != q1)
2524             c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2525     }
2526     if(a_avail && (n!= 2 && n!=3)) {
2527         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2528         if(q2 && q2 != q1)
2529             a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2530     }
2531     if(a_avail && c_avail && (n!=3)) {
2532         int off = mb_pos;
2533         if(n != 1) off--;
2534         if(n != 2) off -= s->mb_stride;
2535         q2 = s->current_picture.qscale_table[off];
2536         if(q2 && q2 != q1)
2537             b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2538     }
2539
2540     if(a_avail && c_avail) {
2541         if(abs(a - b) <= abs(b - c)) {
2542             pred = c;
2543             *dir_ptr = 1;//left
2544         } else {
2545             pred = a;
2546             *dir_ptr = 0;//top
2547         }
2548     } else if(a_avail) {
2549         pred = a;
2550         *dir_ptr = 0;//top
2551     } else if(c_avail) {
2552         pred = c;
2553         *dir_ptr = 1;//left
2554     } else {
2555         pred = 0;
2556         *dir_ptr = 1;//left
2557     }
2558
2559     /* update predictor */
2560     *dc_val_ptr = &dc_val[0];
2561     return pred;
2562 }
2563
2564
2565 /**
2566  * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2567  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2568  * @{
2569  */
2570
2571 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
2572 {
2573     int xy, wrap, pred, a, b, c;
2574
2575     xy = s->block_index[n];
2576     wrap = s->b8_stride;
2577
2578     /* B C
2579      * A X
2580      */
2581     a = s->coded_block[xy - 1       ];
2582     b = s->coded_block[xy - 1 - wrap];
2583     c = s->coded_block[xy     - wrap];
2584
2585     if (b == c) {
2586         pred = a;
2587     } else {
2588         pred = c;
2589     }
2590
2591     /* store value */
2592     *coded_block_ptr = &s->coded_block[xy];
2593
2594     return pred;
2595 }
2596
2597 /**
2598  * Decode one AC coefficient
2599  * @param v The VC1 context
2600  * @param last Last coefficient
2601  * @param skip How much zero coefficients to skip
2602  * @param value Decoded AC coefficient value
2603  * @see 8.1.3.4
2604  */
2605 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
2606 {
2607     GetBitContext *gb = &v->s.gb;
2608     int index, escape, run = 0, level = 0, lst = 0;
2609
2610     index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2611     if (index != vc1_ac_sizes[codingset] - 1) {
2612         run = vc1_index_decode_table[codingset][index][0];
2613         level = vc1_index_decode_table[codingset][index][1];
2614         lst = index >= vc1_last_decode_table[codingset];
2615         if(get_bits(gb, 1))
2616             level = -level;
2617     } else {
2618         escape = decode210(gb);
2619         if (escape != 2) {
2620             index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2621             run = vc1_index_decode_table[codingset][index][0];
2622             level = vc1_index_decode_table[codingset][index][1];
2623             lst = index >= vc1_last_decode_table[codingset];
2624             if(escape == 0) {
2625                 if(lst)
2626                     level += vc1_last_delta_level_table[codingset][run];
2627                 else
2628                     level += vc1_delta_level_table[codingset][run];
2629             } else {
2630                 if(lst)
2631                     run += vc1_last_delta_run_table[codingset][level] + 1;
2632                 else
2633                     run += vc1_delta_run_table[codingset][level] + 1;
2634             }
2635             if(get_bits(gb, 1))
2636                 level = -level;
2637         } else {
2638             int sign;
2639             lst = get_bits(gb, 1);
2640             if(v->s.esc3_level_length == 0) {
2641                 if(v->pq < 8 || v->dquantfrm) { // table 59
2642                     v->s.esc3_level_length = get_bits(gb, 3);
2643                     if(!v->s.esc3_level_length)
2644                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
2645                 } else { //table 60
2646                     v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
2647                 }
2648                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2649             }
2650             run = get_bits(gb, v->s.esc3_run_length);
2651             sign = get_bits(gb, 1);
2652             level = get_bits(gb, v->s.esc3_level_length);
2653             if(sign)
2654                 level = -level;
2655         }
2656     }
2657
2658     *last = lst;
2659     *skip = run;
2660     *value = level;
2661 }
2662
2663 /** Decode intra block in intra frames - should be faster than decode_intra_block
2664  * @param v VC1Context
2665  * @param block block to decode
2666  * @param coded are AC coeffs present or not
2667  * @param codingset set of VLC to decode data
2668  */
2669 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
2670 {
2671     GetBitContext *gb = &v->s.gb;
2672     MpegEncContext *s = &v->s;
2673     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2674     int run_diff, i;
2675     int16_t *dc_val;
2676     int16_t *ac_val, *ac_val2;
2677     int dcdiff;
2678
2679     /* Get DC differential */
2680     if (n < 4) {
2681         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2682     } else {
2683         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2684     }
2685     if (dcdiff < 0){
2686         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2687         return -1;
2688     }
2689     if (dcdiff)
2690     {
2691         if (dcdiff == 119 /* ESC index value */)
2692         {
2693             /* TODO: Optimize */
2694             if (v->pq == 1) dcdiff = get_bits(gb, 10);
2695             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2696             else dcdiff = get_bits(gb, 8);
2697         }
2698         else
2699         {
2700             if (v->pq == 1)
2701                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2702             else if (v->pq == 2)
2703                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2704         }
2705         if (get_bits(gb, 1))
2706             dcdiff = -dcdiff;
2707     }
2708
2709     /* Prediction */
2710     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2711     *dc_val = dcdiff;
2712
2713     /* Store the quantized DC coeff, used for prediction */
2714     if (n < 4) {
2715         block[0] = dcdiff * s->y_dc_scale;
2716     } else {
2717         block[0] = dcdiff * s->c_dc_scale;
2718     }
2719     /* Skip ? */
2720     run_diff = 0;
2721     i = 0;
2722     if (!coded) {
2723         goto not_coded;
2724     }
2725
2726     //AC Decoding
2727     i = 1;
2728
2729     {
2730         int last = 0, skip, value;
2731         const int8_t *zz_table;
2732         int scale;
2733         int k;
2734
2735         scale = v->pq * 2 + v->halfpq;
2736
2737         if(v->s.ac_pred) {
2738             if(!dc_pred_dir)
2739                 zz_table = vc1_horizontal_zz;
2740             else
2741                 zz_table = vc1_vertical_zz;
2742         } else
2743             zz_table = vc1_normal_zz;
2744
2745         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2746         ac_val2 = ac_val;
2747         if(dc_pred_dir) //left
2748             ac_val -= 16;
2749         else //top
2750             ac_val -= 16 * s->block_wrap[n];
2751
2752         while (!last) {
2753             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2754             i += skip;
2755             if(i > 63)
2756                 break;
2757             block[zz_table[i++]] = value;
2758         }
2759
2760         /* apply AC prediction if needed */
2761         if(s->ac_pred) {
2762             if(dc_pred_dir) { //left
2763                 for(k = 1; k < 8; k++)
2764                     block[k << 3] += ac_val[k];
2765             } else { //top
2766                 for(k = 1; k < 8; k++)
2767                     block[k] += ac_val[k + 8];
2768             }
2769         }
2770         /* save AC coeffs for further prediction */
2771         for(k = 1; k < 8; k++) {
2772             ac_val2[k] = block[k << 3];
2773             ac_val2[k + 8] = block[k];
2774         }
2775
2776         /* scale AC coeffs */
2777         for(k = 1; k < 64; k++)
2778             if(block[k]) {
2779                 block[k] *= scale;
2780                 if(!v->pquantizer)
2781                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
2782             }
2783
2784         if(s->ac_pred) i = 63;
2785     }
2786
2787 not_coded:
2788     if(!coded) {
2789         int k, scale;
2790         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2791         ac_val2 = ac_val;
2792
2793         scale = v->pq * 2 + v->halfpq;
2794         memset(ac_val2, 0, 16 * 2);
2795         if(dc_pred_dir) {//left
2796             ac_val -= 16;
2797             if(s->ac_pred)
2798                 memcpy(ac_val2, ac_val, 8 * 2);
2799         } else {//top
2800             ac_val -= 16 * s->block_wrap[n];
2801             if(s->ac_pred)
2802                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2803         }
2804
2805         /* apply AC prediction if needed */
2806         if(s->ac_pred) {
2807             if(dc_pred_dir) { //left
2808                 for(k = 1; k < 8; k++) {
2809                     block[k << 3] = ac_val[k] * scale;
2810                     if(!v->pquantizer && block[k << 3])
2811                         block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2812                 }
2813             } else { //top
2814                 for(k = 1; k < 8; k++) {
2815                     block[k] = ac_val[k + 8] * scale;
2816                     if(!v->pquantizer && block[k])
2817                         block[k] += (block[k] < 0) ? -v->pq : v->pq;
2818                 }
2819             }
2820             i = 63;
2821         }
2822     }
2823     s->block_last_index[n] = i;
2824
2825     return 0;
2826 }
2827
2828 /** Decode intra block in intra frames - should be faster than decode_intra_block
2829  * @param v VC1Context
2830  * @param block block to decode
2831  * @param coded are AC coeffs present or not
2832  * @param codingset set of VLC to decode data
2833  */
2834 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
2835 {
2836     GetBitContext *gb = &v->s.gb;
2837     MpegEncContext *s = &v->s;
2838     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2839     int run_diff, i;
2840     int16_t *dc_val;
2841     int16_t *ac_val, *ac_val2;
2842     int dcdiff;
2843     int a_avail = v->a_avail, c_avail = v->c_avail;
2844     int use_pred = s->ac_pred;
2845     int scale;
2846     int q1, q2 = 0;
2847     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2848
2849     /* Get DC differential */
2850     if (n < 4) {
2851         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2852     } else {
2853         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2854     }
2855     if (dcdiff < 0){
2856         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2857         return -1;
2858     }
2859     if (dcdiff)
2860     {
2861         if (dcdiff == 119 /* ESC index value */)
2862         {
2863             /* TODO: Optimize */
2864             if (mquant == 1) dcdiff = get_bits(gb, 10);
2865             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2866             else dcdiff = get_bits(gb, 8);
2867         }
2868         else
2869         {
2870             if (mquant == 1)
2871                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2872             else if (mquant == 2)
2873                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2874         }
2875         if (get_bits(gb, 1))
2876             dcdiff = -dcdiff;
2877     }
2878
2879     /* Prediction */
2880     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2881     *dc_val = dcdiff;
2882
2883     /* Store the quantized DC coeff, used for prediction */
2884     if (n < 4) {
2885         block[0] = dcdiff * s->y_dc_scale;
2886     } else {
2887         block[0] = dcdiff * s->c_dc_scale;
2888     }
2889     /* Skip ? */
2890     run_diff = 0;
2891     i = 0;
2892
2893     //AC Decoding
2894     i = 1;
2895
2896     /* check if AC is needed at all and adjust direction if needed */
2897     if(!a_avail) dc_pred_dir = 1;
2898     if(!c_avail) dc_pred_dir = 0;
2899     if(!a_avail && !c_avail) use_pred = 0;
2900     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2901     ac_val2 = ac_val;
2902
2903     scale = mquant * 2 + v->halfpq;
2904
2905     if(dc_pred_dir) //left
2906         ac_val -= 16;
2907     else //top
2908         ac_val -= 16 * s->block_wrap[n];
2909
2910     q1 = s->current_picture.qscale_table[mb_pos];
2911     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
2912     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2913     if(n && n<4) q2 = q1;
2914
2915     if(coded) {
2916         int last = 0, skip, value;
2917         const int8_t *zz_table;
2918         int k;
2919
2920         if(v->s.ac_pred) {
2921             if(!dc_pred_dir)
2922                 zz_table = vc1_horizontal_zz;
2923             else
2924                 zz_table = vc1_vertical_zz;
2925         } else
2926             zz_table = vc1_normal_zz;
2927
2928         while (!last) {
2929             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2930             i += skip;
2931             if(i > 63)
2932                 break;
2933             block[zz_table[i++]] = value;
2934         }
2935
2936         /* apply AC prediction if needed */
2937         if(use_pred) {
2938             /* scale predictors if needed*/
2939             if(q2 && q1!=q2) {
2940                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2941                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2942
2943                 if(dc_pred_dir) { //left
2944                     for(k = 1; k < 8; k++)
2945                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2946                 } else { //top
2947                     for(k = 1; k < 8; k++)
2948                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2949                 }
2950             } else {
2951                 if(dc_pred_dir) { //left
2952                     for(k = 1; k < 8; k++)
2953                         block[k << 3] += ac_val[k];
2954                 } else { //top
2955                     for(k = 1; k < 8; k++)
2956                         block[k] += ac_val[k + 8];
2957                 }
2958             }
2959         }
2960         /* save AC coeffs for further prediction */
2961         for(k = 1; k < 8; k++) {
2962             ac_val2[k] = block[k << 3];
2963             ac_val2[k + 8] = block[k];
2964         }
2965
2966         /* scale AC coeffs */
2967         for(k = 1; k < 64; k++)
2968             if(block[k]) {
2969                 block[k] *= scale;
2970                 if(!v->pquantizer)
2971                     block[k] += (block[k] < 0) ? -mquant : mquant;
2972             }
2973
2974         if(use_pred) i = 63;
2975     } else { // no AC coeffs
2976         int k;
2977
2978         memset(ac_val2, 0, 16 * 2);
2979         if(dc_pred_dir) {//left
2980             if(use_pred) {
2981                 memcpy(ac_val2, ac_val, 8 * 2);
2982                 if(q2 && q1!=q2) {
2983                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2984                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2985                     for(k = 1; k < 8; k++)
2986                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2987                 }
2988             }
2989         } else {//top
2990             if(use_pred) {
2991                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2992                 if(q2 && q1!=q2) {
2993                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2994                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2995                     for(k = 1; k < 8; k++)
2996                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2997                 }
2998             }
2999         }
3000
3001         /* apply AC prediction if needed */
3002         if(use_pred) {
3003             if(dc_pred_dir) { //left
3004                 for(k = 1; k < 8; k++) {
3005                     block[k << 3] = ac_val2[k] * scale;
3006                     if(!v->pquantizer && block[k << 3])
3007                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3008                 }
3009             } else { //top
3010                 for(k = 1; k < 8; k++) {
3011                     block[k] = ac_val2[k + 8] * scale;
3012                     if(!v->pquantizer && block[k])
3013                         block[k] += (block[k] < 0) ? -mquant : mquant;
3014                 }
3015             }
3016             i = 63;
3017         }
3018     }
3019     s->block_last_index[n] = i;
3020
3021     return 0;
3022 }
3023
3024 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
3025  * @param v VC1Context
3026  * @param block block to decode
3027  * @param coded are AC coeffs present or not
3028  * @param mquant block quantizer
3029  * @param codingset set of VLC to decode data
3030  */
3031 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
3032 {
3033     GetBitContext *gb = &v->s.gb;
3034     MpegEncContext *s = &v->s;
3035     int dc_pred_dir = 0; /* Direction of the DC prediction used */
3036     int run_diff, i;
3037     int16_t *dc_val;
3038     int16_t *ac_val, *ac_val2;
3039     int dcdiff;
3040     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3041     int a_avail = v->a_avail, c_avail = v->c_avail;
3042     int use_pred = s->ac_pred;
3043     int scale;
3044     int q1, q2 = 0;
3045
3046     /* XXX: Guard against dumb values of mquant */
3047     mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
3048
3049     /* Set DC scale - y and c use the same */
3050     s->y_dc_scale = s->y_dc_scale_table[mquant];
3051     s->c_dc_scale = s->c_dc_scale_table[mquant];
3052
3053     /* Get DC differential */
3054     if (n < 4) {
3055         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3056     } else {
3057         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3058     }
3059     if (dcdiff < 0){
3060         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3061         return -1;
3062     }
3063     if (dcdiff)
3064     {
3065         if (dcdiff == 119 /* ESC index value */)
3066         {
3067             /* TODO: Optimize */
3068             if (mquant == 1) dcdiff = get_bits(gb, 10);
3069             else if (mquant == 2) dcdiff = get_bits(gb, 9);
3070             else dcdiff = get_bits(gb, 8);
3071         }
3072         else
3073         {
3074             if (mquant == 1)
3075                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
3076             else if (mquant == 2)
3077                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
3078         }
3079         if (get_bits(gb, 1))
3080             dcdiff = -dcdiff;
3081     }
3082
3083     /* Prediction */
3084     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3085     *dc_val = dcdiff;
3086
3087     /* Store the quantized DC coeff, used for prediction */
3088
3089     if (n < 4) {
3090         block[0] = dcdiff * s->y_dc_scale;
3091     } else {
3092         block[0] = dcdiff * s->c_dc_scale;
3093     }
3094     /* Skip ? */
3095     run_diff = 0;
3096     i = 0;
3097
3098     //AC Decoding
3099     i = 1;
3100
3101     /* check if AC is needed at all and adjust direction if needed */
3102     if(!a_avail) dc_pred_dir = 1;
3103     if(!c_avail) dc_pred_dir = 0;
3104     if(!a_avail && !c_avail) use_pred = 0;
3105     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3106     ac_val2 = ac_val;
3107
3108     scale = mquant * 2 + v->halfpq;
3109
3110     if(dc_pred_dir) //left
3111         ac_val -= 16;
3112     else //top
3113         ac_val -= 16 * s->block_wrap[n];
3114
3115     q1 = s->current_picture.qscale_table[mb_pos];
3116     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
3117     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3118     if(n && n<4) q2 = q1;
3119
3120     if(coded) {
3121         int last = 0, skip, value;
3122         const int8_t *zz_table;
3123         int k;
3124
3125         zz_table = vc1_simple_progressive_8x8_zz;
3126
3127         while (!last) {
3128             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3129             i += skip;
3130             if(i > 63)
3131                 break;
3132             block[zz_table[i++]] = value;
3133         }
3134
3135         /* apply AC prediction if needed */
3136         if(use_pred) {
3137             /* scale predictors if needed*/
3138             if(q2 && q1!=q2) {
3139                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3140                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3141
3142                 if(dc_pred_dir) { //left
3143                     for(k = 1; k < 8; k++)
3144                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3145                 } else { //top
3146                     for(k = 1; k < 8; k++)
3147                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3148                 }
3149             } else {
3150                 if(dc_pred_dir) { //left
3151                     for(k = 1; k < 8; k++)
3152                         block[k << 3] += ac_val[k];
3153                 } else { //top
3154                     for(k = 1; k < 8; k++)
3155                         block[k] += ac_val[k + 8];
3156                 }
3157             }
3158         }
3159         /* save AC coeffs for further prediction */
3160         for(k = 1; k < 8; k++) {
3161             ac_val2[k] = block[k << 3];
3162             ac_val2[k + 8] = block[k];
3163         }
3164
3165         /* scale AC coeffs */
3166         for(k = 1; k < 64; k++)
3167             if(block[k]) {
3168                 block[k] *= scale;
3169                 if(!v->pquantizer)
3170                     block[k] += (block[k] < 0) ? -mquant : mquant;
3171             }
3172
3173         if(use_pred) i = 63;
3174     } else { // no AC coeffs
3175         int k;
3176
3177         memset(ac_val2, 0, 16 * 2);
3178         if(dc_pred_dir) {//left
3179             if(use_pred) {
3180                 memcpy(ac_val2, ac_val, 8 * 2);
3181                 if(q2 && q1!=q2) {
3182                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3183                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3184                     for(k = 1; k < 8; k++)
3185                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3186                 }
3187             }
3188         } else {//top
3189             if(use_pred) {
3190                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3191                 if(q2 && q1!=q2) {
3192                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3193                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3194                     for(k = 1; k < 8; k++)
3195                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3196                 }
3197             }
3198         }
3199
3200         /* apply AC prediction if needed */
3201         if(use_pred) {
3202             if(dc_pred_dir) { //left
3203                 for(k = 1; k < 8; k++) {
3204                     block[k << 3] = ac_val2[k] * scale;
3205                     if(!v->pquantizer && block[k << 3])
3206                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3207                 }
3208             } else { //top
3209                 for(k = 1; k < 8; k++) {
3210                     block[k] = ac_val2[k + 8] * scale;
3211                     if(!v->pquantizer && block[k])
3212                         block[k] += (block[k] < 0) ? -mquant : mquant;
3213                 }
3214             }
3215             i = 63;
3216         }
3217     }
3218     s->block_last_index[n] = i;
3219
3220     return 0;
3221 }
3222
3223 /** Decode P block
3224  */
3225 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
3226 {
3227     MpegEncContext *s = &v->s;
3228     GetBitContext *gb = &s->gb;
3229     int i, j;
3230     int subblkpat = 0;
3231     int scale, off, idx, last, skip, value;
3232     int ttblk = ttmb & 7;
3233
3234     if(ttmb == -1) {
3235         ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
3236     }
3237     if(ttblk == TT_4X4) {
3238         subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3239     }
3240     if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
3241         subblkpat = decode012(gb);
3242         if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
3243         if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
3244         if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
3245     }
3246     scale = 2 * mquant + v->halfpq;
3247
3248     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3249     if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3250         subblkpat = 2 - (ttblk == TT_8X4_TOP);
3251         ttblk = TT_8X4;
3252     }
3253     if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3254         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3255         ttblk = TT_4X8;
3256     }
3257     switch(ttblk) {
3258     case TT_8X8:
3259         i = 0;
3260         last = 0;
3261         while (!last) {
3262             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3263             i += skip;
3264             if(i > 63)
3265                 break;
3266             idx = vc1_simple_progressive_8x8_zz[i++];
3267             block[idx] = value * scale;
3268             if(!v->pquantizer)
3269                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3270         }
3271         s->dsp.vc1_inv_trans_8x8(block);
3272         break;
3273     case TT_4X4:
3274         for(j = 0; j < 4; j++) {
3275             last = subblkpat & (1 << (3 - j));
3276             i = 0;
3277             off = (j & 1) * 4 + (j & 2) * 16;
3278             while (!last) {
3279                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3280                 i += skip;
3281                 if(i > 15)
3282                     break;
3283                 idx = vc1_simple_progressive_4x4_zz[i++];
3284                 block[idx + off] = value * scale;
3285                 if(!v->pquantizer)
3286                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3287             }
3288             if(!(subblkpat & (1 << (3 - j))))
3289                 s->dsp.vc1_inv_trans_4x4(block, j);
3290         }
3291         break;
3292     case TT_8X4:
3293         for(j = 0; j < 2; j++) {
3294             last = subblkpat & (1 << (1 - j));
3295             i = 0;
3296             off = j * 32;
3297             while (!last) {
3298                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3299                 i += skip;
3300                 if(i > 31)
3301                     break;
3302                 if(v->profile < PROFILE_ADVANCED)
3303                     idx = vc1_simple_progressive_8x4_zz[i++];
3304                 else
3305                     idx = vc1_adv_progressive_8x4_zz[i++];
3306                 block[idx + off] = value * scale;
3307                 if(!v->pquantizer)
3308                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3309             }
3310             if(!(subblkpat & (1 << (1 - j))))
3311                 s->dsp.vc1_inv_trans_8x4(block, j);
3312         }
3313         break;
3314     case TT_4X8:
3315         for(j = 0; j < 2; j++) {
3316             last = subblkpat & (1 << (1 - j));
3317             i = 0;
3318             off = j * 4;
3319             while (!last) {
3320                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3321                 i += skip;
3322                 if(i > 31)
3323                     break;
3324                 if(v->profile < PROFILE_ADVANCED)
3325                     idx = vc1_simple_progressive_4x8_zz[i++];
3326                 else
3327                     idx = vc1_adv_progressive_4x8_zz[i++];
3328                 block[idx + off] = value * scale;
3329                 if(!v->pquantizer)
3330                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3331             }
3332             if(!(subblkpat & (1 << (1 - j))))
3333                 s->dsp.vc1_inv_trans_4x8(block, j);
3334         }
3335         break;
3336     }
3337     return 0;
3338 }
3339
3340
3341 /** Decode one P-frame MB (in Simple/Main profile)
3342  */
3343 static int vc1_decode_p_mb(VC1Context *v)
3344 {
3345     MpegEncContext *s = &v->s;
3346     GetBitContext *gb = &s->gb;
3347     int i, j;
3348     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3349     int cbp; /* cbp decoding stuff */
3350     int mqdiff, mquant; /* MB quantization */
3351     int ttmb = v->ttfrm; /* MB Transform type */
3352     int status;
3353
3354     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3355       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3356     int mb_has_coeffs = 1; /* last_flag */
3357     int dmv_x, dmv_y; /* Differential MV components */
3358     int index, index1; /* LUT indices */
3359     int val, sign; /* temp values */
3360     int first_block = 1;
3361     int dst_idx, off;
3362     int skipped, fourmv;
3363
3364     mquant = v->pq; /* Loosy initialization */
3365
3366     if (v->mv_type_is_raw)
3367         fourmv = get_bits1(gb);
3368     else
3369         fourmv = v->mv_type_mb_plane[mb_pos];
3370     if (v->skip_is_raw)
3371         skipped = get_bits1(gb);
3372     else
3373         skipped = v->s.mbskip_table[mb_pos];
3374
3375     s->dsp.clear_blocks(s->block[0]);
3376
3377     if (!fourmv) /* 1MV mode */
3378     {
3379         if (!skipped)
3380         {
3381             GET_MVDATA(dmv_x, dmv_y);
3382
3383             if (s->mb_intra) {
3384                 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3385                 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3386             }
3387             s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3388             vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3389
3390             /* FIXME Set DC val for inter block ? */
3391             if (s->mb_intra && !mb_has_coeffs)
3392             {
3393                 GET_MQUANT();
3394                 s->ac_pred = get_bits(gb, 1);
3395                 cbp = 0;
3396             }
3397             else if (mb_has_coeffs)
3398             {
3399                 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
3400                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3401                 GET_MQUANT();
3402             }
3403             else
3404             {
3405                 mquant = v->pq;
3406                 cbp = 0;
3407             }
3408             s->current_picture.qscale_table[mb_pos] = mquant;
3409
3410             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3411                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
3412                                 VC1_TTMB_VLC_BITS, 2);
3413             if(!s->mb_intra) vc1_mc_1mv(v, 0);
3414             dst_idx = 0;
3415             for (i=0; i<6; i++)
3416             {
3417                 s->dc_val[0][s->block_index[i]] = 0;
3418                 dst_idx += i >> 2;
3419                 val = ((cbp >> (5 - i)) & 1);
3420                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3421                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3422                 if(s->mb_intra) {
3423                     /* check if prediction blocks A and C are available */
3424                     v->a_avail = v->c_avail = 0;
3425                     if(i == 2 || i == 3 || !s->first_slice_line)
3426                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3427                     if(i == 1 || i == 3 || s->mb_x)
3428                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3429
3430                     vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3431                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3432                     s->dsp.vc1_inv_trans_8x8(s->block[i]);
3433                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3434                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
3435                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3436                     if(v->pq >= 9 && v->overlap) {
3437                         if(v->c_avail)
3438                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3439                         if(v->a_avail)
3440                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3441                     }
3442                 } else if(val) {
3443                     vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3444                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
3445                     first_block = 0;
3446                     if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3447                         s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3448                 }
3449             }
3450         }
3451         else //Skipped
3452         {
3453             s->mb_intra = 0;
3454             for(i = 0; i < 6; i++) {
3455                 v->mb_type[0][s->block_index[i]] = 0;
3456                 s->dc_val[0][s->block_index[i]] = 0;
3457             }
3458             s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3459             s->current_picture.qscale_table[mb_pos] = 0;
3460             vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3461             vc1_mc_1mv(v, 0);
3462             return 0;
3463         }
3464     } //1MV mode
3465     else //4MV mode
3466     {
3467         if (!skipped /* unskipped MB */)
3468         {
3469             int intra_count = 0, coded_inter = 0;
3470             int is_intra[6], is_coded[6];
3471             /* Get CBPCY */
3472             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3473             for (i=0; i<6; i++)
3474             {
3475                 val = ((cbp >> (5 - i)) & 1);
3476                 s->dc_val[0][s->block_index[i]] = 0;
3477                 s->mb_intra = 0;
3478                 if(i < 4) {
3479                     dmv_x = dmv_y = 0;
3480                     s->mb_intra = 0;
3481                     mb_has_coeffs = 0;
3482                     if(val) {
3483                         GET_MVDATA(dmv_x, dmv_y);
3484                     }
3485                     vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3486                     if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
3487                     intra_count += s->mb_intra;
3488                     is_intra[i] = s->mb_intra;
3489                     is_coded[i] = mb_has_coeffs;
3490                 }
3491                 if(i&4){
3492                     is_intra[i] = (intra_count >= 3);
3493                     is_coded[i] = val;
3494                 }
3495                 if(i == 4) vc1_mc_4mv_chroma(v);
3496                 v->mb_type[0][s->block_index[i]] = is_intra[i];
3497                 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
3498             }
3499             // if there are no coded blocks then don't do anything more
3500             if(!intra_count && !coded_inter) return 0;
3501             dst_idx = 0;
3502             GET_MQUANT();
3503             s->current_picture.qscale_table[mb_pos] = mquant;
3504             /* test if block is intra and has pred */
3505             {
3506                 int intrapred = 0;
3507                 for(i=0; i<6; i++)
3508                     if(is_intra[i]) {
3509                         if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3510                             || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
3511                             intrapred = 1;
3512                             break;
3513                         }
3514                     }
3515                 if(intrapred)s->ac_pred = get_bits(gb, 1);
3516                 else s->ac_pred = 0;
3517             }
3518             if (!v->ttmbf && coded_inter)
3519                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3520             for (i=0; i<6; i++)
3521             {
3522                 dst_idx += i >> 2;
3523                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3524                 s->mb_intra = is_intra[i];
3525                 if (is_intra[i]) {
3526                     /* check if prediction blocks A and C are available */
3527                     v->a_avail = v->c_avail = 0;
3528                     if(i == 2 || i == 3 || !s->first_slice_line)
3529                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3530                     if(i == 1 || i == 3 || s->mb_x)
3531                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3532
3533                     vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
3534                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3535                     s->dsp.vc1_inv_trans_8x8(s->block[i]);
3536                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3537                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
3538                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3539                     if(v->pq >= 9 && v->overlap) {
3540                         if(v->c_avail)
3541                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3542                         if(v->a_avail)
3543                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3544                     }
3545                 } else if(is_coded[i]) {
3546                     status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3547                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
3548                     first_block = 0;
3549                     if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3550                         s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3551                 }
3552             }
3553             return status;
3554         }
3555         else //Skipped MB
3556         {
3557             s->mb_intra = 0;
3558             s->current_picture.qscale_table[mb_pos] = 0;
3559             for (i=0; i<6; i++) {
3560                 v->mb_type[0][s->block_index[i]] = 0;
3561                 s->dc_val[0][s->block_index[i]] = 0;
3562             }
3563             for (i=0; i<4; i++)
3564             {
3565                 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
3566                 vc1_mc_4mv_luma(v, i);
3567             }
3568             vc1_mc_4mv_chroma(v);
3569             s->current_picture.qscale_table[mb_pos] = 0;
3570             return 0;
3571         }
3572     }
3573
3574     /* Should never happen */
3575     return -1;
3576 }
3577
3578 /** Decode one B-frame MB (in Main profile)
3579  */
3580 static void vc1_decode_b_mb(VC1Context *v)
3581 {
3582     MpegEncContext *s = &v->s;
3583     GetBitContext *gb = &s->gb;
3584     int i, j;
3585     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3586     int cbp = 0; /* cbp decoding stuff */
3587     int mqdiff, mquant; /* MB quantization */
3588     int ttmb = v->ttfrm; /* MB Transform type */
3589
3590     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3591       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3592     int mb_has_coeffs = 0; /* last_flag */
3593     int index, index1; /* LUT indices */
3594     int val, sign; /* temp values */
3595     int first_block = 1;
3596     int dst_idx, off;
3597     int skipped, direct;
3598     int dmv_x[2], dmv_y[2];
3599     int bmvtype = BMV_TYPE_BACKWARD;
3600
3601     mquant = v->pq; /* Loosy initialization */
3602     s->mb_intra = 0;
3603
3604     if (v->dmb_is_raw)
3605         direct = get_bits1(gb);
3606     else
3607         direct = v->direct_mb_plane[mb_pos];
3608     if (v->skip_is_raw)
3609         skipped = get_bits1(gb);
3610     else
3611         skipped = v->s.mbskip_table[mb_pos];
3612
3613     s->dsp.clear_blocks(s->block[0]);
3614     dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
3615     for(i = 0; i < 6; i++) {
3616         v->mb_type[0][s->block_index[i]] = 0;
3617         s->dc_val[0][s->block_index[i]] = 0;
3618     }
3619     s->current_picture.qscale_table[mb_pos] = 0;
3620
3621     if (!direct) {
3622         if (!skipped) {
3623             GET_MVDATA(dmv_x[0], dmv_y[0]);
3624             dmv_x[1] = dmv_x[0];
3625             dmv_y[1] = dmv_y[0];
3626         }
3627         if(skipped || !s->mb_intra) {
3628             bmvtype = decode012(gb);
3629             switch(bmvtype) {
3630             case 0:
3631                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
3632                 break;
3633             case 1:
3634                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
3635                 break;
3636             case 2:
3637                 bmvtype = BMV_TYPE_INTERPOLATED;
3638                 dmv_x[0] = dmv_y[0] = 0;
3639             }
3640         }
3641     }
3642     for(i = 0; i < 6; i++)
3643         v->mb_type[0][s->block_index[i]] = s->mb_intra;
3644
3645     if (skipped) {
3646         if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
3647         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3648         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3649         return;
3650     }
3651     if (direct) {
3652         cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3653         GET_MQUANT();
3654         s->mb_intra = 0;
3655         mb_has_coeffs = 0;
3656         s->current_picture.qscale_table[mb_pos] = mquant;
3657         if(!v->ttmbf)
3658             ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3659         dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
3660         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3661         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3662     } else {
3663         if(!mb_has_coeffs && !s->mb_intra) {
3664             /* no coded blocks - effectively skipped */
3665             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3666             vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3667             return;
3668         }
3669         if(s->mb_intra && !mb_has_coeffs) {
3670             GET_MQUANT();
3671             s->current_picture.qscale_table[mb_pos] = mquant;
3672             s->ac_pred = get_bits1(gb);
3673             cbp = 0;
3674             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3675         } else {
3676             if(bmvtype == BMV_TYPE_INTERPOLATED) {
3677                 GET_MVDATA(dmv_x[0], dmv_y[0]);
3678                 if(!mb_has_coeffs) {
3679                     /* interpolated skipped block */
3680                     vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3681                     vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3682                     return;
3683                 }
3684             }
3685             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3686             if(!s->mb_intra) {
3687                 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3688             }
3689             if(s->mb_intra)
3690                 s->ac_pred = get_bits1(gb);
3691             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3692             GET_MQUANT();
3693             s->current_picture.qscale_table[mb_pos] = mquant;
3694             if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3695                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3696         }
3697     }
3698     dst_idx = 0;
3699     for (i=0; i<6; i++)
3700     {
3701         s->dc_val[0][s->block_index[i]] = 0;
3702         dst_idx += i >> 2;
3703         val = ((cbp >> (5 - i)) & 1);
3704         off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3705         v->mb_type[0][s->block_index[i]] = s->mb_intra;
3706         if(s->mb_intra) {
3707             /* check if prediction blocks A and C are available */
3708             v->a_avail = v->c_avail = 0;
3709             if(i == 2 || i == 3 || !s->first_slice_line)
3710                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3711             if(i == 1 || i == 3 || s->mb_x)
3712                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3713
3714             vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3715             if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3716             s->dsp.vc1_inv_trans_8x8(s->block[i]);
3717             if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3718             for(j = 0; j < 64; j++) s->block[i][j] += 128;
3719             s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3720         } else if(val) {
3721             vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3722             if(!v->ttmbf && ttmb < 8) ttmb = -1;
3723             first_block = 0;
3724             if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3725                 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3726         }
3727     }
3728 }
3729
3730 /** Decode blocks of I-frame
3731  */
3732 static void vc1_decode_i_blocks(VC1Context *v)
3733 {
3734     int k, j;
3735     MpegEncContext *s = &v->s;
3736     int cbp, val;
3737     uint8_t *coded_val;
3738     int mb_pos;
3739
3740     /* select codingmode used for VLC tables selection */
3741     switch(v->y_ac_table_index){
3742     case 0:
3743         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3744         break;
3745     case 1:
3746         v->codingset = CS_HIGH_MOT_INTRA;
3747         break;
3748     case 2:
3749         v->codingset = CS_MID_RATE_INTRA;
3750         break;
3751     }
3752
3753     switch(v->c_ac_table_index){
3754     case 0:
3755         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3756         break;
3757     case 1:
3758         v->codingset2 = CS_HIGH_MOT_INTER;
3759         break;
3760     case 2:
3761         v->codingset2 = CS_MID_RATE_INTER;
3762         break;
3763     }
3764
3765     /* Set DC scale - y and c use the same */
3766     s->y_dc_scale = s->y_dc_scale_table[v->pq];
3767     s->c_dc_scale = s->c_dc_scale_table[v->pq];
3768
3769     //do frame decode
3770     s->mb_x = s->mb_y = 0;
3771     s->mb_intra = 1;
3772     s->first_slice_line = 1;
3773     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3774     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3775         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3776             ff_init_block_index(s);
3777             ff_update_block_index(s);
3778             s->dsp.clear_blocks(s->block[0]);
3779             mb_pos = s->mb_x + s->mb_y * s->mb_width;
3780             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3781             s->current_picture.qscale_table[mb_pos] = v->pq;
3782             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3783             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3784
3785             // do actual MB decoding and displaying
3786             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3787             v->s.ac_pred = get_bits(&v->s.gb, 1);
3788
3789             for(k = 0; k < 6; k++) {
3790                 val = ((cbp >> (5 - k)) & 1);
3791
3792                 if (k < 4) {
3793                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3794                     val = val ^ pred;
3795                     *coded_val = val;
3796                 }
3797                 cbp |= val << (5 - k);
3798
3799                 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
3800
3801                 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3802                 if(v->pq >= 9 && v->overlap) {
3803                     for(j = 0; j < 64; j++) s->block[k][j] += 128;
3804                 }
3805             }
3806
3807             vc1_put_block(v, s->block);
3808             if(v->pq >= 9 && v->overlap) {
3809                 if(s->mb_x) {
3810                     s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3811                     s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3812                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3813                         s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3814                         s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3815                     }
3816                 }
3817                 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3818                 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3819                 if(!s->first_slice_line) {
3820                     s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3821                     s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3822                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3823                         s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3824                         s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3825                     }
3826                 }
3827                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3828                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3829             }
3830
3831             if(get_bits_count(&s->gb) > v->bits) {
3832                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3833                 return;
3834             }
3835         }
3836         ff_draw_horiz_band(s, s->mb_y * 16, 16);
3837         s->first_slice_line = 0;
3838     }
3839 }
3840
3841 /** Decode blocks of I-frame for advanced profile
3842  */
3843 static void vc1_decode_i_blocks_adv(VC1Context *v)
3844 {
3845     int k, j;
3846     MpegEncContext *s = &v->s;
3847     int cbp, val;
3848     uint8_t *coded_val;
3849     int mb_pos;
3850     int mquant = v->pq;
3851     int mqdiff;
3852     int overlap;
3853     GetBitContext *gb = &s->gb;
3854
3855     /* select codingmode used for VLC tables selection */
3856     switch(v->y_ac_table_index){
3857     case 0:
3858         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3859         break;
3860     case 1:
3861         v->codingset = CS_HIGH_MOT_INTRA;
3862         break;
3863     case 2:
3864         v->codingset = CS_MID_RATE_INTRA;
3865         break;
3866     }
3867
3868     switch(v->c_ac_table_index){
3869     case 0:
3870         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3871         break;
3872     case 1:
3873         v->codingset2 = CS_HIGH_MOT_INTER;
3874         break;
3875     case 2:
3876         v->codingset2 = CS_MID_RATE_INTER;
3877         break;
3878     }
3879
3880     //do frame decode
3881     s->mb_x = s->mb_y = 0;
3882     s->mb_intra = 1;
3883     s->first_slice_line = 1;
3884     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3885     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3886         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3887             ff_init_block_index(s);
3888             ff_update_block_index(s);
3889             s->dsp.clear_blocks(s->block[0]);
3890             mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3891             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3892             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3893             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3894
3895             // do actual MB decoding and displaying
3896             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3897             if(v->acpred_is_raw)
3898                 v->s.ac_pred = get_bits(&v->s.gb, 1);
3899             else
3900                 v->s.ac_pred = v->acpred_plane[mb_pos];
3901
3902             if(v->condover == CONDOVER_SELECT) {
3903                 if(v->overflg_is_raw)
3904                     overlap = get_bits(&v->s.gb, 1);
3905                 else
3906                     overlap = v->over_flags_plane[mb_pos];
3907             } else
3908                 overlap = (v->condover == CONDOVER_ALL);
3909
3910             GET_MQUANT();
3911
3912             s->current_picture.qscale_table[mb_pos] = mquant;
3913             /* Set DC scale - y and c use the same */
3914             s->y_dc_scale = s->y_dc_scale_table[mquant];
3915             s->c_dc_scale = s->c_dc_scale_table[mquant];
3916
3917             for(k = 0; k < 6; k++) {
3918                 val = ((cbp >> (5 - k)) & 1);
3919
3920                 if (k < 4) {
3921                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3922                     val = val ^ pred;
3923                     *coded_val = val;
3924                 }
3925                 cbp |= val << (5 - k);
3926
3927                 v->a_avail = !s->first_slice_line || (k==2 || k==3);
3928                 v->c_avail = !!s->mb_x || (k==1 || k==3);
3929
3930                 vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
3931
3932                 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3933                 for(j = 0; j < 64; j++) s->block[k][j] += 128;
3934             }
3935
3936             vc1_put_block(v, s->block);
3937             if(overlap) {
3938                 if(s->mb_x) {
3939                     s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3940                     s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3941                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3942                         s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3943                         s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3944                     }
3945                 }
3946                 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3947                 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3948                 if(!s->first_slice_line) {
3949                     s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3950                     s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3951                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3952                         s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3953                         s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3954                     }
3955                 }
3956                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3957                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3958             }
3959
3960             if(get_bits_count(&s->gb) > v->bits) {
3961                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3962                 return;
3963             }
3964         }
3965         ff_draw_horiz_band(s, s->mb_y * 16, 16);
3966         s->first_slice_line = 0;
3967     }
3968 }
3969
3970 static void vc1_decode_p_blocks(VC1Context *v)
3971 {
3972     MpegEncContext *s = &v->s;
3973
3974     /* select codingmode used for VLC tables selection */
3975     switch(v->c_ac_table_index){
3976     case 0:
3977         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3978         break;
3979     case 1:
3980         v->codingset = CS_HIGH_MOT_INTRA;
3981         break;
3982     case 2:
3983         v->codingset = CS_MID_RATE_INTRA;
3984         break;
3985     }
3986
3987     switch(v->c_ac_table_index){
3988     case 0:
3989         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3990         break;
3991     case 1:
3992         v->codingset2 = CS_HIGH_MOT_INTER;
3993         break;
3994     case 2:
3995         v->codingset2 = CS_MID_RATE_INTER;
3996         break;
3997     }
3998
3999     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4000     s->first_slice_line = 1;
4001     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4002         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
4003             ff_init_block_index(s);
4004             ff_update_block_index(s);
4005             s->dsp.clear_blocks(s->block[0]);
4006
4007             vc1_decode_p_mb(v);
4008             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4009                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
4010                 return;
4011             }
4012         }
4013         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4014         s->first_slice_line = 0;
4015     }
4016 }
4017
4018 static void vc1_decode_b_blocks(VC1Context *v)
4019 {
4020     MpegEncContext *s = &v->s;
4021
4022     /* select codingmode used for VLC tables selection */
4023     switch(v->c_ac_table_index){
4024     case 0:
4025         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4026         break;
4027     case 1:
4028         v->codingset = CS_HIGH_MOT_INTRA;
4029         break;
4030     case 2:
4031         v->codingset = CS_MID_RATE_INTRA;
4032         break;
4033     }
4034
4035     switch(v->c_ac_table_index){
4036     case 0:
4037         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4038         break;
4039     case 1:
4040         v->codingset2 = CS_HIGH_MOT_INTER;
4041         break;
4042     case 2:
4043         v->codingset2 = CS_MID_RATE_INTER;
4044         break;
4045     }
4046
4047     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4048     s->first_slice_line = 1;
4049     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4050         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
4051             ff_init_block_index(s);
4052             ff_update_block_index(s);
4053             s->dsp.clear_blocks(s->block[0]);
4054
4055             vc1_decode_b_mb(v);
4056             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4057                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
4058                 return;
4059             }
4060         }
4061         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4062         s->first_slice_line = 0;
4063     }
4064 }
4065
4066 static void vc1_decode_skip_blocks(VC1Context *v)
4067 {
4068     MpegEncContext *s = &v->s;
4069
4070     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4071     s->first_slice_line = 1;
4072     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4073         s->mb_x = 0;
4074         ff_init_block_index(s);
4075         ff_update_block_index(s);
4076         memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4077         memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4078         memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4079         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4080         s->first_slice_line = 0;
4081     }
4082     s->pict_type = P_TYPE;
4083 }
4084
4085 static void vc1_decode_blocks(VC1Context *v)
4086 {
4087
4088     v->s.esc3_level_length = 0;
4089
4090     switch(v->s.pict_type) {
4091     case I_TYPE:
4092         if(v->profile == PROFILE_ADVANCED)
4093             vc1_decode_i_blocks_adv(v);
4094         else
4095             vc1_decode_i_blocks(v);
4096         break;
4097     case P_TYPE:
4098         if(v->p_frame_skipped)
4099             vc1_decode_skip_blocks(v);
4100         else
4101             vc1_decode_p_blocks(v);
4102         break;
4103     case B_TYPE:
4104         if(v->bi_type){
4105             if(v->profile == PROFILE_ADVANCED)
4106                 vc1_decode_i_blocks_adv(v);
4107             else
4108                 vc1_decode_i_blocks(v);
4109         }else
4110             vc1_decode_b_blocks(v);
4111         break;
4112     }
4113 }
4114
4115 #define IS_MARKER(x) (((x) & ~0xFF) == VC1_CODE_RES0)
4116
4117 /** Find VC-1 marker in buffer
4118  * @return position where next marker starts or end of buffer if no marker found
4119  */
4120 static av_always_inline uint8_t* find_next_marker(uint8_t *src, uint8_t *end)
4121 {
4122     uint32_t mrk = 0xFFFFFFFF;
4123
4124     if(end-src < 4) return end;
4125     while(src < end){
4126         mrk = (mrk << 8) | *src++;
4127         if(IS_MARKER(mrk))
4128             return src-4;
4129     }
4130     return end;
4131 }
4132
4133 static av_always_inline int vc1_unescape_buffer(uint8_t *src, int size, uint8_t *dst)
4134 {
4135     int dsize = 0, i;
4136
4137     if(size < 4){
4138         for(dsize = 0; dsize < size; dsize++) *dst++ = *src++;
4139         return size;
4140     }
4141     for(i = 0; i < size; i++, src++) {
4142         if(src[0] == 3 && i >= 2 && !src[-1] && !src[-2] && i < size-1 && src[1] < 4) {
4143             dst[dsize++] = src[1];
4144             src++;
4145             i++;
4146         } else
4147             dst[dsize++] = *src;
4148     }
4149     return dsize;
4150 }
4151
4152 /** Initialize a VC1/WMV3 decoder
4153  * @todo TODO: Handle VC-1 IDUs (Transport level?)
4154