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