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