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