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