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