Set codec dimensions in extradata parsing
[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->s.avctx->width = v->s.avctx->coded_width;
1282     v->s.avctx->height = v->s.avctx->coded_height;
1283     v->broadcast = get_bits1(gb);
1284     v->interlace = get_bits1(gb);
1285     if(v->interlace){
1286         av_log(v->s.avctx, AV_LOG_ERROR, "Interlaced mode not supported (yet)\n");
1287         return -1;
1288     }
1289     v->tfcntrflag = get_bits1(gb);
1290     v->finterpflag = get_bits1(gb);
1291     get_bits1(gb); // reserved
1292
1293     av_log(v->s.avctx, AV_LOG_DEBUG,
1294                "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1295                "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
1296                "TFCTRflag=%i, FINTERPflag=%i\n",
1297                v->level, v->frmrtq_postproc, v->bitrtq_postproc,
1298                v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
1299                v->tfcntrflag, v->finterpflag
1300                );
1301
1302     v->psf = get_bits1(gb);
1303     if(v->psf) { //PsF, 6.1.13
1304         av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
1305         return -1;
1306     }
1307     if(get_bits1(gb)) { //Display Info - decoding is not affected by it
1308         int w, h, ar = 0;
1309         av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
1310         v->s.avctx->width  = v->s.width  = w = get_bits(gb, 14) + 1;
1311         v->s.avctx->height = v->s.height = h = get_bits(gb, 14) + 1;
1312         av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
1313         if(get_bits1(gb))
1314             ar = get_bits(gb, 4);
1315         if(ar && ar < 14){
1316             v->s.avctx->sample_aspect_ratio = vc1_pixel_aspect[ar];
1317         }else if(ar == 15){
1318             w = get_bits(gb, 8);
1319             h = get_bits(gb, 8);
1320             v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
1321         }
1322
1323         if(get_bits1(gb)){ //framerate stuff
1324             if(get_bits1(gb)) {
1325                 v->s.avctx->time_base.num = 32;
1326                 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
1327             } else {
1328                 int nr, dr;
1329                 nr = get_bits(gb, 8);
1330                 dr = get_bits(gb, 4);
1331                 if(nr && nr < 8 && dr && dr < 3){
1332                     v->s.avctx->time_base.num = fps_dr[dr - 1];
1333                     v->s.avctx->time_base.den = fps_nr[nr - 1] * 1000;
1334                 }
1335             }
1336         }
1337
1338         if(get_bits1(gb)){
1339             v->color_prim = get_bits(gb, 8);
1340             v->transfer_char = get_bits(gb, 8);
1341             v->matrix_coef = get_bits(gb, 8);
1342         }
1343     }
1344
1345     v->hrd_param_flag = get_bits1(gb);
1346     if(v->hrd_param_flag) {
1347         int i;
1348         v->hrd_num_leaky_buckets = get_bits(gb, 5);
1349         get_bits(gb, 4); //bitrate exponent
1350         get_bits(gb, 4); //buffer size exponent
1351         for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1352             get_bits(gb, 16); //hrd_rate[n]
1353             get_bits(gb, 16); //hrd_buffer[n]
1354         }
1355     }
1356     return 0;
1357 }
1358
1359 static int decode_entry_point(AVCodecContext *avctx, GetBitContext *gb)
1360 {
1361     VC1Context *v = avctx->priv_data;
1362     int i, blink, refdist;
1363
1364     av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
1365     blink = get_bits1(gb); // broken link
1366     avctx->max_b_frames = 1 - get_bits1(gb); // 'closed entry' also signalize possible B-frames
1367     v->panscanflag = get_bits1(gb);
1368     refdist = get_bits1(gb); // refdist flag
1369     v->s.loop_filter = get_bits1(gb);
1370     v->fastuvmc = get_bits1(gb);
1371     v->extended_mv = get_bits1(gb);
1372     v->dquant = get_bits(gb, 2);
1373     v->vstransform = get_bits1(gb);
1374     v->overlap = get_bits1(gb);
1375     v->quantizer_mode = get_bits(gb, 2);
1376
1377     if(v->hrd_param_flag){
1378         for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1379             get_bits(gb, 8); //hrd_full[n]
1380         }
1381     }
1382
1383     if(get_bits1(gb)){
1384         avctx->coded_width = (get_bits(gb, 12)+1)<<1;
1385         avctx->coded_height = (get_bits(gb, 12)+1)<<1;
1386     }
1387     if(v->extended_mv)
1388         v->extended_dmv = get_bits1(gb);
1389     if(get_bits1(gb)) {
1390         av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
1391         skip_bits(gb, 3); // Y range, ignored for now
1392     }
1393     if(get_bits1(gb)) {
1394         av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
1395         skip_bits(gb, 3); // UV range, ignored for now
1396     }
1397
1398     av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
1399         "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1400         "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1401         "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1402         blink, 1 - avctx->max_b_frames, v->panscanflag, refdist, v->s.loop_filter,
1403         v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
1404
1405     return 0;
1406 }
1407
1408 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1409 {
1410     int pqindex, lowquant, status;
1411
1412     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1413     skip_bits(gb, 2); //framecnt unused
1414     v->rangeredfrm = 0;
1415     if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1416     v->s.pict_type = get_bits(gb, 1);
1417     if (v->s.avctx->max_b_frames) {
1418         if (!v->s.pict_type) {
1419             if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1420             else v->s.pict_type = B_TYPE;
1421         } else v->s.pict_type = P_TYPE;
1422     } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1423
1424     v->bi_type = 0;
1425     if(v->s.pict_type == B_TYPE) {
1426         v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1427         v->bfraction = vc1_bfraction_lut[v->bfraction];
1428         if(v->bfraction == 0) {
1429             v->s.pict_type = BI_TYPE;
1430         }
1431     }
1432     if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1433         get_bits(gb, 7); // skip buffer fullness
1434
1435     /* calculate RND */
1436     if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1437         v->rnd = 1;
1438     if(v->s.pict_type == P_TYPE)
1439         v->rnd ^= 1;
1440
1441     /* Quantizer stuff */
1442     pqindex = get_bits(gb, 5);
1443     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1444         v->pq = pquant_table[0][pqindex];
1445     else
1446         v->pq = pquant_table[1][pqindex];
1447
1448     v->pquantizer = 1;
1449     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1450         v->pquantizer = pqindex < 9;
1451     if (v->quantizer_mode == QUANT_NON_UNIFORM)
1452         v->pquantizer = 0;
1453     v->pqindex = pqindex;
1454     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1455     else v->halfpq = 0;
1456     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1457         v->pquantizer = get_bits(gb, 1);
1458     v->dquantfrm = 0;
1459     if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1460     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1461     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1462     v->range_x = 1 << (v->k_x - 1);
1463     v->range_y = 1 << (v->k_y - 1);
1464     if (v->profile == PROFILE_ADVANCED)
1465     {
1466         if (v->postprocflag) v->postproc = get_bits(gb, 1);
1467     }
1468     else
1469         if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1470
1471 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1472 //        (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1473
1474     if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
1475
1476     switch(v->s.pict_type) {
1477     case P_TYPE:
1478         if (v->pq < 5) v->tt_index = 0;
1479         else if(v->pq < 13) v->tt_index = 1;
1480         else v->tt_index = 2;
1481
1482         lowquant = (v->pq > 12) ? 0 : 1;
1483         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1484         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1485         {
1486             int scale, shift, i;
1487             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1488             v->lumscale = get_bits(gb, 6);
1489             v->lumshift = get_bits(gb, 6);
1490             v->use_ic = 1;
1491             /* fill lookup tables for intensity compensation */
1492             if(!v->lumscale) {
1493                 scale = -64;
1494                 shift = (255 - v->lumshift * 2) << 6;
1495                 if(v->lumshift > 31)
1496                     shift += 128 << 6;
1497             } else {
1498                 scale = v->lumscale + 32;
1499                 if(v->lumshift > 31)
1500                     shift = (v->lumshift - 64) << 6;
1501                 else
1502                     shift = v->lumshift << 6;
1503             }
1504             for(i = 0; i < 256; i++) {
1505                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1506                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1507             }
1508         }
1509         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1510             v->s.quarter_sample = 0;
1511         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1512             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1513                 v->s.quarter_sample = 0;
1514             else
1515                 v->s.quarter_sample = 1;
1516         } else
1517             v->s.quarter_sample = 1;
1518         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));
1519
1520         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1521                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1522                 || v->mv_mode == MV_PMODE_MIXED_MV)
1523         {
1524             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1525             if (status < 0) return -1;
1526             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1527                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1528         } else {
1529             v->mv_type_is_raw = 0;
1530             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1531         }
1532         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1533         if (status < 0) return -1;
1534         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1535                "Imode: %i, Invert: %i\n", status>>1, status&1);
1536
1537         /* Hopefully this is correct for P frames */
1538         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1539         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1540
1541         if (v->dquant)
1542         {
1543             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1544             vop_dquant_decoding(v);
1545         }
1546
1547         v->ttfrm = 0; //FIXME Is that so ?
1548         if (v->vstransform)
1549         {
1550             v->ttmbf = get_bits(gb, 1);
1551             if (v->ttmbf)
1552             {
1553                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1554             }
1555         } else {
1556             v->ttmbf = 1;
1557             v->ttfrm = TT_8X8;
1558         }
1559         break;
1560     case B_TYPE:
1561         if (v->pq < 5) v->tt_index = 0;
1562         else if(v->pq < 13) v->tt_index = 1;
1563         else v->tt_index = 2;
1564
1565         lowquant = (v->pq > 12) ? 0 : 1;
1566         v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1567         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1568         v->s.mspel = v->s.quarter_sample;
1569
1570         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1571         if (status < 0) return -1;
1572         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1573                "Imode: %i, Invert: %i\n", status>>1, status&1);
1574         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1575         if (status < 0) return -1;
1576         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1577                "Imode: %i, Invert: %i\n", status>>1, status&1);
1578
1579         v->s.mv_table_index = get_bits(gb, 2);
1580         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1581
1582         if (v->dquant)
1583         {
1584             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1585             vop_dquant_decoding(v);
1586         }
1587
1588         v->ttfrm = 0;
1589         if (v->vstransform)
1590         {
1591             v->ttmbf = get_bits(gb, 1);
1592             if (v->ttmbf)
1593             {
1594                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1595             }
1596         } else {
1597             v->ttmbf = 1;
1598             v->ttfrm = TT_8X8;
1599         }
1600         break;
1601     }
1602
1603     /* AC Syntax */
1604     v->c_ac_table_index = decode012(gb);
1605     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1606     {
1607         v->y_ac_table_index = decode012(gb);
1608     }
1609     /* DC Syntax */
1610     v->s.dc_table_index = get_bits(gb, 1);
1611
1612     if(v->s.pict_type == BI_TYPE) {
1613         v->s.pict_type = B_TYPE;
1614         v->bi_type = 1;
1615     }
1616     return 0;
1617 }
1618
1619 static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
1620 {
1621     int pqindex, lowquant;
1622     int status;
1623
1624     v->p_frame_skipped = 0;
1625
1626     if(v->interlace)
1627         v->fcm = decode012(gb);
1628     switch(get_prefix(gb, 0, 4)) {
1629     case 0:
1630         v->s.pict_type = P_TYPE;
1631         break;
1632     case 1:
1633         v->s.pict_type = B_TYPE;
1634         break;
1635     case 2:
1636         v->s.pict_type = I_TYPE;
1637         break;
1638     case 3:
1639         v->s.pict_type = BI_TYPE;
1640         break;
1641     case 4:
1642         v->s.pict_type = P_TYPE; // skipped pic
1643         v->p_frame_skipped = 1;
1644         return 0;
1645     }
1646     if(v->tfcntrflag)
1647         get_bits(gb, 8);
1648     if(v->broadcast) {
1649         if(!v->interlace || v->panscanflag) {
1650             v->rptfrm = get_bits(gb, 2);
1651         } else {
1652             v->tff = get_bits1(gb);
1653             v->rptfrm = get_bits1(gb);
1654         }
1655     }
1656     if(v->panscanflag) {
1657         //...
1658     }
1659     v->rnd = get_bits1(gb);
1660     if(v->interlace)
1661         v->uvsamp = get_bits1(gb);
1662     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1663     if(v->s.pict_type == B_TYPE) {
1664         v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1665         v->bfraction = vc1_bfraction_lut[v->bfraction];
1666         if(v->bfraction == 0) {
1667             v->s.pict_type = BI_TYPE; /* XXX: should not happen here */
1668         }
1669     }
1670     pqindex = get_bits(gb, 5);
1671     v->pqindex = pqindex;
1672     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1673         v->pq = pquant_table[0][pqindex];
1674     else
1675         v->pq = pquant_table[1][pqindex];
1676
1677     v->pquantizer = 1;
1678     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1679         v->pquantizer = pqindex < 9;
1680     if (v->quantizer_mode == QUANT_NON_UNIFORM)
1681         v->pquantizer = 0;
1682     v->pqindex = pqindex;
1683     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1684     else v->halfpq = 0;
1685     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1686         v->pquantizer = get_bits(gb, 1);
1687
1688     switch(v->s.pict_type) {
1689     case I_TYPE:
1690     case BI_TYPE:
1691         status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1692         if (status < 0) return -1;
1693         av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1694                 "Imode: %i, Invert: %i\n", status>>1, status&1);
1695         v->condover = CONDOVER_NONE;
1696         if(v->overlap && v->pq <= 8) {
1697             v->condover = decode012(gb);
1698             if(v->condover == CONDOVER_SELECT) {
1699                 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1700                 if (status < 0) return -1;
1701                 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1702                         "Imode: %i, Invert: %i\n", status>>1, status&1);
1703             }
1704         }
1705         break;
1706     case P_TYPE:
1707         if(v->postprocflag)
1708             v->postproc = get_bits1(gb);
1709         if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1710         else v->mvrange = 0;
1711         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1712         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1713         v->range_x = 1 << (v->k_x - 1);
1714         v->range_y = 1 << (v->k_y - 1);
1715
1716         if (v->pq < 5) v->tt_index = 0;
1717         else if(v->pq < 13) v->tt_index = 1;
1718         else v->tt_index = 2;
1719
1720         lowquant = (v->pq > 12) ? 0 : 1;
1721         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1722         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1723         {
1724             int scale, shift, i;
1725             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1726             v->lumscale = get_bits(gb, 6);
1727             v->lumshift = get_bits(gb, 6);
1728             /* fill lookup tables for intensity compensation */
1729             if(!v->lumscale) {
1730                 scale = -64;
1731                 shift = (255 - v->lumshift * 2) << 6;
1732                 if(v->lumshift > 31)
1733                     shift += 128 << 6;
1734             } else {
1735                 scale = v->lumscale + 32;
1736                 if(v->lumshift > 31)
1737                     shift = (v->lumshift - 64) << 6;
1738                 else
1739                     shift = v->lumshift << 6;
1740             }
1741             for(i = 0; i < 256; i++) {
1742                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1743                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1744             }
1745         }
1746         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1747             v->s.quarter_sample = 0;
1748         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1749             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1750                 v->s.quarter_sample = 0;
1751             else
1752                 v->s.quarter_sample = 1;
1753         } else
1754             v->s.quarter_sample = 1;
1755         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));
1756
1757         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1758                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1759                 || v->mv_mode == MV_PMODE_MIXED_MV)
1760         {
1761             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1762             if (status < 0) return -1;
1763             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1764                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1765         } else {
1766             v->mv_type_is_raw = 0;
1767             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1768         }
1769         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1770         if (status < 0) return -1;
1771         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1772                "Imode: %i, Invert: %i\n", status>>1, status&1);
1773
1774         /* Hopefully this is correct for P frames */
1775         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1776         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1777         if (v->dquant)
1778         {
1779             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1780             vop_dquant_decoding(v);
1781         }
1782
1783         v->ttfrm = 0; //FIXME Is that so ?
1784         if (v->vstransform)
1785         {
1786             v->ttmbf = get_bits(gb, 1);
1787             if (v->ttmbf)
1788             {
1789                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1790             }
1791         } else {
1792             v->ttmbf = 1;
1793             v->ttfrm = TT_8X8;
1794         }
1795         break;
1796     case B_TYPE:
1797         if(v->postprocflag)
1798             v->postproc = get_bits1(gb);
1799         if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1800         else v->mvrange = 0;
1801         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1802         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1803         v->range_x = 1 << (v->k_x - 1);
1804         v->range_y = 1 << (v->k_y - 1);
1805
1806         if (v->pq < 5) v->tt_index = 0;
1807         else if(v->pq < 13) v->tt_index = 1;
1808         else v->tt_index = 2;
1809
1810         lowquant = (v->pq > 12) ? 0 : 1;
1811         v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1812         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1813         v->s.mspel = v->s.quarter_sample;
1814
1815         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1816         if (status < 0) return -1;
1817         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1818                "Imode: %i, Invert: %i\n", status>>1, status&1);
1819         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1820         if (status < 0) return -1;
1821         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1822                "Imode: %i, Invert: %i\n", status>>1, status&1);
1823
1824         v->s.mv_table_index = get_bits(gb, 2);
1825         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1826
1827         if (v->dquant)
1828         {
1829             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1830             vop_dquant_decoding(v);
1831         }
1832
1833         v->ttfrm = 0;
1834         if (v->vstransform)
1835         {
1836             v->ttmbf = get_bits(gb, 1);
1837             if (v->ttmbf)
1838             {
1839                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1840             }
1841         } else {
1842             v->ttmbf = 1;
1843             v->ttfrm = TT_8X8;
1844         }
1845         break;
1846     }
1847
1848     /* AC Syntax */
1849     v->c_ac_table_index = decode012(gb);
1850     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1851     {
1852         v->y_ac_table_index = decode012(gb);
1853     }
1854     /* DC Syntax */
1855     v->s.dc_table_index = get_bits(gb, 1);
1856     if ((v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE) && v->dquant) {
1857         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1858         vop_dquant_decoding(v);
1859     }
1860
1861     v->bi_type = 0;
1862     if(v->s.pict_type == BI_TYPE) {
1863         v->s.pict_type = B_TYPE;
1864         v->bi_type = 1;
1865     }
1866     return 0;
1867 }
1868
1869 /***********************************************************************/
1870 /**
1871  * @defgroup block VC-1 Block-level functions
1872  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1873  * @{
1874  */
1875
1876 /**
1877  * @def GET_MQUANT
1878  * @brief Get macroblock-level quantizer scale
1879  */
1880 #define GET_MQUANT()                                           \
1881   if (v->dquantfrm)                                            \
1882   {                                                            \
1883     int edges = 0;                                             \
1884     if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1885     {                                                          \
1886       if (v->dqbilevel)                                        \
1887       {                                                        \
1888         mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
1889       }                                                        \
1890       else                                                     \
1891       {                                                        \
1892         mqdiff = get_bits(gb, 3);                              \
1893         if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1894         else mquant = get_bits(gb, 5);                         \
1895       }                                                        \
1896     }                                                          \
1897     if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
1898         edges = 1 << v->dqsbedge;                              \
1899     else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1900         edges = (3 << v->dqsbedge) % 15;                       \
1901     else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1902         edges = 15;                                            \
1903     if((edges&1) && !s->mb_x)                                  \
1904         mquant = v->altpq;                                     \
1905     if((edges&2) && s->first_slice_line)                       \
1906         mquant = v->altpq;                                     \
1907     if((edges&4) && s->mb_x == (s->mb_width - 1))              \
1908         mquant = v->altpq;                                     \
1909     if((edges&8) && s->mb_y == (s->mb_height - 1))             \
1910         mquant = v->altpq;                                     \
1911   }
1912
1913 /**
1914  * @def GET_MVDATA(_dmv_x, _dmv_y)
1915  * @brief Get MV differentials
1916  * @see MVDATA decoding from 8.3.5.2, p(1)20
1917  * @param _dmv_x Horizontal differential for decoded MV
1918  * @param _dmv_y Vertical differential for decoded MV
1919  */
1920 #define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1921   index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1922                        VC1_MV_DIFF_VLC_BITS, 2);                    \
1923   if (index > 36)                                                   \
1924   {                                                                 \
1925     mb_has_coeffs = 1;                                              \
1926     index -= 37;                                                    \
1927   }                                                                 \
1928   else mb_has_coeffs = 0;                                           \
1929   s->mb_intra = 0;                                                  \
1930   if (!index) { _dmv_x = _dmv_y = 0; }                              \
1931   else if (index == 35)                                             \
1932   {                                                                 \
1933     _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1934     _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1935   }                                                                 \
1936   else if (index == 36)                                             \
1937   {                                                                 \
1938     _dmv_x = 0;                                                     \
1939     _dmv_y = 0;                                                     \
1940     s->mb_intra = 1;                                                \
1941   }                                                                 \
1942   else                                                              \
1943   {                                                                 \
1944     index1 = index%6;                                               \
1945     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1946     else                                   val = 0;                 \
1947     if(size_table[index1] - val > 0)                                \
1948         val = get_bits(gb, size_table[index1] - val);               \
1949     else                                   val = 0;                 \
1950     sign = 0 - (val&1);                                             \
1951     _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1952                                                                     \
1953     index1 = index/6;                                               \
1954     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1955     else                                   val = 0;                 \
1956     if(size_table[index1] - val > 0)                                \
1957         val = get_bits(gb, size_table[index1] - val);               \
1958     else                                   val = 0;                 \
1959     sign = 0 - (val&1);                                             \
1960     _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1961   }
1962
1963 /** Predict and set motion vector
1964  */
1965 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)
1966 {
1967     int xy, wrap, off = 0;
1968     int16_t *A, *B, *C;
1969     int px, py;
1970     int sum;
1971
1972     /* scale MV difference to be quad-pel */
1973     dmv_x <<= 1 - s->quarter_sample;
1974     dmv_y <<= 1 - s->quarter_sample;
1975
1976     wrap = s->b8_stride;
1977     xy = s->block_index[n];
1978
1979     if(s->mb_intra){
1980         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1981         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1982         if(mv1) { /* duplicate motion data for 1-MV block */
1983             s->current_picture.motion_val[0][xy + 1][0] = 0;
1984             s->current_picture.motion_val[0][xy + 1][1] = 0;
1985             s->current_picture.motion_val[0][xy + wrap][0] = 0;
1986             s->current_picture.motion_val[0][xy + wrap][1] = 0;
1987             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1988             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1989         }
1990         return;
1991     }
1992
1993     C = s->current_picture.motion_val[0][xy - 1];
1994     A = s->current_picture.motion_val[0][xy - wrap];
1995     if(mv1)
1996         off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1997     else {
1998         //in 4-MV mode different blocks have different B predictor position
1999         switch(n){
2000         case 0:
2001             off = (s->mb_x > 0) ? -1 : 1;
2002             break;
2003         case 1:
2004             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
2005             break;
2006         case 2:
2007             off = 1;
2008             break;
2009         case 3:
2010             off = -1;
2011         }
2012     }
2013     B = s->current_picture.motion_val[0][xy - wrap + off];
2014
2015     if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
2016         if(s->mb_width == 1) {
2017             px = A[0];
2018             py = A[1];
2019         } else {
2020             px = mid_pred(A[0], B[0], C[0]);
2021             py = mid_pred(A[1], B[1], C[1]);
2022         }
2023     } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
2024         px = C[0];
2025         py = C[1];
2026     } else {
2027         px = py = 0;
2028     }
2029     /* Pullback MV as specified in 8.3.5.3.4 */
2030     {
2031         int qx, qy, X, Y;
2032         qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
2033         qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
2034         X = (s->mb_width << 6) - 4;
2035         Y = (s->mb_height << 6) - 4;
2036         if(mv1) {
2037             if(qx + px < -60) px = -60 - qx;
2038             if(qy + py < -60) py = -60 - qy;
2039         } else {
2040             if(qx + px < -28) px = -28 - qx;
2041             if(qy + py < -28) py = -28 - qy;
2042         }
2043         if(qx + px > X) px = X - qx;
2044         if(qy + py > Y) py = Y - qy;
2045     }
2046     /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2047     if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
2048         if(is_intra[xy - wrap])
2049             sum = FFABS(px) + FFABS(py);
2050         else
2051             sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2052         if(sum > 32) {
2053             if(get_bits1(&s->gb)) {
2054                 px = A[0];
2055                 py = A[1];
2056             } else {
2057                 px = C[0];
2058                 py = C[1];
2059             }
2060         } else {
2061             if(is_intra[xy - 1])
2062                 sum = FFABS(px) + FFABS(py);
2063             else
2064                 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2065             if(sum > 32) {
2066                 if(get_bits1(&s->gb)) {
2067                     px = A[0];
2068                     py = A[1];
2069                 } else {
2070                     px = C[0];
2071                     py = C[1];
2072                 }
2073             }
2074         }
2075     }
2076     /* store MV using signed modulus of MV range defined in 4.11 */
2077     s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
2078     s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
2079     if(mv1) { /* duplicate motion data for 1-MV block */
2080         s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
2081         s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
2082         s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
2083         s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
2084         s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
2085         s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
2086     }
2087 }
2088
2089 /** Motion compensation for direct or interpolated blocks in B-frames
2090  */
2091 static void vc1_interp_mc(VC1Context *v)
2092 {
2093     MpegEncContext *s = &v->s;
2094     DSPContext *dsp = &v->s.dsp;
2095     uint8_t *srcY, *srcU, *srcV;
2096     int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
2097
2098     if(!v->s.next_picture.data[0])return;
2099
2100     mx = s->mv[1][0][0];
2101     my = s->mv[1][0][1];
2102     uvmx = (mx + ((mx & 3) == 3)) >> 1;
2103     uvmy = (my + ((my & 3) == 3)) >> 1;
2104     if(v->fastuvmc) {
2105         uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
2106         uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
2107     }
2108     srcY = s->next_picture.data[0];
2109     srcU = s->next_picture.data[1];
2110     srcV = s->next_picture.data[2];
2111
2112     src_x = s->mb_x * 16 + (mx >> 2);
2113     src_y = s->mb_y * 16 + (my >> 2);
2114     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
2115     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
2116
2117     src_x   = clip(  src_x, -16, s->mb_width  * 16);
2118     src_y   = clip(  src_y, -16, s->mb_height * 16);
2119     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
2120     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
2121
2122     srcY += src_y * s->linesize + src_x;
2123     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
2124     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
2125
2126     /* for grayscale we should not try to read from unknown area */
2127     if(s->flags & CODEC_FLAG_GRAY) {
2128         srcU = s->edge_emu_buffer + 18 * s->linesize;
2129         srcV = s->edge_emu_buffer + 18 * s->linesize;
2130     }
2131
2132     if(v->rangeredfrm
2133        || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
2134        || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
2135         uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
2136
2137         srcY -= s->mspel * (1 + s->linesize);
2138         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
2139                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
2140         srcY = s->edge_emu_buffer;
2141         ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
2142                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2143         ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
2144                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2145         srcU = uvbuf;
2146         srcV = uvbuf + 16;
2147         /* if we deal with range reduction we need to scale source blocks */
2148         if(v->rangeredfrm) {
2149             int i, j;
2150             uint8_t *src, *src2;
2151
2152             src = srcY;
2153             for(j = 0; j < 17 + s->mspel*2; j++) {
2154                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
2155                 src += s->linesize;
2156             }
2157             src = srcU; src2 = srcV;
2158             for(j = 0; j < 9; j++) {
2159                 for(i = 0; i < 9; i++) {
2160                     src[i] = ((src[i] - 128) >> 1) + 128;
2161                     src2[i] = ((src2[i] - 128) >> 1) + 128;
2162                 }
2163                 src += s->uvlinesize;
2164                 src2 += s->uvlinesize;
2165             }
2166         }
2167         srcY += s->mspel * (1 + s->linesize);
2168     }
2169
2170     mx >>= 1;
2171     my >>= 1;
2172     dxy = ((my & 1) << 1) | (mx & 1);
2173
2174     dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
2175
2176     if(s->flags & CODEC_FLAG_GRAY) return;
2177     /* Chroma MC always uses qpel blilinear */
2178     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
2179     uvmx = (uvmx&3)<<1;
2180     uvmy = (uvmy&3)<<1;
2181     dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
2182     dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
2183 }
2184
2185 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2186 {
2187     int n = bfrac;
2188
2189 #if B_FRACTION_DEN==256
2190     if(inv)
2191         n -= 256;
2192     if(!qs)
2193         return 2 * ((value * n + 255) >> 9);
2194     return (value * n + 128) >> 8;
2195 #else
2196     if(inv)
2197         n -= B_FRACTION_DEN;
2198     if(!qs)
2199         return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2200     return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2201 #endif
2202 }
2203
2204 /** Reconstruct motion vector for B-frame and do motion compensation
2205  */
2206 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
2207 {
2208     if(v->use_ic) {
2209         v->mv_mode2 = v->mv_mode;
2210         v->mv_mode = MV_PMODE_INTENSITY_COMP;
2211     }
2212     if(direct) {
2213         vc1_mc_1mv(v, 0);
2214         vc1_interp_mc(v);
2215         if(v->use_ic) v->mv_mode = v->mv_mode2;
2216         return;
2217     }
2218     if(mode == BMV_TYPE_INTERPOLATED) {
2219         vc1_mc_1mv(v, 0);
2220         vc1_interp_mc(v);
2221         if(v->use_ic) v->mv_mode = v->mv_mode2;
2222         return;
2223     }
2224
2225     if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
2226     vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2227     if(v->use_ic) v->mv_mode = v->mv_mode2;
2228 }
2229
2230 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
2231 {
2232     MpegEncContext *s = &v->s;
2233     int xy, wrap, off = 0;
2234     int16_t *A, *B, *C;
2235     int px, py;
2236     int sum;
2237     int r_x, r_y;
2238     const uint8_t *is_intra = v->mb_type[0];
2239
2240     r_x = v->range_x;
2241     r_y = v->range_y;
2242     /* scale MV difference to be quad-pel */
2243     dmv_x[0] <<= 1 - s->quarter_sample;
2244     dmv_y[0] <<= 1 - s->quarter_sample;
2245     dmv_x[1] <<= 1 - s->quarter_sample;
2246     dmv_y[1] <<= 1 - s->quarter_sample;
2247
2248     wrap = s->b8_stride;
2249     xy = s->block_index[0];
2250
2251     if(s->mb_intra) {
2252         s->current_picture.motion_val[0][xy][0] =
2253         s->current_picture.motion_val[0][xy][1] =
2254         s->current_picture.motion_val[1][xy][0] =
2255         s->current_picture.motion_val[1][xy][1] = 0;
2256         return;
2257     }
2258     s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2259     s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2260     s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2261     s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2262     if(direct) {
2263         s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2264         s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2265         s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2266         s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2267         return;
2268     }
2269
2270     if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2271         C = s->current_picture.motion_val[0][xy - 2];
2272         A = s->current_picture.motion_val[0][xy - wrap*2];
2273         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2274         B = s->current_picture.motion_val[0][xy - wrap*2 + off];
2275
2276         if(!s->first_slice_line) { // predictor A is not out of bounds
2277             if(s->mb_width == 1) {
2278                 px = A[0];
2279                 py = A[1];
2280             } else {
2281                 px = mid_pred(A[0], B[0], C[0]);
2282                 py = mid_pred(A[1], B[1], C[1]);
2283             }
2284         } else if(s->mb_x) { // predictor C is not out of bounds
2285             px = C[0];
2286             py = C[1];
2287         } else {
2288             px = py = 0;
2289         }
2290         /* Pullback MV as specified in 8.3.5.3.4 */
2291         {
2292             int qx, qy, X, Y;
2293             if(v->profile < PROFILE_ADVANCED) {
2294                 qx = (s->mb_x << 5);
2295                 qy = (s->mb_y << 5);
2296                 X = (s->mb_width << 5) - 4;
2297                 Y = (s->mb_height << 5) - 4;
2298                 if(qx + px < -28) px = -28 - qx;
2299                 if(qy + py < -28) py = -28 - qy;
2300                 if(qx + px > X) px = X - qx;
2301                 if(qy + py > Y) py = Y - qy;
2302             } else {
2303                 qx = (s->mb_x << 6);
2304                 qy = (s->mb_y << 6);
2305                 X = (s->mb_width << 6) - 4;
2306                 Y = (s->mb_height << 6) - 4;
2307                 if(qx + px < -60) px = -60 - qx;
2308                 if(qy + py < -60) py = -60 - qy;
2309                 if(qx + px > X) px = X - qx;
2310                 if(qy + py > Y) py = Y - qy;
2311             }
2312         }
2313         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2314         if(0 && !s->first_slice_line && s->mb_x) {
2315             if(is_intra[xy - wrap])
2316                 sum = FFABS(px) + FFABS(py);
2317             else
2318                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2319             if(sum > 32) {
2320                 if(get_bits1(&s->gb)) {
2321                     px = A[0];
2322                     py = A[1];
2323                 } else {
2324                     px = C[0];
2325                     py = C[1];
2326                 }
2327             } else {
2328                 if(is_intra[xy - 2])
2329                     sum = FFABS(px) + FFABS(py);
2330                 else
2331                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2332                 if(sum > 32) {
2333                     if(get_bits1(&s->gb)) {
2334                         px = A[0];
2335                         py = A[1];
2336                     } else {
2337                         px = C[0];
2338                         py = C[1];
2339                     }
2340                 }
2341             }
2342         }
2343         /* store MV using signed modulus of MV range defined in 4.11 */
2344         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2345         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2346     }
2347     if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2348         C = s->current_picture.motion_val[1][xy - 2];
2349         A = s->current_picture.motion_val[1][xy - wrap*2];
2350         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2351         B = s->current_picture.motion_val[1][xy - wrap*2 + off];
2352
2353         if(!s->first_slice_line) { // predictor A is not out of bounds
2354             if(s->mb_width == 1) {
2355                 px = A[0];
2356                 py = A[1];
2357             } else {
2358                 px = mid_pred(A[0], B[0], C[0]);
2359                 py = mid_pred(A[1], B[1], C[1]);
2360             }
2361         } else if(s->mb_x) { // predictor C is not out of bounds
2362             px = C[0];
2363             py = C[1];
2364         } else {
2365             px = py = 0;
2366         }
2367         /* Pullback MV as specified in 8.3.5.3.4 */
2368         {
2369             int qx, qy, X, Y;
2370             if(v->profile < PROFILE_ADVANCED) {
2371                 qx = (s->mb_x << 5);
2372                 qy = (s->mb_y << 5);
2373                 X = (s->mb_width << 5) - 4;
2374                 Y = (s->mb_height << 5) - 4;
2375                 if(qx + px < -28) px = -28 - qx;
2376                 if(qy + py < -28) py = -28 - qy;
2377                 if(qx + px > X) px = X - qx;
2378                 if(qy + py > Y) py = Y - qy;
2379             } else {
2380                 qx = (s->mb_x << 6);
2381                 qy = (s->mb_y << 6);
2382                 X = (s->mb_width << 6) - 4;
2383                 Y = (s->mb_height << 6) - 4;
2384                 if(qx + px < -60) px = -60 - qx;
2385                 if(qy + py < -60) py = -60 - qy;
2386                 if(qx + px > X) px = X - qx;
2387                 if(qy + py > Y) py = Y - qy;
2388             }
2389         }
2390         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2391         if(0 && !s->first_slice_line && s->mb_x) {
2392             if(is_intra[xy - wrap])
2393                 sum = FFABS(px) + FFABS(py);
2394             else
2395                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2396             if(sum > 32) {
2397                 if(get_bits1(&s->gb)) {
2398                     px = A[0];
2399                     py = A[1];
2400                 } else {
2401                     px = C[0];
2402                     py = C[1];
2403                 }
2404             } else {
2405                 if(is_intra[xy - 2])
2406                     sum = FFABS(px) + FFABS(py);
2407                 else
2408                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2409                 if(sum > 32) {
2410                     if(get_bits1(&s->gb)) {
2411                         px = A[0];
2412                         py = A[1];
2413                     } else {
2414                         px = C[0];
2415                         py = C[1];
2416                     }
2417                 }
2418             }
2419         }
2420         /* store MV using signed modulus of MV range defined in 4.11 */
2421
2422         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2423         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2424     }
2425     s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2426     s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2427     s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2428     s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2429 }
2430
2431 /** Get predicted DC value for I-frames only
2432  * prediction dir: left=0, top=1
2433  * @param s MpegEncContext
2434  * @param[in] n block index in the current MB
2435  * @param dc_val_ptr Pointer to DC predictor
2436  * @param dir_ptr Prediction direction for use in AC prediction
2437  */
2438 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2439                               int16_t **dc_val_ptr, int *dir_ptr)
2440 {
2441     int a, b, c, wrap, pred, scale;
2442     int16_t *dc_val;
2443     static const uint16_t dcpred[32] = {
2444     -1, 1024,  512,  341,  256,  205,  171,  146,  128,
2445          114,  102,   93,   85,   79,   73,   68,   64,
2446           60,   57,   54,   51,   49,   47,   45,   43,
2447           41,   39,   38,   37,   35,   34,   33
2448     };
2449
2450     /* find prediction - wmv3_dc_scale always used here in fact */
2451     if (n < 4)     scale = s->y_dc_scale;
2452     else           scale = s->c_dc_scale;
2453
2454     wrap = s->block_wrap[n];
2455     dc_val= s->dc_val[0] + s->block_index[n];
2456
2457     /* B A
2458      * C X
2459      */
2460     c = dc_val[ - 1];
2461     b = dc_val[ - 1 - wrap];
2462     a = dc_val[ - wrap];
2463
2464     if (pq < 9 || !overlap)
2465     {
2466         /* Set outer values */
2467         if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
2468         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
2469     }
2470     else
2471     {
2472         /* Set outer values */
2473         if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
2474         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
2475     }
2476
2477     if (abs(a - b) <= abs(b - c)) {
2478         pred = c;
2479         *dir_ptr = 1;//left
2480     } else {
2481         pred = a;
2482         *dir_ptr = 0;//top
2483     }
2484
2485     /* update predictor */
2486     *dc_val_ptr = &dc_val[0];
2487     return pred;
2488 }
2489
2490
2491 /** Get predicted DC value
2492  * prediction dir: left=0, top=1
2493  * @param s MpegEncContext
2494  * @param[in] n block index in the current MB
2495  * @param dc_val_ptr Pointer to DC predictor
2496  * @param dir_ptr Prediction direction for use in AC prediction
2497  */
2498 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2499                               int a_avail, int c_avail,
2500                               int16_t **dc_val_ptr, int *dir_ptr)
2501 {
2502     int a, b, c, wrap, pred, scale;
2503     int16_t *dc_val;
2504     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2505     int q1, q2 = 0;
2506
2507     /* find prediction - wmv3_dc_scale always used here in fact */
2508     if (n < 4)     scale = s->y_dc_scale;
2509     else           scale = s->c_dc_scale;
2510
2511     wrap = s->block_wrap[n];
2512     dc_val= s->dc_val[0] + s->block_index[n];
2513
2514     /* B A
2515      * C X
2516      */
2517     c = dc_val[ - 1];
2518     b = dc_val[ - 1 - wrap];
2519     a = dc_val[ - wrap];
2520     /* scale predictors if needed */
2521     q1 = s->current_picture.qscale_table[mb_pos];
2522     if(c_avail && (n!= 1 && n!=3)) {
2523         q2 = s->current_picture.qscale_table[mb_pos - 1];
2524         if(q2 && q2 != q1)
2525             c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2526     }
2527     if(a_avail && (n!= 2 && n!=3)) {
2528         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2529         if(q2 && q2 != q1)
2530             a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2531     }
2532     if(a_avail && c_avail && (n!=3)) {
2533         int off = mb_pos;
2534         if(n != 1) off--;
2535         if(n != 2) off -= s->mb_stride;
2536         q2 = s->current_picture.qscale_table[off];
2537         if(q2 && q2 != q1)
2538             b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2539     }
2540
2541     if(a_avail && c_avail) {
2542         if(abs(a - b) <= abs(b - c)) {
2543             pred = c;
2544             *dir_ptr = 1;//left
2545         } else {
2546             pred = a;
2547             *dir_ptr = 0;//top
2548         }
2549     } else if(a_avail) {
2550         pred = a;
2551         *dir_ptr = 0;//top
2552     } else if(c_avail) {
2553         pred = c;
2554         *dir_ptr = 1;//left
2555     } else {
2556         pred = 0;
2557         *dir_ptr = 1;//left
2558     }
2559
2560     /* update predictor */
2561     *dc_val_ptr = &dc_val[0];
2562     return pred;
2563 }
2564
2565
2566 /**
2567  * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2568  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2569  * @{
2570  */
2571
2572 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
2573 {
2574     int xy, wrap, pred, a, b, c;
2575
2576     xy = s->block_index[n];
2577     wrap = s->b8_stride;
2578
2579     /* B C
2580      * A X
2581      */
2582     a = s->coded_block[xy - 1       ];
2583     b = s->coded_block[xy - 1 - wrap];
2584     c = s->coded_block[xy     - wrap];
2585
2586     if (b == c) {
2587         pred = a;
2588     } else {
2589         pred = c;
2590     }
2591
2592     /* store value */
2593     *coded_block_ptr = &s->coded_block[xy];
2594
2595     return pred;
2596 }
2597
2598 /**
2599  * Decode one AC coefficient
2600  * @param v The VC1 context
2601  * @param last Last coefficient
2602  * @param skip How much zero coefficients to skip
2603  * @param value Decoded AC coefficient value
2604  * @see 8.1.3.4
2605  */
2606 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
2607 {
2608     GetBitContext *gb = &v->s.gb;
2609     int index, escape, run = 0, level = 0, lst = 0;
2610
2611     index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2612     if (index != vc1_ac_sizes[codingset] - 1) {
2613         run = vc1_index_decode_table[codingset][index][0];
2614         level = vc1_index_decode_table[codingset][index][1];
2615         lst = index >= vc1_last_decode_table[codingset];
2616         if(get_bits(gb, 1))
2617             level = -level;
2618     } else {
2619         escape = decode210(gb);
2620         if (escape != 2) {
2621             index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2622             run = vc1_index_decode_table[codingset][index][0];
2623             level = vc1_index_decode_table[codingset][index][1];
2624             lst = index >= vc1_last_decode_table[codingset];
2625             if(escape == 0) {
2626                 if(lst)
2627                     level += vc1_last_delta_level_table[codingset][run];
2628                 else
2629                     level += vc1_delta_level_table[codingset][run];
2630             } else {
2631                 if(lst)
2632                     run += vc1_last_delta_run_table[codingset][level] + 1;
2633                 else
2634                     run += vc1_delta_run_table[codingset][level] + 1;
2635             }
2636             if(get_bits(gb, 1))
2637                 level = -level;
2638         } else {
2639             int sign;
2640             lst = get_bits(gb, 1);
2641             if(v->s.esc3_level_length == 0) {
2642                 if(v->pq < 8 || v->dquantfrm) { // table 59
2643                     v->s.esc3_level_length = get_bits(gb, 3);
2644                     if(!v->s.esc3_level_length)
2645                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
2646                 } else { //table 60
2647                     v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
2648                 }
2649                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2650             }
2651             run = get_bits(gb, v->s.esc3_run_length);
2652             sign = get_bits(gb, 1);
2653             level = get_bits(gb, v->s.esc3_level_length);
2654             if(sign)
2655                 level = -level;
2656         }
2657     }
2658
2659     *last = lst;
2660     *skip = run;
2661     *value = level;
2662 }
2663
2664 /** Decode intra block in intra frames - should be faster than decode_intra_block
2665  * @param v VC1Context
2666  * @param block block to decode
2667  * @param coded are AC coeffs present or not
2668  * @param codingset set of VLC to decode data
2669  */
2670 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
2671 {
2672     GetBitContext *gb = &v->s.gb;
2673     MpegEncContext *s = &v->s;
2674     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2675     int run_diff, i;
2676     int16_t *dc_val;
2677     int16_t *ac_val, *ac_val2;
2678     int dcdiff;
2679
2680     /* Get DC differential */
2681     if (n < 4) {
2682         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2683     } else {
2684         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2685     }
2686     if (dcdiff < 0){
2687         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2688         return -1;
2689     }
2690     if (dcdiff)
2691     {
2692         if (dcdiff == 119 /* ESC index value */)
2693         {
2694             /* TODO: Optimize */
2695             if (v->pq == 1) dcdiff = get_bits(gb, 10);
2696             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2697             else dcdiff = get_bits(gb, 8);
2698         }
2699         else
2700         {
2701             if (v->pq == 1)
2702                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2703             else if (v->pq == 2)
2704                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2705         }
2706         if (get_bits(gb, 1))
2707             dcdiff = -dcdiff;
2708     }
2709
2710     /* Prediction */
2711     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2712     *dc_val = dcdiff;
2713
2714     /* Store the quantized DC coeff, used for prediction */
2715     if (n < 4) {
2716         block[0] = dcdiff * s->y_dc_scale;
2717     } else {
2718         block[0] = dcdiff * s->c_dc_scale;
2719     }
2720     /* Skip ? */
2721     run_diff = 0;
2722     i = 0;
2723     if (!coded) {
2724         goto not_coded;
2725     }
2726
2727     //AC Decoding
2728     i = 1;
2729
2730     {
2731         int last = 0, skip, value;
2732         const int8_t *zz_table;
2733         int scale;
2734         int k;
2735
2736         scale = v->pq * 2 + v->halfpq;
2737
2738         if(v->s.ac_pred) {
2739             if(!dc_pred_dir)
2740                 zz_table = vc1_horizontal_zz;
2741             else
2742                 zz_table = vc1_vertical_zz;
2743         } else
2744             zz_table = vc1_normal_zz;
2745
2746         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2747         ac_val2 = ac_val;
2748         if(dc_pred_dir) //left
2749             ac_val -= 16;
2750         else //top
2751             ac_val -= 16 * s->block_wrap[n];
2752
2753         while (!last) {
2754             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2755             i += skip;
2756             if(i > 63)
2757                 break;
2758             block[zz_table[i++]] = value;
2759         }
2760
2761         /* apply AC prediction if needed */
2762         if(s->ac_pred) {
2763             if(dc_pred_dir) { //left
2764                 for(k = 1; k < 8; k++)
2765                     block[k << 3] += ac_val[k];
2766             } else { //top
2767                 for(k = 1; k < 8; k++)
2768                     block[k] += ac_val[k + 8];
2769             }
2770         }
2771         /* save AC coeffs for further prediction */
2772         for(k = 1; k < 8; k++) {
2773             ac_val2[k] = block[k << 3];
2774             ac_val2[k + 8] = block[k];
2775         }
2776
2777         /* scale AC coeffs */
2778         for(k = 1; k < 64; k++)
2779             if(block[k]) {
2780                 block[k] *= scale;
2781                 if(!v->pquantizer)
2782                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
2783             }
2784
2785         if(s->ac_pred) i = 63;
2786     }
2787
2788 not_coded:
2789     if(!coded) {
2790         int k, scale;
2791         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2792         ac_val2 = ac_val;
2793
2794         scale = v->pq * 2 + v->halfpq;
2795         memset(ac_val2, 0, 16 * 2);
2796         if(dc_pred_dir) {//left
2797             ac_val -= 16;
2798             if(s->ac_pred)
2799                 memcpy(ac_val2, ac_val, 8 * 2);
2800         } else {//top
2801             ac_val -= 16 * s->block_wrap[n];
2802             if(s->ac_pred)
2803                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2804         }
2805
2806         /* apply AC prediction if needed */
2807         if(s->ac_pred) {
2808             if(dc_pred_dir) { //left
2809                 for(k = 1; k < 8; k++) {
2810                     block[k << 3] = ac_val[k] * scale;
2811                     if(!v->pquantizer && block[k << 3])
2812                         block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2813                 }
2814             } else { //top
2815                 for(k = 1; k < 8; k++) {
2816                     block[k] = ac_val[k + 8] * scale;
2817                     if(!v->pquantizer && block[k])
2818                         block[k] += (block[k] < 0) ? -v->pq : v->pq;
2819                 }
2820             }
2821             i = 63;
2822         }
2823     }
2824     s->block_last_index[n] = i;
2825
2826     return 0;
2827 }
2828
2829 /** Decode intra block in intra frames - should be faster than decode_intra_block
2830  * @param v VC1Context
2831  * @param block block to decode
2832  * @param coded are AC coeffs present or not
2833  * @param codingset set of VLC to decode data
2834  */
2835 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
2836 {
2837     GetBitContext *gb = &v->s.gb;
2838     MpegEncContext *s = &v->s;
2839     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2840     int run_diff, i;
2841     int16_t *dc_val;
2842     int16_t *ac_val, *ac_val2;
2843     int dcdiff;
2844     int a_avail = v->a_avail, c_avail = v->c_avail;
2845     int use_pred = s->ac_pred;
2846     int scale;
2847     int q1, q2 = 0;
2848     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2849
2850     /* Get DC differential */
2851     if (n < 4) {
2852         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2853     } else {
2854         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2855     }
2856     if (dcdiff < 0){
2857         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2858         return -1;
2859     }
2860     if (dcdiff)
2861     {
2862         if (dcdiff == 119 /* ESC index value */)
2863         {
2864             /* TODO: Optimize */
2865             if (mquant == 1) dcdiff = get_bits(gb, 10);
2866             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2867             else dcdiff = get_bits(gb, 8);
2868         }
2869         else
2870         {
2871             if (mquant == 1)
2872                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2873             else if (mquant == 2)
2874                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2875         }
2876         if (get_bits(gb, 1))
2877             dcdiff = -dcdiff;
2878     }
2879
2880     /* Prediction */
2881     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2882     *dc_val = dcdiff;
2883
2884     /* Store the quantized DC coeff, used for prediction */
2885     if (n < 4) {
2886         block[0] = dcdiff * s->y_dc_scale;
2887     } else {
2888         block[0] = dcdiff * s->c_dc_scale;
2889     }
2890     /* Skip ? */
2891     run_diff = 0;
2892     i = 0;
2893
2894     //AC Decoding
2895     i = 1;
2896
2897     /* check if AC is needed at all and adjust direction if needed */
2898     if(!a_avail) dc_pred_dir = 1;
2899     if(!c_avail) dc_pred_dir = 0;
2900     if(!a_avail && !c_avail) use_pred = 0;
2901     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2902     ac_val2 = ac_val;
2903
2904     scale = mquant * 2 + v->halfpq;
2905
2906     if(dc_pred_dir) //left
2907         ac_val -= 16;
2908     else //top
2909         ac_val -= 16 * s->block_wrap[n];
2910
2911     q1 = s->current_picture.qscale_table[mb_pos];
2912     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
2913     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2914     if(n && n<4) q2 = q1;
2915
2916     if(coded) {
2917         int last = 0, skip, value;
2918         const int8_t *zz_table;
2919         int k;
2920
2921         if(v->s.ac_pred) {
2922             if(!dc_pred_dir)
2923                 zz_table = vc1_horizontal_zz;
2924             else
2925                 zz_table = vc1_vertical_zz;
2926         } else
2927             zz_table = vc1_normal_zz;
2928
2929         while (!last) {
2930             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2931             i += skip;
2932             if(i > 63)
2933                 break;
2934             block[zz_table[i++]] = value;
2935         }
2936
2937         /* apply AC prediction if needed */
2938         if(use_pred) {
2939             /* scale predictors if needed*/
2940             if(q2 && q1!=q2) {
2941                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2942                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2943
2944                 if(dc_pred_dir) { //left
2945                     for(k = 1; k < 8; k++)
2946                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2947                 } else { //top
2948                     for(k = 1; k < 8; k++)
2949                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2950                 }
2951             } else {
2952                 if(dc_pred_dir) { //left
2953                     for(k = 1; k < 8; k++)
2954                         block[k << 3] += ac_val[k];
2955                 } else { //top
2956                     for(k = 1; k < 8; k++)
2957                         block[k] += ac_val[k + 8];
2958                 }
2959             }
2960         }
2961         /* save AC coeffs for further prediction */
2962         for(k = 1; k < 8; k++) {
2963             ac_val2[k] = block[k << 3];
2964             ac_val2[k + 8] = block[k];
2965         }
2966
2967         /* scale AC coeffs */
2968         for(k = 1; k < 64; k++)
2969             if(block[k]) {
2970                 block[k] *= scale;
2971                 if(!v->pquantizer)
2972                     block[k] += (block[k] < 0) ? -mquant : mquant;
2973             }
2974
2975         if(use_pred) i = 63;
2976     } else { // no AC coeffs
2977         int k;
2978
2979         memset(ac_val2, 0, 16 * 2);
2980         if(dc_pred_dir) {//left
2981             if(use_pred) {
2982                 memcpy(ac_val2, ac_val, 8 * 2);
2983                 if(q2 && q1!=q2) {
2984                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2985                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2986                     for(k = 1; k < 8; k++)
2987                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2988                 }
2989             }
2990         } else {//top
2991             if(use_pred) {
2992                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2993                 if(q2 && q1!=q2) {
2994                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2995                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2996                     for(k = 1; k < 8; k++)
2997                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2998                 }
2999             }
3000         }
3001
3002         /* apply AC prediction if needed */
3003         if(use_pred) {
3004             if(dc_pred_dir) { //left
3005                 for(k = 1; k < 8; k++) {
3006                     block[k << 3] = ac_val2[k] * scale;
3007                     if(!v->pquantizer && block[k << 3])
3008                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3009                 }
3010             } else { //top
3011                 for(k = 1; k < 8; k++) {
3012                     block[k] = ac_val2[k + 8] * scale;
3013                     if(!v->pquantizer && block[k])
3014                         block[k] += (block[k] < 0) ? -mquant : mquant;
3015                 }
3016             }
3017             i = 63;
3018         }
3019     }
3020     s->block_last_index[n] = i;
3021
3022     return 0;
3023 }
3024
3025 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
3026  * @param v VC1Context
3027  * @param block block to decode
3028  * @param coded are AC coeffs present or not
3029  * @param mquant block quantizer
3030  * @param codingset set of VLC to decode data
3031  */
3032 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
3033 {
3034     GetBitContext *gb = &v->s.gb;
3035     MpegEncContext *s = &v->s;
3036     int dc_pred_dir = 0; /* Direction of the DC prediction used */
3037     int run_diff, i;
3038     int16_t *dc_val;
3039     int16_t *ac_val, *ac_val2;
3040     int dcdiff;
3041     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3042     int a_avail = v->a_avail, c_avail = v->c_avail;
3043     int use_pred = s->ac_pred;
3044     int scale;
3045     int q1, q2 = 0;
3046
3047     /* XXX: Guard against dumb values of mquant */
3048     mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
3049
3050     /* Set DC scale - y and c use the same */
3051     s->y_dc_scale = s->y_dc_scale_table[mquant];
3052     s->c_dc_scale = s->c_dc_scale_table[mquant];
3053
3054     /* Get DC differential */
3055     if (n < 4) {
3056         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3057     } else {
3058         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3059     }
3060     if (dcdiff < 0){
3061         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3062         return -1;
3063     }
3064     if (dcdiff)
3065     {
3066         if (dcdiff == 119 /* ESC index value */)
3067         {
3068             /* TODO: Optimize */
3069             if (mquant == 1) dcdiff = get_bits(gb, 10);
3070             else if (mquant == 2) dcdiff = get_bits(gb, 9);
3071             else dcdiff = get_bits(gb, 8);
3072         }
3073         else
3074         {
3075             if (mquant == 1)
3076                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
3077             else if (mquant == 2)
3078                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
3079         }
3080         if (get_bits(gb, 1))
3081             dcdiff = -dcdiff;
3082     }
3083
3084     /* Prediction */
3085     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3086     *dc_val = dcdiff;
3087
3088     /* Store the quantized DC coeff, used for prediction */
3089
3090     if (n < 4) {
3091         block[0] = dcdiff * s->y_dc_scale;
3092     } else {
3093         block[0] = dcdiff * s->c_dc_scale;
3094     }
3095     /* Skip ? */
3096     run_diff = 0;
3097     i = 0;
3098
3099     //AC Decoding
3100     i = 1;
3101
3102     /* check if AC is needed at all and adjust direction if needed */
3103     if(!a_avail) dc_pred_dir = 1;
3104     if(!c_avail) dc_pred_dir = 0;
3105     if(!a_avail && !c_avail) use_pred = 0;
3106     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3107     ac_val2 = ac_val;
3108
3109     scale = mquant * 2 + v->halfpq;
3110
3111     if(dc_pred_dir) //left
3112         ac_val -= 16;
3113     else //top
3114         ac_val -= 16 * s->block_wrap[n];
3115
3116     q1 = s->current_picture.qscale_table[mb_pos];
3117     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
3118     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3119     if(n && n<4) q2 = q1;
3120
3121     if(coded) {
3122         int last = 0, skip, value;
3123         const int8_t *zz_table;
3124         int k;
3125
3126         zz_table = vc1_simple_progressive_8x8_zz;
3127
3128         while (!last) {
3129             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3130             i += skip;
3131             if(i > 63)
3132                 break;
3133             block[zz_table[i++]] = value;
3134         }
3135
3136         /* apply AC prediction if needed */
3137         if(use_pred) {
3138             /* scale predictors if needed*/
3139             if(q2 && q1!=q2) {
3140                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3141                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3142
3143                 if(dc_pred_dir) { //left
3144                     for(k = 1; k < 8; k++)
3145                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3146                 } else { //top
3147                     for(k = 1; k < 8; k++)
3148                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3149                 }
3150             } else {
3151                 if(dc_pred_dir) { //left
3152                     for(k = 1; k < 8; k++)
3153                         block[k << 3] += ac_val[k];
3154                 } else { //top
3155                     for(k = 1; k < 8; k++)
3156                         block[k] += ac_val[k + 8];
3157                 }
3158             }
3159         }
3160         /* save AC coeffs for further prediction */
3161         for(k = 1; k < 8; k++) {
3162             ac_val2[k] = block[k << 3];
3163             ac_val2[k + 8] = block[k];
3164         }
3165
3166         /* scale AC coeffs */
3167         for(k = 1; k < 64; k++)
3168             if(block[k]) {
3169                 block[k] *= scale;
3170                 if(!v->pquantizer)
3171                     block[k] += (block[k] < 0) ? -mquant : mquant;
3172             }
3173
3174         if(use_pred) i = 63;
3175     } else { // no AC coeffs
3176         int k;
3177
3178         memset(ac_val2, 0, 16 * 2);
3179         if(dc_pred_dir) {//left
3180             if(use_pred) {
3181                 memcpy(ac_val2, ac_val, 8 * 2);
3182                 if(q2 && q1!=q2) {
3183                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3184                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3185                     for(k = 1; k < 8; k++)
3186                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3187                 }
3188             }
3189         } else {//top
3190             if(use_pred) {
3191                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3192                 if(q2 && q1!=q2) {
3193                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3194                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3195                     for(k = 1; k < 8; k++)
3196                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3197                 }
3198             }
3199         }
3200
3201         /* apply AC prediction if needed */
3202         if(use_pred) {
3203             if(dc_pred_dir) { //left
3204                 for(k = 1; k < 8; k++) {
3205                     block[k << 3] = ac_val2[k] * scale;
3206                     if(!v->pquantizer && block[k << 3])
3207                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3208                 }
3209             } else { //top
3210                 for(k = 1; k < 8; k++) {
3211                     block[k] = ac_val2[k + 8] * scale;
3212                     if(!v->pquantizer && block[k])
3213                         block[k] += (block[k] < 0) ? -mquant : mquant;
3214                 }
3215             }
3216             i = 63;
3217         }
3218     }
3219     s->block_last_index[n] = i;
3220
3221     return 0;
3222 }
3223
3224 /** Decode P block
3225  */
3226 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
3227 {
3228     MpegEncContext *s = &v->s;
3229     GetBitContext *gb = &s->gb;
3230     int i, j;
3231     int subblkpat = 0;
3232     int scale, off, idx, last, skip, value;
3233     int ttblk = ttmb & 7;
3234
3235     if(ttmb == -1) {
3236         ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
3237     }
3238     if(ttblk == TT_4X4) {
3239         subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3240     }
3241     if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
3242         subblkpat = decode012(gb);
3243         if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
3244         if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
3245         if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
3246     }
3247     scale = 2 * mquant + v->halfpq;
3248
3249     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3250     if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3251         subblkpat = 2 - (ttblk == TT_8X4_TOP);
3252         ttblk = TT_8X4;
3253     }
3254     if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3255         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3256         ttblk = TT_4X8;
3257     }
3258     switch(ttblk) {
3259     case TT_8X8:
3260         i = 0;
3261         last = 0;
3262         while (!last) {
3263             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3264             i += skip;
3265             if(i > 63)
3266                 break;
3267             idx = vc1_simple_progressive_8x8_zz[i++];
3268             block[idx] = value * scale;
3269             if(!v->pquantizer)
3270                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3271         }
3272         s->dsp.vc1_inv_trans_8x8(block);
3273         break;
3274     case TT_4X4:
3275         for(j = 0; j < 4; j++) {
3276             last = subblkpat & (1 << (3 - j));
3277             i = 0;
3278             off = (j & 1) * 4 + (j & 2) * 16;
3279             while (!last) {
3280                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3281                 i += skip;
3282                 if(i > 15)
3283                     break;
3284                 idx = vc1_simple_progressive_4x4_zz[i++];
3285                 block[idx + off] = value * scale;
3286                 if(!v->pquantizer)
3287                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3288             }
3289             if(!(subblkpat & (1 << (3 - j))))
3290                 s->dsp.vc1_inv_trans_4x4(block, j);
3291         }
3292         break;
3293     case TT_8X4:
3294         for(j = 0; j < 2; j++) {
3295             last = subblkpat & (1 << (1 - j));
3296             i = 0;
3297             off = j * 32;
3298             while (!last) {
3299                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3300                 i += skip;
3301                 if(i > 31)
3302                     break;
3303                 if(v->profile < PROFILE_ADVANCED)
3304                     idx = vc1_simple_progressive_8x4_zz[i++];
3305                 else
3306                     idx = vc1_adv_progressive_8x4_zz[i++];
3307                 block[idx + off] = value * scale;
3308                 if(!v->pquantizer)
3309                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3310             }
3311             if(!(subblkpat & (1 << (1 - j))))
3312                 s->dsp.vc1_inv_trans_8x4(block, j);
3313         }
3314         break;
3315     case TT_4X8:
3316         for(j = 0; j < 2; j++) {
3317             last = subblkpat & (1 << (1 - j));
3318             i = 0;
3319             off = j * 4;
3320             while (!last) {
3321                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3322                 i += skip;
3323                 if(i > 31)
3324                     break;
3325                 if(v->profile < PROFILE_ADVANCED)
3326                     idx = vc1_simple_progressive_4x8_zz[i++];
3327                 else
3328                     idx = vc1_adv_progressive_4x8_zz[i++];
3329                 block[idx + off] = value * scale;
3330                 if(!v->pquantizer)
3331                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3332             }
3333             if(!(subblkpat & (1 << (1 - j))))
3334                 s->dsp.vc1_inv_trans_4x8(block, j);
3335         }
3336         break;
3337     }
3338     return 0;
3339 }
3340
3341
3342 /** Decode one P-frame MB (in Simple/Main profile)
3343  */
3344 static int vc1_decode_p_mb(VC1Context *v)
3345 {
3346     MpegEncContext *s = &v->s;
3347     GetBitContext *gb = &s->gb;
3348     int i, j;
3349     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3350     int cbp; /* cbp decoding stuff */
3351     int mqdiff, mquant; /* MB quantization */
3352     int ttmb = v->ttfrm; /* MB Transform type */
3353     int status;
3354
3355     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3356       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3357     int mb_has_coeffs = 1; /* last_flag */
3358     int dmv_x, dmv_y; /* Differential MV components */
3359     int index, index1; /* LUT indices */
3360     int val, sign; /* temp values */
3361     int first_block = 1;
3362     int dst_idx, off;
3363     int skipped, fourmv;
3364
3365     mquant = v->pq; /* Loosy initialization */
3366
3367     if (v->mv_type_is_raw)
3368         fourmv = get_bits1(gb);
3369     else
3370         fourmv = v->mv_type_mb_plane[mb_pos];
3371     if (v->skip_is_raw)
3372         skipped = get_bits1(gb);
3373     else
3374         skipped = v->s.mbskip_table[mb_pos];
3375
3376     s->dsp.clear_blocks(s->block[0]);
3377
3378     if (!fourmv) /* 1MV mode */
3379     {
3380         if (!skipped)
3381         {
3382             GET_MVDATA(dmv_x, dmv_y);
3383
3384             if (s->mb_intra) {
3385                 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3386                 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3387             }
3388             s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3389             vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3390
3391             /* FIXME Set DC val for inter block ? */
3392             if (s->mb_intra && !mb_has_coeffs)
3393             {
3394                 GET_MQUANT();
3395                 s->ac_pred = get_bits(gb, 1);
3396                 cbp = 0;
3397             }
3398             else if (mb_has_coeffs)
3399             {
3400                 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
3401                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3402                 GET_MQUANT();
3403             }
3404             else
3405             {
3406                 mquant = v->pq;
3407                 cbp = 0;
3408             }
3409             s->current_picture.qscale_table[mb_pos] = mquant;
3410
3411             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3412                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
3413                                 VC1_TTMB_VLC_BITS, 2);
3414             if(!s->mb_intra) vc1_mc_1mv(v, 0);
3415             dst_idx = 0;
3416             for (i=0; i<6; i++)
3417             {
3418                 s->dc_val[0][s->block_index[i]] = 0;
3419                 dst_idx += i >> 2;
3420                 val = ((cbp >> (5 - i)) & 1);
3421                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3422                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3423                 if(s->mb_intra) {
3424                     /* check if prediction blocks A and C are available */
3425                     v->a_avail = v->c_avail = 0;
3426                     if(i == 2 || i == 3 || !s->first_slice_line)
3427                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3428                     if(i == 1 || i == 3 || s->mb_x)
3429                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3430
3431                     vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3432                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3433                     s->dsp.vc1_inv_trans_8x8(s->block[i]);
3434                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3435                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
3436                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3437                     if(v->pq >= 9 && v->overlap) {
3438                         if(v->c_avail)
3439                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3440                         if(v->a_avail)
3441                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3442                     }
3443                 } else if(val) {
3444                     vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3445                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
3446                     first_block = 0;
3447                     if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3448                         s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3449                 }
3450             }
3451         }
3452         else //Skipped
3453         {
3454             s->mb_intra = 0;
3455             for(i = 0; i < 6; i++) {
3456                 v->mb_type[0][s->block_index[i]] = 0;
3457                 s->dc_val[0][s->block_index[i]] = 0;
3458             }
3459             s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3460             s->current_picture.qscale_table[mb_pos] = 0;
3461             vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3462             vc1_mc_1mv(v, 0);
3463             return 0;
3464         }
3465     } //1MV mode
3466     else //4MV mode
3467     {
3468         if (!skipped /* unskipped MB */)
3469         {
3470             int intra_count = 0, coded_inter = 0;
3471             int is_intra[6], is_coded[6];
3472             /* Get CBPCY */
3473             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3474             for (i=0; i<6; i++)
3475             {
3476                 val = ((cbp >> (5 - i)) & 1);
3477                 s->dc_val[0][s->block_index[i]] = 0;
3478                 s->mb_intra = 0;
3479                 if(i < 4) {
3480                     dmv_x = dmv_y = 0;
3481                     s->mb_intra = 0;
3482                     mb_has_coeffs = 0;
3483                     if(val) {
3484                         GET_MVDATA(dmv_x, dmv_y);
3485                     }
3486                     vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3487                     if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
3488                     intra_count += s->mb_intra;
3489                     is_intra[i] = s->mb_intra;
3490                     is_coded[i] = mb_has_coeffs;
3491                 }
3492                 if(i&4){
3493                     is_intra[i] = (intra_count >= 3);
3494                     is_coded[i] = val;
3495                 }
3496                 if(i == 4) vc1_mc_4mv_chroma(v);
3497                 v->mb_type[0][s->block_index[i]] = is_intra[i];
3498                 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
3499             }
3500             // if there are no coded blocks then don't do anything more
3501             if(!intra_count && !coded_inter) return 0;
3502             dst_idx = 0;
3503             GET_MQUANT();
3504             s->current_picture.qscale_table[mb_pos] = mquant;
3505             /* test if block is intra and has pred */
3506             {
3507                 int intrapred = 0;
3508                 for(i=0; i<6; i++)
3509                     if(is_intra[i]) {
3510                         if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3511                             || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
3512                             intrapred = 1;
3513                             break;
3514                         }
3515                     }
3516                 if(intrapred)s->ac_pred = get_bits(gb, 1);
3517                 else s->ac_pred = 0;
3518             }
3519             if (!v->ttmbf && coded_inter)
3520                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3521             for (i=0; i<6; i++)
3522             {
3523                 dst_idx += i >> 2;
3524                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3525                 s->mb_intra = is_intra[i];
3526                 if (is_intra[i]) {
3527                     /* check if prediction blocks A and C are available */
3528                     v->a_avail = v->c_avail = 0;
3529                     if(i == 2 || i == 3 || !s->first_slice_line)
3530                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3531                     if(i == 1 || i == 3 || s->mb_x)
3532                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3533
3534                     vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
3535                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3536                     s->dsp.vc1_inv_trans_8x8(s->block[i]);
3537                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3538                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
3539                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3540                     if(v->pq >= 9 && v->overlap) {
3541                         if(v->c_avail)
3542                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3543                         if(v->a_avail)
3544                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3545                     }
3546                 } else if(is_coded[i]) {
3547                     status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3548                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
3549                     first_block = 0;
3550                     if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3551                         s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3552                 }
3553             }
3554             return status;
3555         }
3556         else //Skipped MB
3557         {
3558             s->mb_intra = 0;
3559             s->current_picture.qscale_table[mb_pos] = 0;
3560             for (i=0; i<6; i++) {
3561                 v->mb_type[0][s->block_index[i]] = 0;
3562                 s->dc_val[0][s->block_index[i]] = 0;
3563             }
3564             for (i=0; i<4; i++)
3565             {
3566                 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
3567                 vc1_mc_4mv_luma(v, i);
3568             }
3569             vc1_mc_4mv_chroma(v);
3570             s->current_picture.qscale_table[mb_pos] = 0;
3571             return 0;
3572         }
3573     }
3574
3575     /* Should never happen */
3576     return -1;
3577 }
3578
3579 /** Decode one B-frame MB (in Main profile)
3580  */
3581 static void vc1_decode_b_mb(VC1Context *v)
3582 {
3583     MpegEncContext *s = &v->s;
3584     GetBitContext *gb = &s->gb;
3585     int i, j;
3586     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3587     int cbp = 0; /* cbp decoding stuff */
3588     int mqdiff, mquant; /* MB quantization */
3589     int ttmb = v->ttfrm; /* MB Transform type */
3590
3591     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3592       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3593     int mb_has_coeffs = 0; /* last_flag */
3594     int index, index1; /* LUT indices */
3595     int val, sign; /* temp values */
3596     int first_block = 1;
3597     int dst_idx, off;
3598     int skipped, direct;
3599     int dmv_x[2], dmv_y[2];
3600     int bmvtype = BMV_TYPE_BACKWARD;
3601
3602     mquant = v->pq; /* Loosy initialization */
3603     s->mb_intra = 0;
3604
3605     if (v->dmb_is_raw)
3606         direct = get_bits1(gb);
3607     else
3608         direct = v->direct_mb_plane[mb_pos];
3609     if (v->skip_is_raw)
3610         skipped = get_bits1(gb);
3611     else
3612         skipped = v->s.mbskip_table[mb_pos];
3613
3614     s->dsp.clear_blocks(s->block[0]);
3615     dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
3616     for(i = 0; i < 6; i++) {
3617         v->mb_type[0][s->block_index[i]] = 0;
3618         s->dc_val[0][s->block_index[i]] = 0;
3619     }
3620     s->current_picture.qscale_table[mb_pos] = 0;
3621
3622     if (!direct) {
3623         if (!skipped) {
3624             GET_MVDATA(dmv_x[0], dmv_y[0]);
3625             dmv_x[1] = dmv_x[0];
3626             dmv_y[1] = dmv_y[0];
3627         }
3628         if(skipped || !s->mb_intra) {
3629             bmvtype = decode012(gb);
3630             switch(bmvtype) {
3631             case 0:
3632                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
3633                 break;
3634             case 1:
3635                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
3636                 break;
3637             case 2:
3638                 bmvtype = BMV_TYPE_INTERPOLATED;
3639                 dmv_x[0] = dmv_y[0] = 0;
3640             }
3641         }
3642     }
3643     for(i = 0; i < 6; i++)
3644         v->mb_type[0][s->block_index[i]] = s->mb_intra;
3645
3646     if (skipped) {
3647         if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
3648         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3649         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3650         return;
3651     }
3652     if (direct) {
3653         cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3654         GET_MQUANT();
3655         s->mb_intra = 0;
3656         mb_has_coeffs = 0;
3657         s->current_picture.qscale_table[mb_pos] = mquant;
3658         if(!v->ttmbf)
3659             ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3660         dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
3661         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3662         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3663     } else {
3664         if(!mb_has_coeffs && !s->mb_intra) {
3665             /* no coded blocks - effectively skipped */
3666             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3667             vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3668             return;
3669         }
3670         if(s->mb_intra && !mb_has_coeffs) {
3671             GET_MQUANT();
3672             s->current_picture.qscale_table[mb_pos] = mquant;
3673             s->ac_pred = get_bits1(gb);
3674             cbp = 0;
3675             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3676         } else {
3677             if(bmvtype == BMV_TYPE_INTERPOLATED) {
3678                 GET_MVDATA(dmv_x[0], dmv_y[0]);
3679                 if(!mb_has_coeffs) {
3680                     /* interpolated skipped block */
3681                     vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3682                     vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3683                     return;
3684                 }
3685             }
3686             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3687             if(!s->mb_intra) {
3688                 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3689             }
3690             if(s->mb_intra)
3691                 s->ac_pred = get_bits1(gb);
3692             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3693             GET_MQUANT();
3694             s->current_picture.qscale_table[mb_pos] = mquant;
3695             if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3696                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3697         }
3698     }
3699     dst_idx = 0;
3700     for (i=0; i<6; i++)
3701     {
3702         s->dc_val[0][s->block_index[i]] = 0;
3703         dst_idx += i >> 2;
3704         val = ((cbp >> (5 - i)) & 1);
3705         off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3706         v->mb_type[0][s->block_index[i]] = s->mb_intra;
3707         if(s->mb_intra) {
3708             /* check if prediction blocks A and C are available */
3709             v->a_avail = v->c_avail = 0;
3710             if(i == 2 || i == 3 || !s->first_slice_line)
3711                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3712             if(i == 1 || i == 3 || s->mb_x)
3713                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3714
3715             vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3716             if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3717             s->dsp.vc1_inv_trans_8x8(s->block[i]);
3718             if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3719             for(j = 0; j < 64; j++) s->block[i][j] += 128;
3720             s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3721         } else if(val) {
3722             vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3723             if(!v->ttmbf && ttmb < 8) ttmb = -1;
3724             first_block = 0;
3725             if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3726                 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3727         }
3728     }
3729 }
3730
3731 /** Decode blocks of I-frame
3732  */
3733 static void vc1_decode_i_blocks(VC1Context *v)
3734 {
3735     int k, j;
3736     MpegEncContext *s = &v->s;
3737     int cbp, val;
3738     uint8_t *coded_val;
3739     int mb_pos;
3740
3741     /* select codingmode used for VLC tables selection */
3742     switch(v->y_ac_table_index){
3743     case 0:
3744         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3745         break;
3746     case 1:
3747         v->codingset = CS_HIGH_MOT_INTRA;
3748         break;
3749     case 2:
3750         v->codingset = CS_MID_RATE_INTRA;
3751         break;
3752     }
3753
3754     switch(v->c_ac_table_index){
3755     case 0:
3756         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3757         break;
3758     case 1:
3759         v->codingset2 = CS_HIGH_MOT_INTER;
3760         break;
3761     case 2:
3762         v->codingset2 = CS_MID_RATE_INTER;
3763         break;
3764     }
3765
3766     /* Set DC scale - y and c use the same */
3767     s->y_dc_scale = s->y_dc_scale_table[v->pq];
3768     s->c_dc_scale = s->c_dc_scale_table[v->pq];
3769
3770     //do frame decode
3771     s->mb_x = s->mb_y = 0;
3772     s->mb_intra = 1;
3773     s->first_slice_line = 1;
3774     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3775     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3776         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3777             ff_init_block_index(s);
3778             ff_update_block_index(s);
3779             s->dsp.clear_blocks(s->block[0]);
3780             mb_pos = s->mb_x + s->mb_y * s->mb_width;
3781             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3782             s->current_picture.qscale_table[mb_pos] = v->pq;
3783             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3784             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3785
3786             // do actual MB decoding and displaying
3787             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3788             v->s.ac_pred = get_bits(&v->s.gb, 1);
3789
3790             for(k = 0; k < 6; k++) {
3791                 val = ((cbp >> (5 - k)) & 1);
3792
3793                 if (k < 4) {
3794                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3795                     val = val ^ pred;
3796                     *coded_val = val;
3797                 }
3798                 cbp |= val << (5 - k);
3799
3800                 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
3801
3802                 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3803                 if(v->pq >= 9 && v->overlap) {
3804                     for(j = 0; j < 64; j++) s->block[k][j] += 128;
3805                 }
3806             }
3807
3808             vc1_put_block(v, s->block);
3809             if(v->pq >= 9 && v->overlap) {
3810                 if(s->mb_x) {
3811                     s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3812                     s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3813                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3814                         s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3815                         s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3816                     }
3817                 }
3818                 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3819                 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3820                 if(!s->first_slice_line) {
3821                     s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3822                     s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3823                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3824                         s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3825                         s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3826                     }
3827                 }
3828                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3829                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3830             }
3831
3832             if(get_bits_count(&s->gb) > v->bits) {
3833                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3834                 return;
3835             }
3836         }
3837         ff_draw_horiz_band(s, s->mb_y * 16, 16);
3838         s->first_slice_line = 0;
3839     }
3840 }
3841
3842 /** Decode blocks of I-frame for advanced profile
3843  */
3844 static void vc1_decode_i_blocks_adv(VC1Context *v)
3845 {
3846     int k, j;
3847     MpegEncContext *s = &v->s;
3848     int cbp, val;
3849     uint8_t *coded_val;
3850     int mb_pos;
3851     int mquant = v->pq;
3852     int mqdiff;
3853     int overlap;
3854     GetBitContext *gb = &s->gb;
3855
3856     /* select codingmode used for VLC tables selection */
3857     switch(v->y_ac_table_index){
3858     case 0:
3859         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3860         break;
3861     case 1:
3862         v->codingset = CS_HIGH_MOT_INTRA;
3863         break;
3864     case 2:
3865         v->codingset = CS_MID_RATE_INTRA;
3866         break;
3867     }
3868
3869     switch(v->c_ac_table_index){
3870     case 0:
3871         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3872         break;
3873     case 1:
3874         v->codingset2 = CS_HIGH_MOT_INTER;
3875         break;
3876     case 2:
3877         v->codingset2 = CS_MID_RATE_INTER;
3878         break;
3879     }
3880
3881     //do frame decode
3882     s->mb_x = s->mb_y = 0;
3883     s->mb_intra = 1;
3884     s->first_slice_line = 1;
3885     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3886     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3887         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3888             ff_init_block_index(s);
3889             ff_update_block_index(s);
3890             s->dsp.clear_blocks(s->block[0]);
3891             mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3892             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3893             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3894             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3895
3896             // do actual MB decoding and displaying
3897             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3898             if(v->acpred_is_raw)
3899                 v->s.ac_pred = get_bits(&v->s.gb, 1);
3900             else
3901                 v->s.ac_pred = v->acpred_plane[mb_pos];
3902
3903             if(v->condover == CONDOVER_SELECT) {
3904                 if(v->overflg_is_raw)
3905                     overlap = get_bits(&v->s.gb, 1);
3906                 else
3907                     overlap = v->over_flags_plane[mb_pos];
3908             } else
3909                 overlap = (v->condover == CONDOVER_ALL);
3910
3911             GET_MQUANT();
3912
3913             s->current_picture.qscale_table[mb_pos] = mquant;
3914             /* Set DC scale - y and c use the same */
3915             s->y_dc_scale = s->y_dc_scale_table[mquant];
3916             s->c_dc_scale = s->c_dc_scale_table[mquant];
3917
3918             for(k = 0; k < 6; k++) {
3919                 val = ((cbp >> (5 - k)) & 1);
3920
3921                 if (k < 4) {
3922                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3923                     val = val ^ pred;
3924                     *coded_val = val;
3925                 }
3926                 cbp |= val << (5 - k);
3927
3928                 v->a_avail = !s->first_slice_line || (k==2 || k==3);
3929                 v->c_avail = !!s->mb_x || (k==1 || k==3);
3930
3931                 vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
3932
3933                 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3934                 for(j = 0; j < 64; j++) s->block[k][j] += 128;
3935             }
3936
3937             vc1_put_block(v, s->block);
3938             if(overlap) {
3939                 if(s->mb_x) {
3940                     s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3941                     s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3942                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3943                         s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3944                         s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3945                     }
3946                 }
3947                 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3948                 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3949                 if(!s->first_slice_line) {
3950                     s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3951                     s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3952                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3953                         s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3954                         s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3955                     }
3956                 }
3957                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3958                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3959             }
3960
3961             if(get_bits_count(&s->gb) > v->bits) {
3962                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3963                 return;
3964             }
3965         }
3966         ff_draw_horiz_band(s, s->mb_y * 16, 16);
3967         s->first_slice_line = 0;
3968     }
3969 }
3970
3971 static void vc1_decode_p_blocks(VC1Context *v)
3972 {
3973     MpegEncContext *s = &v->s;
3974
3975     /* select codingmode used for VLC tables selection */
3976     switch(v->c_ac_table_index){
3977     case 0:
3978         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3979         break;
3980     case 1:
3981         v->codingset = CS_HIGH_MOT_INTRA;
3982         break;
3983     case 2:
3984         v->codingset = CS_MID_RATE_INTRA;
3985         break;
3986     }
3987
3988     switch(v->c_ac_table_index){
3989     case 0:
3990         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3991         break;
3992     case 1:
3993         v->codingset2 = CS_HIGH_MOT_INTER;
3994         break;
3995     case 2:
3996         v->codingset2 = CS_MID_RATE_INTER;
3997         break;
3998     }
3999
4000     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4001     s->first_slice_line = 1;
4002     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4003         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
4004             ff_init_block_index(s);
4005             ff_update_block_index(s);
4006             s->dsp.clear_blocks(s->block[0]);
4007
4008             vc1_decode_p_mb(v);
4009             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4010                 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);
4011                 return;
4012             }
4013         }
4014         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4015         s->first_slice_line = 0;
4016     }
4017 }
4018
4019 static void vc1_decode_b_blocks(VC1Context *v)
4020 {
4021     MpegEncContext *s = &v->s;
4022
4023     /* select codingmode used for VLC tables selection */
4024     switch(v->c_ac_table_index){
4025     case 0:
4026         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4027         break;
4028     case 1:
4029         v->codingset = CS_HIGH_MOT_INTRA;
4030         break;
4031     case 2:
4032         v->codingset = CS_MID_RATE_INTRA;
4033         break;
4034     }
4035
4036     switch(v->c_ac_table_index){
4037     case 0:
4038         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4039         break;
4040     case 1:
4041         v->codingset2 = CS_HIGH_MOT_INTER;
4042         break;
4043     case 2:
4044         v->codingset2 = CS_MID_RATE_INTER;
4045         break;
4046     }
4047
4048     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4049     s->first_slice_line = 1;
4050     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4051         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
4052             ff_init_block_index(s);
4053             ff_update_block_index(s);
4054             s->dsp.clear_blocks(s->block[0]);
4055
4056             vc1_decode_b_mb(v);
4057             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4058                 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);
4059                 return;
4060             }
4061         }
4062         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4063         s->first_slice_line = 0;
4064     }
4065 }
4066
4067 static void vc1_decode_skip_blocks(VC1Context *v)
4068 {
4069     MpegEncContext *s = &v->s;
4070
4071     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4072     s->first_slice_line = 1;
4073     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4074         s->mb_x = 0;
4075         ff_init_block_index(s);
4076         ff_update_block_index(s);
4077         memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4078         memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4079         memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4080         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4081         s->first_slice_line = 0;
4082     }
4083     s->pict_type = P_TYPE;
4084 }
4085
4086 static void vc1_decode_blocks(VC1Context *v)
4087 {
4088
4089     v->s.esc3_level_length = 0;
4090
4091     switch(v->s.pict_type) {
4092     case I_TYPE:
4093         if(v->profile == PROFILE_ADVANCED)
4094             vc1_decode_i_blocks_adv(v);
4095         else
4096             vc1_decode_i_blocks(v);
4097         break;
4098     case P_TYPE:
4099         if(v->p_frame_skipped)
4100             vc1_decode_skip_blocks(v);
4101         else
4102             vc1_decode_p_blocks(v);
4103         break;
4104     case B_TYPE:
4105         if(v->bi_type){
4106             if(v->profile == PROFILE_ADVANCED)
4107                 vc1_decode_i_blocks_adv(v);
4108             else
4109                 vc1_decode_i_blocks(v);
4110         }else
4111             vc1_decode_b_blocks(v);
4112         break;
4113     }
4114 }
4115
4116 #define IS_MARKER(x) (((x) & ~0xFF) == VC1_CODE_RES0)
4117
4118 /** Find VC-1 marker in buffer
4119  * @return position where next marker starts or end of buffer if no marker found
4120  */
4121 static av_always_inline uint8_t* find_next_marker(uint8_t *src, uint8_t *end)
4122 {
4123     uint32_t mrk = 0xFFFFFFFF;
4124
4125     if(end-src < 4) return end;
4126     while(src < end){
4127         mrk = (mrk << 8) | *src++;
4128         if(IS_MARKER(mrk))
4129             return src-4;
4130     }