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