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