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