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