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