0c17083039b20fce17e3315680176b52857a49b2
[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 file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  *
22  */
23
24 /**
25  * @file vc1.c
26  * VC-1 and WMV3 decoder
27  *
28  */
29 #include "common.h"
30 #include "dsputil.h"
31 #include "avcodec.h"
32 #include "mpegvideo.h"
33 #include "vc1data.h"
34 #include "vc1acdata.h"
35
36 #undef NDEBUG
37 #include <assert.h>
38
39 extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];
40 extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];
41 extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];
42 #define MB_INTRA_VLC_BITS 9
43 extern VLC ff_msmp4_mb_i_vlc;
44 extern const uint16_t ff_msmp4_mb_i_table[64][2];
45 #define DC_VLC_BITS 9
46 #define AC_VLC_BITS 9
47 static const uint16_t table_mb_intra[64][2];
48
49
50 /** Available Profiles */
51 //@{
52 enum Profile {
53     PROFILE_SIMPLE,
54     PROFILE_MAIN,
55     PROFILE_COMPLEX, ///< TODO: WMV9 specific
56     PROFILE_ADVANCED
57 };
58 //@}
59
60 /** Sequence quantizer mode */
61 //@{
62 enum QuantMode {
63     QUANT_FRAME_IMPLICIT,    ///< Implicitly specified at frame level
64     QUANT_FRAME_EXPLICIT,    ///< Explicitly specified at frame level
65     QUANT_NON_UNIFORM,       ///< Non-uniform quant used for all frames
66     QUANT_UNIFORM            ///< Uniform quant used for all frames
67 };
68 //@}
69
70 /** Where quant can be changed */
71 //@{
72 enum DQProfile {
73     DQPROFILE_FOUR_EDGES,
74     DQPROFILE_DOUBLE_EDGES,
75     DQPROFILE_SINGLE_EDGE,
76     DQPROFILE_ALL_MBS
77 };
78 //@}
79
80 /** @name Where quant can be changed
81  */
82 //@{
83 enum DQSingleEdge {
84     DQSINGLE_BEDGE_LEFT,
85     DQSINGLE_BEDGE_TOP,
86     DQSINGLE_BEDGE_RIGHT,
87     DQSINGLE_BEDGE_BOTTOM
88 };
89 //@}
90
91 /** Which pair of edges is quantized with ALTPQUANT */
92 //@{
93 enum DQDoubleEdge {
94     DQDOUBLE_BEDGE_TOPLEFT,
95     DQDOUBLE_BEDGE_TOPRIGHT,
96     DQDOUBLE_BEDGE_BOTTOMRIGHT,
97     DQDOUBLE_BEDGE_BOTTOMLEFT
98 };
99 //@}
100
101 /** MV modes for P frames */
102 //@{
103 enum MVModes {
104     MV_PMODE_1MV_HPEL_BILIN,
105     MV_PMODE_1MV,
106     MV_PMODE_1MV_HPEL,
107     MV_PMODE_MIXED_MV,
108     MV_PMODE_INTENSITY_COMP
109 };
110 //@}
111
112 /** @name MV types for B frames */
113 //@{
114 enum BMVTypes {
115     BMV_TYPE_BACKWARD,
116     BMV_TYPE_FORWARD,
117     BMV_TYPE_INTERPOLATED
118 };
119 //@}
120
121 /** @name Block types for P/B frames */
122 //@{
123 enum TransformTypes {
124     TT_8X8,
125     TT_8X4_BOTTOM,
126     TT_8X4_TOP,
127     TT_8X4, //Both halves
128     TT_4X8_RIGHT,
129     TT_4X8_LEFT,
130     TT_4X8, //Both halves
131     TT_4X4
132 };
133 //@}
134
135 /** Table for conversion between TTBLK and TTMB */
136 static const int ttblk_to_tt[3][8] = {
137   { TT_8X4, TT_4X8, TT_8X8, TT_4X4, TT_8X4_TOP, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT },
138   { TT_8X8, TT_4X8_RIGHT, TT_4X8_LEFT, TT_4X4, TT_8X4, TT_4X8, TT_8X4_BOTTOM, TT_8X4_TOP },
139   { TT_8X8, TT_4X8, TT_4X4, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT, TT_8X4, TT_8X4_TOP }
140 };
141
142 static const int ttfrm_to_tt[4] = { TT_8X8, TT_8X4, TT_4X8, TT_4X4 };
143
144 /** MV P mode - the 5th element is only used for mode 1 */
145 static const uint8_t mv_pmode_table[2][5] = {
146   { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV },
147   { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN }
148 };
149 static const uint8_t mv_pmode_table2[2][4] = {
150   { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV },
151   { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN }
152 };
153
154 /** One more frame type */
155 #define BI_TYPE 7
156
157 static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
158   fps_dr[2] = { 1000, 1001 };
159 static const uint8_t pquant_table[3][32] = {
160   {  /* Implicit quantizer */
161      0,  1,  2,  3,  4,  5,  6,  7,  8,  6,  7,  8,  9, 10, 11, 12,
162     13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
163   },
164   {  /* Explicit quantizer, pquantizer uniform */
165      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
166     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
167   },
168   {  /* Explicit quantizer, pquantizer non-uniform */
169      0,  1,  1,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,
170     14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
171   }
172 };
173
174 /** @name VC-1 VLC tables and defines
175  *  @todo TODO move this into the context
176  */
177 //@{
178 #define VC1_BFRACTION_VLC_BITS 7
179 static VLC vc1_bfraction_vlc;
180 #define VC1_IMODE_VLC_BITS 4
181 static VLC vc1_imode_vlc;
182 #define VC1_NORM2_VLC_BITS 3
183 static VLC vc1_norm2_vlc;
184 #define VC1_NORM6_VLC_BITS 9
185 static VLC vc1_norm6_vlc;
186 /* Could be optimized, one table only needs 8 bits */
187 #define VC1_TTMB_VLC_BITS 9 //12
188 static VLC vc1_ttmb_vlc[3];
189 #define VC1_MV_DIFF_VLC_BITS 9 //15
190 static VLC vc1_mv_diff_vlc[4];
191 #define VC1_CBPCY_P_VLC_BITS 9 //14
192 static VLC vc1_cbpcy_p_vlc[4];
193 #define VC1_4MV_BLOCK_PATTERN_VLC_BITS 6
194 static VLC vc1_4mv_block_pattern_vlc[4];
195 #define VC1_TTBLK_VLC_BITS 5
196 static VLC vc1_ttblk_vlc[3];
197 #define VC1_SUBBLKPAT_VLC_BITS 6
198 static VLC vc1_subblkpat_vlc[3];
199
200 static VLC vc1_ac_coeff_table[8];
201 //@}
202
203 enum CodingSet {
204     CS_HIGH_MOT_INTRA = 0,
205     CS_HIGH_MOT_INTER,
206     CS_LOW_MOT_INTRA,
207     CS_LOW_MOT_INTER,
208     CS_MID_RATE_INTRA,
209     CS_MID_RATE_INTER,
210     CS_HIGH_RATE_INTRA,
211     CS_HIGH_RATE_INTER
212 };
213
214 /** @name Overlap conditions for Advanced Profile */
215 //@{
216 enum COTypes {
217     CONDOVER_NONE = 0,
218     CONDOVER_ALL,
219     CONDOVER_SELECT
220 };
221 //@}
222
223
224 /** The VC1 Context
225  * @fixme Change size wherever another size is more efficient
226  * Many members are only used for Advanced Profile
227  */
228 typedef struct VC1Context{
229     MpegEncContext s;
230
231     int bits;
232
233     /** Simple/Main Profile sequence header */
234     //@{
235     int res_sm;           ///< reserved, 2b
236     int res_x8;           ///< reserved
237     int multires;         ///< frame-level RESPIC syntax element present
238     int res_fasttx;       ///< reserved, always 1
239     int res_transtab;     ///< reserved, always 0
240     int rangered;         ///< RANGEREDFRM (range reduction) syntax element present
241                           ///< at frame level
242     int res_rtm_flag;     ///< reserved, set to 1
243     int reserved;         ///< reserved
244     //@}
245
246     /** Advanced Profile */
247     //@{
248     int level;            ///< 3bits, for Advanced/Simple Profile, provided by TS layer
249     int chromaformat;     ///< 2bits, 2=4:2:0, only defined
250     int postprocflag;     ///< Per-frame processing suggestion flag present
251     int broadcast;        ///< TFF/RFF present
252     int interlace;        ///< Progressive/interlaced (RPTFTM syntax element)
253     int tfcntrflag;       ///< TFCNTR present
254     int panscanflag;      ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
255     int extended_dmv;     ///< Additional extended dmv range at P/B frame-level
256     int color_prim;       ///< 8bits, chroma coordinates of the color primaries
257     int transfer_char;    ///< 8bits, Opto-electronic transfer characteristics
258     int matrix_coef;      ///< 8bits, Color primaries->YCbCr transform matrix
259     int hrd_param_flag;   ///< Presence of Hypothetical Reference
260                           ///< Decoder parameters
261     int psf;              ///< Progressive Segmented Frame
262     //@}
263
264     /** Sequence header data for all Profiles
265      * TODO: choose between ints, uint8_ts and monobit flags
266      */
267     //@{
268     int profile;          ///< 2bits, Profile
269     int frmrtq_postproc;  ///< 3bits,
270     int bitrtq_postproc;  ///< 5bits, quantized framerate-based postprocessing strength
271     int fastuvmc;         ///< Rounding of qpel vector to hpel ? (not in Simple)
272     int extended_mv;      ///< Ext MV in P/B (not in Simple)
273     int dquant;           ///< How qscale varies with MBs, 2bits (not in Simple)
274     int vstransform;      ///< variable-size [48]x[48] transform type + info
275     int overlap;          ///< overlapped transforms in use
276     int quantizer_mode;   ///< 2bits, quantizer mode used for sequence, see QUANT_*
277     int finterpflag;      ///< INTERPFRM present
278     //@}
279
280     /** Frame decoding info for all profiles */
281     //@{
282     uint8_t mv_mode;      ///< MV coding monde
283     uint8_t mv_mode2;     ///< Secondary MV coding mode (B frames)
284     int k_x;              ///< Number of bits for MVs (depends on MV range)
285     int k_y;              ///< Number of bits for MVs (depends on MV range)
286     int range_x, range_y; ///< MV range
287     uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale
288     /** pquant parameters */
289     //@{
290     uint8_t dquantfrm;
291     uint8_t dqprofile;
292     uint8_t dqsbedge;
293     uint8_t dqbilevel;
294     //@}
295     /** AC coding set indexes
296      * @see 8.1.1.10, p(1)10
297      */
298     //@{
299     int c_ac_table_index; ///< Chroma index from ACFRM element
300     int y_ac_table_index; ///< Luma index from AC2FRM element
301     //@}
302     int ttfrm;            ///< Transform type info present at frame level
303     uint8_t ttmbf;        ///< Transform type flag
304     uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
305     int codingset;        ///< index of current table set from 11.8 to use for luma block decoding
306     int codingset2;       ///< index of current table set from 11.8 to use for chroma block decoding
307     int pqindex;          ///< raw pqindex used in coding set selection
308     int a_avail, c_avail;
309     uint8_t *mb_type_base, *mb_type[3];
310
311
312     /** Luma compensation parameters */
313     //@{
314     uint8_t lumscale;
315     uint8_t lumshift;
316     //@}
317     int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs
318     uint8_t halfpq;       ///< Uniform quant over image and qp+.5
319     uint8_t respic;       ///< Frame-level flag for resized images
320     int buffer_fullness;  ///< HRD info
321     /** Ranges:
322      * -# 0 -> [-64n 63.f] x [-32, 31.f]
323      * -# 1 -> [-128, 127.f] x [-64, 63.f]
324      * -# 2 -> [-512, 511.f] x [-128, 127.f]
325      * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
326      */
327     uint8_t mvrange;
328     uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use
329     VLC *cbpcy_vlc;               ///< CBPCY VLC table
330     int tt_index;                 ///< Index for Transform Type tables
331     uint8_t* mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)
332     uint8_t* direct_mb_plane;     ///< bitplane for "direct" MBs
333     int mv_type_is_raw;           ///< mv type mb plane is not coded
334     int dmb_is_raw;               ///< direct mb plane is raw
335     int skip_is_raw;              ///< skip mb plane is not coded
336     uint8_t luty[256], lutuv[256]; // lookup tables used for intensity compensation
337     int use_ic;                   ///< use intensity compensation in B-frames
338     int rnd;                      ///< rounding control
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     uint8_t* acpred_plane;       ///< AC prediction flags bitplane
362     int acpred_is_raw;
363     uint8_t* over_flags_plane;   ///< Overflags bitplane
364     int overflg_is_raw;
365     uint8_t condover;
366     uint16_t *hrd_rate, *hrd_buffer;
367     uint8_t *hrd_fullness;
368     uint8_t range_mapy_flag;
369     uint8_t range_mapuv_flag;
370     uint8_t range_mapy;
371     uint8_t range_mapuv;
372     //@}
373
374     int p_frame_skipped;
375     int bi_type;
376 } VC1Context;
377
378 /**
379  * Get unary code of limited length
380  * @fixme FIXME Slow and ugly
381  * @param gb GetBitContext
382  * @param[in] stop The bitstop value (unary code of 1's or 0's)
383  * @param[in] len Maximum length
384  * @return Unary length/index
385  */
386 static int get_prefix(GetBitContext *gb, int stop, int len)
387 {
388 #if 1
389     int i;
390
391     for(i = 0; i < len && get_bits1(gb) != stop; i++);
392     return i;
393 /*  int i = 0, tmp = !stop;
394
395   while (i != len && tmp != stop)
396   {
397     tmp = get_bits(gb, 1);
398     i++;
399   }
400   if (i == len && tmp != stop) return len+1;
401   return i;*/
402 #else
403   unsigned int buf;
404   int log;
405
406   OPEN_READER(re, gb);
407   UPDATE_CACHE(re, gb);
408   buf=GET_CACHE(re, gb); //Still not sure
409   if (stop) buf = ~buf;
410
411   log= av_log2(-buf); //FIXME: -?
412   if (log < limit){
413     LAST_SKIP_BITS(re, gb, log+1);
414     CLOSE_READER(re, gb);
415     return log;
416   }
417
418   LAST_SKIP_BITS(re, gb, limit);
419   CLOSE_READER(re, gb);
420   return limit;
421 #endif
422 }
423
424 static inline int decode210(GetBitContext *gb){
425     int n;
426     n = get_bits1(gb);
427     if (n == 1)
428         return 0;
429     else
430         return 2 - get_bits1(gb);
431 }
432
433 /**
434  * Init VC-1 specific tables and VC1Context members
435  * @param v The VC1Context to initialize
436  * @return Status
437  */
438 static int vc1_init_common(VC1Context *v)
439 {
440     static int done = 0;
441     int i = 0;
442
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 /** Decode rows by checking if they are skipped
524  * @param plane Buffer to store decoded bits
525  * @param[in] width Width of this buffer
526  * @param[in] height Height of this buffer
527  * @param[in] stride of this buffer
528  */
529 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
530     int x, y;
531
532     for (y=0; y<height; y++){
533         if (!get_bits(gb, 1)) //rowskip
534             memset(plane, 0, width);
535         else
536             for (x=0; x<width; x++)
537                 plane[x] = get_bits(gb, 1);
538         plane += stride;
539     }
540 }
541
542 /** Decode columns by checking if they are skipped
543  * @param plane Buffer to store decoded bits
544  * @param[in] width Width of this buffer
545  * @param[in] height Height of this buffer
546  * @param[in] stride of this buffer
547  * @fixme FIXME: Optimize
548  */
549 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
550     int x, y;
551
552     for (x=0; x<width; x++){
553         if (!get_bits(gb, 1)) //colskip
554             for (y=0; y<height; y++)
555                 plane[y*stride] = 0;
556         else
557             for (y=0; y<height; y++)
558                 plane[y*stride] = get_bits(gb, 1);
559         plane ++;
560     }
561 }
562
563 /** Decode a bitplane's bits
564  * @param bp Bitplane where to store the decode bits
565  * @param v VC-1 context for bit reading and logging
566  * @return Status
567  * @fixme FIXME: Optimize
568  */
569 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
570 {
571     GetBitContext *gb = &v->s.gb;
572
573     int imode, x, y, code, offset;
574     uint8_t invert, *planep = data;
575     int width, height, stride;
576
577     width = v->s.mb_width;
578     height = v->s.mb_height;
579     stride = v->s.mb_stride;
580     invert = get_bits(gb, 1);
581     imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
582
583     *raw_flag = 0;
584     switch (imode)
585     {
586     case IMODE_RAW:
587         //Data is actually read in the MB layer (same for all tests == "raw")
588         *raw_flag = 1; //invert ignored
589         return invert;
590     case IMODE_DIFF2:
591     case IMODE_NORM2:
592         if ((height * width) & 1)
593         {
594             *planep++ = get_bits(gb, 1);
595             offset = 1;
596         }
597         else offset = 0;
598         // decode bitplane as one long line
599         for (y = offset; y < height * width; y += 2) {
600             code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
601             *planep++ = code & 1;
602             offset++;
603             if(offset == width) {
604                 offset = 0;
605                 planep += stride - width;
606             }
607             *planep++ = code >> 1;
608             offset++;
609             if(offset == width) {
610                 offset = 0;
611                 planep += stride - width;
612             }
613         }
614         break;
615     case IMODE_DIFF6:
616     case IMODE_NORM6:
617         if(!(height % 3) && (width % 3)) { // use 2x3 decoding
618             for(y = 0; y < height; y+= 3) {
619                 for(x = width & 1; x < width; x += 2) {
620                     code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
621                     if(code < 0){
622                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
623                         return -1;
624                     }
625                     planep[x + 0] = (code >> 0) & 1;
626                     planep[x + 1] = (code >> 1) & 1;
627                     planep[x + 0 + stride] = (code >> 2) & 1;
628                     planep[x + 1 + stride] = (code >> 3) & 1;
629                     planep[x + 0 + stride * 2] = (code >> 4) & 1;
630                     planep[x + 1 + stride * 2] = (code >> 5) & 1;
631                 }
632                 planep += stride * 3;
633             }
634             if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
635         } else { // 3x2
636             planep += (height & 1) * stride;
637             for(y = height & 1; y < height; y += 2) {
638                 for(x = width % 3; x < width; x += 3) {
639                     code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
640                     if(code < 0){
641                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
642                         return -1;
643                     }
644                     planep[x + 0] = (code >> 0) & 1;
645                     planep[x + 1] = (code >> 1) & 1;
646                     planep[x + 2] = (code >> 2) & 1;
647                     planep[x + 0 + stride] = (code >> 3) & 1;
648                     planep[x + 1 + stride] = (code >> 4) & 1;
649                     planep[x + 2 + stride] = (code >> 5) & 1;
650                 }
651                 planep += stride * 2;
652             }
653             x = width % 3;
654             if(x) decode_colskip(data  ,             x, height    , stride, &v->s.gb);
655             if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
656         }
657         break;
658     case IMODE_ROWSKIP:
659         decode_rowskip(data, width, height, stride, &v->s.gb);
660         break;
661     case IMODE_COLSKIP:
662         decode_colskip(data, width, height, stride, &v->s.gb);
663         break;
664     default: break;
665     }
666
667     /* Applying diff operator */
668     if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
669     {
670         planep = data;
671         planep[0] ^= invert;
672         for (x=1; x<width; x++)
673             planep[x] ^= planep[x-1];
674         for (y=1; y<height; y++)
675         {
676             planep += stride;
677             planep[0] ^= planep[-stride];
678             for (x=1; x<width; x++)
679             {
680                 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
681                 else                                 planep[x] ^= planep[x-1];
682             }
683         }
684     }
685     else if (invert)
686     {
687         planep = data;
688         for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
689     }
690     return (imode<<1) + invert;
691 }
692
693 /** @} */ //Bitplane group
694
695 /***********************************************************************/
696 /** VOP Dquant decoding
697  * @param v VC-1 Context
698  */
699 static int vop_dquant_decoding(VC1Context *v)
700 {
701     GetBitContext *gb = &v->s.gb;
702     int pqdiff;
703
704     //variable size
705     if (v->dquant == 2)
706     {
707         pqdiff = get_bits(gb, 3);
708         if (pqdiff == 7) v->altpq = get_bits(gb, 5);
709         else v->altpq = v->pq + pqdiff + 1;
710     }
711     else
712     {
713         v->dquantfrm = get_bits(gb, 1);
714         if ( v->dquantfrm )
715         {
716             v->dqprofile = get_bits(gb, 2);
717             switch (v->dqprofile)
718             {
719             case DQPROFILE_SINGLE_EDGE:
720             case DQPROFILE_DOUBLE_EDGES:
721                 v->dqsbedge = get_bits(gb, 2);
722                 break;
723             case DQPROFILE_ALL_MBS:
724                 v->dqbilevel = get_bits(gb, 1);
725             default: break; //Forbidden ?
726             }
727             if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
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         }
734     }
735     return 0;
736 }
737
738 /** Put block onto picture
739  */
740 static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
741 {
742     uint8_t *Y;
743     int ys, us, vs;
744     DSPContext *dsp = &v->s.dsp;
745
746     if(v->rangeredfrm) {
747         int i, j, k;
748         for(k = 0; k < 6; k++)
749             for(j = 0; j < 8; j++)
750                 for(i = 0; i < 8; i++)
751                     block[k][i + j*8] = ((block[k][i + j*8] - 128) << 1) + 128;
752
753     }
754     ys = v->s.current_picture.linesize[0];
755     us = v->s.current_picture.linesize[1];
756     vs = v->s.current_picture.linesize[2];
757     Y = v->s.dest[0];
758
759     dsp->put_pixels_clamped(block[0], Y, ys);
760     dsp->put_pixels_clamped(block[1], Y + 8, ys);
761     Y += ys * 8;
762     dsp->put_pixels_clamped(block[2], Y, ys);
763     dsp->put_pixels_clamped(block[3], Y + 8, ys);
764
765     if(!(v->s.flags & CODEC_FLAG_GRAY)) {
766         dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
767         dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
768     }
769 }
770
771 /** Do motion compensation over 1 macroblock
772  * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
773  */
774 static void vc1_mc_1mv(VC1Context *v, int dir)
775 {
776     MpegEncContext *s = &v->s;
777     DSPContext *dsp = &v->s.dsp;
778     uint8_t *srcY, *srcU, *srcV;
779     int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
780
781     if(!v->s.last_picture.data[0])return;
782
783     mx = s->mv[dir][0][0];
784     my = s->mv[dir][0][1];
785
786     // store motion vectors for further use in B frames
787     if(s->pict_type == P_TYPE) {
788         s->current_picture.motion_val[1][s->block_index[0]][0] = mx;
789         s->current_picture.motion_val[1][s->block_index[0]][1] = my;
790     }
791     uvmx = (mx + ((mx & 3) == 3)) >> 1;
792     uvmy = (my + ((my & 3) == 3)) >> 1;
793     if(v->fastuvmc) {
794         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
795         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
796     }
797     if(!dir) {
798         srcY = s->last_picture.data[0];
799         srcU = s->last_picture.data[1];
800         srcV = s->last_picture.data[2];
801     } else {
802         srcY = s->next_picture.data[0];
803         srcU = s->next_picture.data[1];
804         srcV = s->next_picture.data[2];
805     }
806
807     src_x = s->mb_x * 16 + (mx >> 2);
808     src_y = s->mb_y * 16 + (my >> 2);
809     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
810     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
811
812     src_x   = clip(  src_x, -16, s->mb_width  * 16);
813     src_y   = clip(  src_y, -16, s->mb_height * 16);
814     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
815     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
816
817     srcY += src_y * s->linesize + src_x;
818     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
819     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
820
821     /* for grayscale we should not try to read from unknown area */
822     if(s->flags & CODEC_FLAG_GRAY) {
823         srcU = s->edge_emu_buffer + 18 * s->linesize;
824         srcV = s->edge_emu_buffer + 18 * s->linesize;
825     }
826
827     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
828        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
829        || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
830         uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
831
832         srcY -= s->mspel * (1 + s->linesize);
833         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
834                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
835         srcY = s->edge_emu_buffer;
836         ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
837                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
838         ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
839                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
840         srcU = uvbuf;
841         srcV = uvbuf + 16;
842         /* if we deal with range reduction we need to scale source blocks */
843         if(v->rangeredfrm) {
844             int i, j;
845             uint8_t *src, *src2;
846
847             src = srcY;
848             for(j = 0; j < 17 + s->mspel*2; j++) {
849                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
850                 src += s->linesize;
851             }
852             src = srcU; src2 = srcV;
853             for(j = 0; j < 9; j++) {
854                 for(i = 0; i < 9; i++) {
855                     src[i] = ((src[i] - 128) >> 1) + 128;
856                     src2[i] = ((src2[i] - 128) >> 1) + 128;
857                 }
858                 src += s->uvlinesize;
859                 src2 += s->uvlinesize;
860             }
861         }
862         /* if we deal with intensity compensation we need to scale source blocks */
863         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
864             int i, j;
865             uint8_t *src, *src2;
866
867             src = srcY;
868             for(j = 0; j < 17 + s->mspel*2; j++) {
869                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
870                 src += s->linesize;
871             }
872             src = srcU; src2 = srcV;
873             for(j = 0; j < 9; j++) {
874                 for(i = 0; i < 9; i++) {
875                     src[i] = v->lutuv[src[i]];
876                     src2[i] = v->lutuv[src2[i]];
877                 }
878                 src += s->uvlinesize;
879                 src2 += s->uvlinesize;
880             }
881         }
882         srcY += s->mspel * (1 + s->linesize);
883     }
884
885     if(s->mspel) {
886         dxy = ((my & 3) << 2) | (mx & 3);
887         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0]    , srcY    , s->linesize, v->rnd);
888         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
889         srcY += s->linesize * 8;
890         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
891         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
892     } else { // hpel mc - always used for luma
893         dxy = (my & 2) | ((mx & 2) >> 1);
894
895         if(!v->rnd)
896             dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
897         else
898             dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
899     }
900
901     if(s->flags & CODEC_FLAG_GRAY) return;
902     /* Chroma MC always uses qpel bilinear */
903     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
904     uvmx = (uvmx&3)<<1;
905     uvmy = (uvmy&3)<<1;
906     if(!v->rnd){
907         dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
908         dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
909     }else{
910         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
911         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
912     }
913 }
914
915 /** Do motion compensation for 4-MV macroblock - luminance block
916  */
917 static void vc1_mc_4mv_luma(VC1Context *v, int n)
918 {
919     MpegEncContext *s = &v->s;
920     DSPContext *dsp = &v->s.dsp;
921     uint8_t *srcY;
922     int dxy, mx, my, src_x, src_y;
923     int off;
924
925     if(!v->s.last_picture.data[0])return;
926     mx = s->mv[0][n][0];
927     my = s->mv[0][n][1];
928     srcY = s->last_picture.data[0];
929
930     off = s->linesize * 4 * (n&2) + (n&1) * 8;
931
932     src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
933     src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
934
935     src_x   = clip(  src_x, -16, s->mb_width  * 16);
936     src_y   = clip(  src_y, -16, s->mb_height * 16);
937
938     srcY += src_y * s->linesize + src_x;
939
940     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
941        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
942        || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
943         srcY -= s->mspel * (1 + s->linesize);
944         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
945                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
946         srcY = s->edge_emu_buffer;
947         /* if we deal with range reduction we need to scale source blocks */
948         if(v->rangeredfrm) {
949             int i, j;
950             uint8_t *src;
951
952             src = srcY;
953             for(j = 0; j < 9 + s->mspel*2; j++) {
954                 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
955                 src += s->linesize;
956             }
957         }
958         /* if we deal with intensity compensation we need to scale source blocks */
959         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
960             int i, j;
961             uint8_t *src;
962
963             src = srcY;
964             for(j = 0; j < 9 + s->mspel*2; j++) {
965                 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
966                 src += s->linesize;
967             }
968         }
969         srcY += s->mspel * (1 + s->linesize);
970     }
971
972     if(s->mspel) {
973         dxy = ((my & 3) << 2) | (mx & 3);
974         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
975     } else { // hpel mc - always used for luma
976         dxy = (my & 2) | ((mx & 2) >> 1);
977         if(!v->rnd)
978             dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
979         else
980             dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
981     }
982 }
983
984 static inline int median4(int a, int b, int c, int d)
985 {
986     if(a < b) {
987         if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
988         else      return (FFMIN(b, c) + FFMAX(a, d)) / 2;
989     } else {
990         if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
991         else      return (FFMIN(a, c) + FFMAX(b, d)) / 2;
992     }
993 }
994
995
996 /** Do motion compensation for 4-MV macroblock - both chroma blocks
997  */
998 static void vc1_mc_4mv_chroma(VC1Context *v)
999 {
1000     MpegEncContext *s = &v->s;
1001     DSPContext *dsp = &v->s.dsp;
1002     uint8_t *srcU, *srcV;
1003     int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1004     int i, idx, tx = 0, ty = 0;
1005     int mvx[4], mvy[4], intra[4];
1006     static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1007
1008     if(!v->s.last_picture.data[0])return;
1009     if(s->flags & CODEC_FLAG_GRAY) return;
1010
1011     for(i = 0; i < 4; i++) {
1012         mvx[i] = s->mv[0][i][0];
1013         mvy[i] = s->mv[0][i][1];
1014         intra[i] = v->mb_type[0][s->block_index[i]];
1015     }
1016
1017     /* calculate chroma MV vector from four luma MVs */
1018     idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1019     if(!idx) { // all blocks are inter
1020         tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1021         ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1022     } else if(count[idx] == 1) { // 3 inter blocks
1023         switch(idx) {
1024         case 0x1:
1025             tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1026             ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1027             break;
1028         case 0x2:
1029             tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1030             ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1031             break;
1032         case 0x4:
1033             tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1034             ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1035             break;
1036         case 0x8:
1037             tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1038             ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1039             break;
1040         }
1041     } else if(count[idx] == 2) {
1042         int t1 = 0, t2 = 0;
1043         for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1044         for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1045         tx = (mvx[t1] + mvx[t2]) / 2;
1046         ty = (mvy[t1] + mvy[t2]) / 2;
1047     } else
1048         return; //no need to do MC for inter blocks
1049
1050     s->current_picture.motion_val[1][s->block_index[0]][0] = tx;
1051     s->current_picture.motion_val[1][s->block_index[0]][1] = ty;
1052     uvmx = (tx + ((tx&3) == 3)) >> 1;
1053     uvmy = (ty + ((ty&3) == 3)) >> 1;
1054     if(v->fastuvmc) {
1055         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1056         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1057     }
1058
1059     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1060     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1061
1062     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
1063     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
1064     srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1065     srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1066     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1067        || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
1068        || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
1069         ff_emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize, 8+1, 8+1,
1070                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1071         ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1072                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1073         srcU = s->edge_emu_buffer;
1074         srcV = s->edge_emu_buffer + 16;
1075
1076         /* if we deal with range reduction we need to scale source blocks */
1077         if(v->rangeredfrm) {
1078             int i, j;
1079             uint8_t *src, *src2;
1080
1081             src = srcU; src2 = srcV;
1082             for(j = 0; j < 9; j++) {
1083                 for(i = 0; i < 9; i++) {
1084                     src[i] = ((src[i] - 128) >> 1) + 128;
1085                     src2[i] = ((src2[i] - 128) >> 1) + 128;
1086                 }
1087                 src += s->uvlinesize;
1088                 src2 += s->uvlinesize;
1089             }
1090         }
1091         /* if we deal with intensity compensation we need to scale source blocks */
1092         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1093             int i, j;
1094             uint8_t *src, *src2;
1095
1096             src = srcU; src2 = srcV;
1097             for(j = 0; j < 9; j++) {
1098                 for(i = 0; i < 9; i++) {
1099                     src[i] = v->lutuv[src[i]];
1100                     src2[i] = v->lutuv[src2[i]];
1101                 }
1102                 src += s->uvlinesize;
1103                 src2 += s->uvlinesize;
1104             }
1105         }
1106     }
1107
1108     /* Chroma MC always uses qpel bilinear */
1109     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
1110     uvmx = (uvmx&3)<<1;
1111     uvmy = (uvmy&3)<<1;
1112     if(!v->rnd){
1113         dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1114         dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1115     }else{
1116         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1117         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1118     }
1119 }
1120
1121 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
1122
1123 /**
1124  * Decode Simple/Main Profiles sequence header
1125  * @see Figure 7-8, p16-17
1126  * @param avctx Codec context
1127  * @param gb GetBit context initialized from Codec context extra_data
1128  * @return Status
1129  */
1130 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1131 {
1132     VC1Context *v = avctx->priv_data;
1133
1134     av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
1135     v->profile = get_bits(gb, 2);
1136     if (v->profile == 2)
1137     {
1138         av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1139         return -1;
1140     }
1141
1142     if (v->profile == PROFILE_ADVANCED)
1143     {
1144         return decode_sequence_header_adv(v, gb);
1145     }
1146     else
1147     {
1148         v->res_sm = get_bits(gb, 2); //reserved
1149         if (v->res_sm)
1150         {
1151             av_log(avctx, AV_LOG_ERROR,
1152                    "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1153             return -1;
1154         }
1155     }
1156
1157     // (fps-2)/4 (->30)
1158     v->frmrtq_postproc = get_bits(gb, 3); //common
1159     // (bitrate-32kbps)/64kbps
1160     v->bitrtq_postproc = get_bits(gb, 5); //common
1161     v->s.loop_filter = get_bits(gb, 1); //common
1162     if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1163     {
1164         av_log(avctx, AV_LOG_ERROR,
1165                "LOOPFILTER shell not be enabled in simple profile\n");
1166     }
1167
1168     v->res_x8 = get_bits(gb, 1); //reserved
1169     if (v->res_x8)
1170     {
1171         av_log(avctx, AV_LOG_ERROR,
1172                "1 for reserved RES_X8 is forbidden\n");
1173         //return -1;
1174     }
1175     v->multires = get_bits(gb, 1);
1176     v->res_fasttx = get_bits(gb, 1);
1177     if (!v->res_fasttx)
1178     {
1179         av_log(avctx, AV_LOG_ERROR,
1180                "0 for reserved RES_FASTTX is forbidden\n");
1181         //return -1;
1182     }
1183
1184     v->fastuvmc =  get_bits(gb, 1); //common
1185     if (!v->profile && !v->fastuvmc)
1186     {
1187         av_log(avctx, AV_LOG_ERROR,
1188                "FASTUVMC unavailable in Simple Profile\n");
1189         return -1;
1190     }
1191     v->extended_mv =  get_bits(gb, 1); //common
1192     if (!v->profile && v->extended_mv)
1193     {
1194         av_log(avctx, AV_LOG_ERROR,
1195                "Extended MVs unavailable in Simple Profile\n");
1196         return -1;
1197     }
1198     v->dquant =  get_bits(gb, 2); //common
1199     v->vstransform =  get_bits(gb, 1); //common
1200
1201     v->res_transtab = get_bits(gb, 1);
1202     if (v->res_transtab)
1203     {
1204         av_log(avctx, AV_LOG_ERROR,
1205                "1 for reserved RES_TRANSTAB is forbidden\n");
1206         return -1;
1207     }
1208
1209     v->overlap = get_bits(gb, 1); //common
1210
1211     v->s.resync_marker = get_bits(gb, 1);
1212     v->rangered = get_bits(gb, 1);
1213     if (v->rangered && v->profile == PROFILE_SIMPLE)
1214     {
1215         av_log(avctx, AV_LOG_INFO,
1216                "RANGERED should be set to 0 in simple profile\n");
1217     }
1218
1219     v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1220     v->quantizer_mode = get_bits(gb, 2); //common
1221
1222     v->finterpflag = get_bits(gb, 1); //common
1223     v->res_rtm_flag = get_bits(gb, 1); //reserved
1224     if (!v->res_rtm_flag)
1225     {
1226 //            av_log(avctx, AV_LOG_ERROR,
1227 //                   "0 for reserved RES_RTM_FLAG is forbidden\n");
1228         av_log(avctx, AV_LOG_ERROR,
1229                "Old WMV3 version detected, only I-frames will be decoded\n");
1230         //return -1;
1231     }
1232     av_log(avctx, AV_LOG_DEBUG,
1233                "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1234                "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1235                "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1236                "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1237                v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1238                v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1239                v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1240                v->dquant, v->quantizer_mode, avctx->max_b_frames
1241                );
1242     return 0;
1243 }
1244
1245 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
1246 {
1247     v->res_rtm_flag = 1;
1248     v->level = get_bits(gb, 3);
1249     if(v->level >= 5)
1250     {
1251         av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1252     }
1253     v->chromaformat = get_bits(gb, 2);
1254     if (v->chromaformat != 1)
1255     {
1256         av_log(v->s.avctx, AV_LOG_ERROR,
1257                "Only 4:2:0 chroma format supported\n");
1258         return -1;
1259     }
1260
1261     // (fps-2)/4 (->30)
1262     v->frmrtq_postproc = get_bits(gb, 3); //common
1263     // (bitrate-32kbps)/64kbps
1264     v->bitrtq_postproc = get_bits(gb, 5); //common
1265     v->postprocflag = get_bits(gb, 1); //common
1266
1267     v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
1268     v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
1269     v->broadcast = get_bits1(gb);
1270     v->interlace = get_bits1(gb);
1271     if(v->interlace){
1272         av_log(v->s.avctx, AV_LOG_ERROR, "Interlaced mode not supported (yet)\n");
1273         return -1;
1274     }
1275     v->tfcntrflag = get_bits1(gb);
1276     v->finterpflag = get_bits1(gb);
1277     get_bits1(gb); // reserved
1278
1279     av_log(v->s.avctx, AV_LOG_DEBUG,
1280                "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1281                "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
1282                "TFCTRflag=%i, FINTERPflag=%i\n",
1283                v->level, v->frmrtq_postproc, v->bitrtq_postproc,
1284                v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
1285                v->tfcntrflag, v->finterpflag
1286                );
1287
1288     v->psf = get_bits1(gb);
1289     if(v->psf) { //PsF, 6.1.13
1290         av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
1291         return -1;
1292     }
1293     if(get_bits1(gb)) { //Display Info - decoding is not affected by it
1294         int w, h, ar = 0;
1295         av_log(v->s.avctx, AV_LOG_INFO, "Display extended info:\n");
1296         w = get_bits(gb, 14) + 1;
1297         h = get_bits(gb, 14) + 1;
1298         av_log(v->s.avctx, AV_LOG_INFO, "Display dimensions: %ix%i\n", w, h);
1299         if(get_bits1(gb))
1300             ar = get_bits(gb, 4);
1301         if(ar && ar < 14){
1302             v->s.avctx->sample_aspect_ratio = vc1_pixel_aspect[ar];
1303         }else if(ar == 15){
1304             w = get_bits(gb, 8);
1305             h = get_bits(gb, 8);
1306             v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
1307         }
1308
1309         if(get_bits1(gb)){ //framerate stuff
1310             if(get_bits1(gb)) {
1311                 get_bits(gb, 16);
1312             } else {
1313                 get_bits(gb, 8);
1314                 get_bits(gb, 4);
1315             }
1316         }
1317
1318         if(get_bits1(gb)){
1319             v->color_prim = get_bits(gb, 8);
1320             v->transfer_char = get_bits(gb, 8);
1321             v->matrix_coef = get_bits(gb, 8);
1322         }
1323     }
1324
1325     v->hrd_param_flag = get_bits1(gb);
1326     if(v->hrd_param_flag) {
1327         int i;
1328         v->hrd_num_leaky_buckets = get_bits(gb, 5);
1329         get_bits(gb, 4); //bitrate exponent
1330         get_bits(gb, 4); //buffer size exponent
1331         for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1332             get_bits(gb, 16); //hrd_rate[n]
1333             get_bits(gb, 16); //hrd_buffer[n]
1334         }
1335     }
1336     return 0;
1337 }
1338
1339 static int decode_entry_point(AVCodecContext *avctx, GetBitContext *gb)
1340 {
1341     VC1Context *v = avctx->priv_data;
1342     int i, blink, refdist;
1343
1344     av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
1345     blink = get_bits1(gb); // broken link
1346     avctx->max_b_frames = 1 - get_bits1(gb); // 'closed entry' also signalize possible B-frames
1347     v->panscanflag = get_bits1(gb);
1348     refdist = get_bits1(gb); // refdist flag
1349     v->s.loop_filter = get_bits1(gb);
1350     v->fastuvmc = get_bits1(gb);
1351     v->extended_mv = get_bits1(gb);
1352     v->dquant = get_bits(gb, 2);
1353     v->vstransform = get_bits1(gb);
1354     v->overlap = get_bits1(gb);
1355     v->quantizer_mode = get_bits(gb, 2);
1356
1357     if(v->hrd_param_flag){
1358         for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1359             get_bits(gb, 8); //hrd_full[n]
1360         }
1361     }
1362
1363     if(get_bits1(gb)){
1364         avctx->coded_width = (get_bits(gb, 12)+1)<<1;
1365         avctx->coded_height = (get_bits(gb, 12)+1)<<1;
1366     }
1367     if(v->extended_mv)
1368         v->extended_dmv = get_bits1(gb);
1369     if(get_bits1(gb)) {
1370         av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
1371         skip_bits(gb, 3); // Y range, ignored for now
1372     }
1373     if(get_bits1(gb)) {
1374         av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
1375         skip_bits(gb, 3); // UV range, ignored for now
1376     }
1377
1378     av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
1379         "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1380         "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1381         "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1382         blink, 1 - avctx->max_b_frames, v->panscanflag, refdist, v->s.loop_filter,
1383         v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
1384
1385     return 0;
1386 }
1387
1388 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1389 {
1390     int pqindex, lowquant, status;
1391
1392     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1393     skip_bits(gb, 2); //framecnt unused
1394     v->rangeredfrm = 0;
1395     if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1396     v->s.pict_type = get_bits(gb, 1);
1397     if (v->s.avctx->max_b_frames) {
1398         if (!v->s.pict_type) {
1399             if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1400             else v->s.pict_type = B_TYPE;
1401         } else v->s.pict_type = P_TYPE;
1402     } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1403
1404     v->bi_type = 0;
1405     if(v->s.pict_type == B_TYPE) {
1406         v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1407         v->bfraction = vc1_bfraction_lut[v->bfraction];
1408         if(v->bfraction == 0) {
1409             v->s.pict_type = BI_TYPE;
1410         }
1411     }
1412     if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1413         get_bits(gb, 7); // skip buffer fullness
1414
1415     /* calculate RND */
1416     if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1417         v->rnd = 1;
1418     if(v->s.pict_type == P_TYPE)
1419         v->rnd ^= 1;
1420
1421     /* Quantizer stuff */
1422     pqindex = get_bits(gb, 5);
1423     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1424         v->pq = pquant_table[0][pqindex];
1425     else
1426         v->pq = pquant_table[1][pqindex];
1427
1428     v->pquantizer = 1;
1429     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1430         v->pquantizer = pqindex < 9;
1431     if (v->quantizer_mode == QUANT_NON_UNIFORM)
1432         v->pquantizer = 0;
1433     v->pqindex = pqindex;
1434     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1435     else v->halfpq = 0;
1436     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1437         v->pquantizer = get_bits(gb, 1);
1438     v->dquantfrm = 0;
1439     if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1440     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1441     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1442     v->range_x = 1 << (v->k_x - 1);
1443     v->range_y = 1 << (v->k_y - 1);
1444     if (v->profile == PROFILE_ADVANCED)
1445     {
1446         if (v->postprocflag) v->postproc = get_bits(gb, 1);
1447     }
1448     else
1449         if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1450
1451 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1452 //        (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1453
1454     if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
1455
1456     switch(v->s.pict_type) {
1457     case P_TYPE:
1458         if (v->pq < 5) v->tt_index = 0;
1459         else if(v->pq < 13) v->tt_index = 1;
1460         else v->tt_index = 2;
1461
1462         lowquant = (v->pq > 12) ? 0 : 1;
1463         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1464         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1465         {
1466             int scale, shift, i;
1467             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1468             v->lumscale = get_bits(gb, 6);
1469             v->lumshift = get_bits(gb, 6);
1470             v->use_ic = 1;
1471             /* fill lookup tables for intensity compensation */
1472             if(!v->lumscale) {
1473                 scale = -64;
1474                 shift = (255 - v->lumshift * 2) << 6;
1475                 if(v->lumshift > 31)
1476                     shift += 128 << 6;
1477             } else {
1478                 scale = v->lumscale + 32;
1479                 if(v->lumshift > 31)
1480                     shift = (v->lumshift - 64) << 6;
1481                 else
1482                     shift = v->lumshift << 6;
1483             }
1484             for(i = 0; i < 256; i++) {
1485                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1486                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1487             }
1488         }
1489         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1490             v->s.quarter_sample = 0;
1491         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1492             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1493                 v->s.quarter_sample = 0;
1494             else
1495                 v->s.quarter_sample = 1;
1496         } else
1497             v->s.quarter_sample = 1;
1498         v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1499
1500         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1501                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1502                 || v->mv_mode == MV_PMODE_MIXED_MV)
1503         {
1504             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1505             if (status < 0) return -1;
1506             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1507                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1508         } else {
1509             v->mv_type_is_raw = 0;
1510             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1511         }
1512         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1513         if (status < 0) return -1;
1514         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1515                "Imode: %i, Invert: %i\n", status>>1, status&1);
1516
1517         /* Hopefully this is correct for P frames */
1518         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1519         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1520
1521         if (v->dquant)
1522         {
1523             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1524             vop_dquant_decoding(v);
1525         }
1526
1527         v->ttfrm = 0; //FIXME Is that so ?
1528         if (v->vstransform)
1529         {
1530             v->ttmbf = get_bits(gb, 1);
1531             if (v->ttmbf)
1532             {
1533                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1534             }
1535         } else {
1536             v->ttmbf = 1;
1537             v->ttfrm = TT_8X8;
1538         }
1539         break;
1540     case B_TYPE:
1541         if (v->pq < 5) v->tt_index = 0;
1542         else if(v->pq < 13) v->tt_index = 1;
1543         else v->tt_index = 2;
1544
1545         lowquant = (v->pq > 12) ? 0 : 1;
1546         v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1547         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1548         v->s.mspel = v->s.quarter_sample;
1549
1550         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1551         if (status < 0) return -1;
1552         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1553                "Imode: %i, Invert: %i\n", status>>1, status&1);
1554         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1555         if (status < 0) return -1;
1556         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1557                "Imode: %i, Invert: %i\n", status>>1, status&1);
1558
1559         v->s.mv_table_index = get_bits(gb, 2);
1560         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1561
1562         if (v->dquant)
1563         {
1564             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1565             vop_dquant_decoding(v);
1566         }
1567
1568         v->ttfrm = 0;
1569         if (v->vstransform)
1570         {
1571             v->ttmbf = get_bits(gb, 1);
1572             if (v->ttmbf)
1573             {
1574                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1575             }
1576         } else {
1577             v->ttmbf = 1;
1578             v->ttfrm = TT_8X8;
1579         }
1580         break;
1581     }
1582
1583     /* AC Syntax */
1584     v->c_ac_table_index = decode012(gb);
1585     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1586     {
1587         v->y_ac_table_index = decode012(gb);
1588     }
1589     /* DC Syntax */
1590     v->s.dc_table_index = get_bits(gb, 1);
1591
1592     if(v->s.pict_type == BI_TYPE) {
1593         v->s.pict_type = B_TYPE;
1594         v->bi_type = 1;
1595     }
1596     return 0;
1597 }
1598
1599 static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
1600 {
1601     int fcm;
1602     int pqindex, lowquant;
1603     int status;
1604
1605     v->p_frame_skipped = 0;
1606
1607     if(v->interlace)
1608         fcm = decode012(gb);
1609     switch(get_prefix(gb, 0, 4)) {
1610     case 0:
1611         v->s.pict_type = P_TYPE;
1612         break;
1613     case 1:
1614         v->s.pict_type = B_TYPE;
1615         break;
1616     case 2:
1617         v->s.pict_type = I_TYPE;
1618         break;
1619     case 3:
1620         v->s.pict_type = BI_TYPE;
1621         break;
1622     case 4:
1623         v->s.pict_type = P_TYPE; // skipped pic
1624         v->p_frame_skipped = 1;
1625         return 0;
1626     }
1627     if(v->tfcntrflag)
1628         get_bits(gb, 8);
1629     if(v->broadcast) {
1630         if(!v->interlace || v->panscanflag) {
1631             get_bits(gb, 2);
1632         } else {
1633             get_bits1(gb);
1634             get_bits1(gb);
1635         }
1636     }
1637     if(v->panscanflag) {
1638         //...
1639     }
1640     v->rnd = get_bits1(gb);
1641     if(v->interlace)
1642         v->uvsamp = get_bits1(gb);
1643     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1644     if(v->s.pict_type == B_TYPE) {
1645         v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1646         v->bfraction = vc1_bfraction_lut[v->bfraction];
1647         if(v->bfraction == 0) {
1648             v->s.pict_type = BI_TYPE; /* XXX: should not happen here */
1649         }
1650     }
1651     pqindex = get_bits(gb, 5);
1652     v->pqindex = pqindex;
1653     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1654         v->pq = pquant_table[0][pqindex];
1655     else
1656         v->pq = pquant_table[1][pqindex];
1657
1658     v->pquantizer = 1;
1659     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1660         v->pquantizer = pqindex < 9;
1661     if (v->quantizer_mode == QUANT_NON_UNIFORM)
1662         v->pquantizer = 0;
1663     v->pqindex = pqindex;
1664     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1665     else v->halfpq = 0;
1666     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1667         v->pquantizer = get_bits(gb, 1);
1668
1669     switch(v->s.pict_type) {
1670     case I_TYPE:
1671     case BI_TYPE:
1672         status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1673         if (status < 0) return -1;
1674         av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1675                 "Imode: %i, Invert: %i\n", status>>1, status&1);
1676         v->condover = CONDOVER_NONE;
1677         if(v->overlap && v->pq <= 8) {
1678             v->condover = decode012(gb);
1679             if(v->condover == CONDOVER_SELECT) {
1680                 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1681                 if (status < 0) return -1;
1682                 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1683                         "Imode: %i, Invert: %i\n", status>>1, status&1);
1684             }
1685         }
1686         break;
1687     case P_TYPE:
1688         if(v->postprocflag)
1689             v->postproc = get_bits1(gb);
1690         if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1691         else v->mvrange = 0;
1692         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1693         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1694         v->range_x = 1 << (v->k_x - 1);
1695         v->range_y = 1 << (v->k_y - 1);
1696
1697         if (v->pq < 5) v->tt_index = 0;
1698         else if(v->pq < 13) v->tt_index = 1;
1699         else v->tt_index = 2;
1700
1701         lowquant = (v->pq > 12) ? 0 : 1;
1702         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1703         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1704         {
1705             int scale, shift, i;
1706             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1707             v->lumscale = get_bits(gb, 6);
1708             v->lumshift = get_bits(gb, 6);
1709             /* fill lookup tables for intensity compensation */
1710             if(!v->lumscale) {
1711                 scale = -64;
1712                 shift = (255 - v->lumshift * 2) << 6;
1713                 if(v->lumshift > 31)
1714                     shift += 128 << 6;
1715             } else {
1716                 scale = v->lumscale + 32;
1717                 if(v->lumshift > 31)
1718                     shift = (v->lumshift - 64) << 6;
1719                 else
1720                     shift = v->lumshift << 6;
1721             }
1722             for(i = 0; i < 256; i++) {
1723                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1724                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1725             }
1726         }
1727         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1728             v->s.quarter_sample = 0;
1729         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1730             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1731                 v->s.quarter_sample = 0;
1732             else
1733                 v->s.quarter_sample = 1;
1734         } else
1735             v->s.quarter_sample = 1;
1736         v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1737
1738         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1739                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1740                 || v->mv_mode == MV_PMODE_MIXED_MV)
1741         {
1742             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1743             if (status < 0) return -1;
1744             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1745                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1746         } else {
1747             v->mv_type_is_raw = 0;
1748             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1749         }
1750         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1751         if (status < 0) return -1;
1752         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1753                "Imode: %i, Invert: %i\n", status>>1, status&1);
1754
1755         /* Hopefully this is correct for P frames */
1756         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1757         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1758         if (v->dquant)
1759         {
1760             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1761             vop_dquant_decoding(v);
1762         }
1763
1764         v->ttfrm = 0; //FIXME Is that so ?
1765         if (v->vstransform)
1766         {
1767             v->ttmbf = get_bits(gb, 1);
1768             if (v->ttmbf)
1769             {
1770                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1771             }
1772         } else {
1773             v->ttmbf = 1;
1774             v->ttfrm = TT_8X8;
1775         }
1776         break;
1777     case B_TYPE:
1778         if(v->postprocflag)
1779             v->postproc = get_bits1(gb);
1780         if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1781         else v->mvrange = 0;
1782         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1783         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1784         v->range_x = 1 << (v->k_x - 1);
1785         v->range_y = 1 << (v->k_y - 1);
1786
1787         if (v->pq < 5) v->tt_index = 0;
1788         else if(v->pq < 13) v->tt_index = 1;
1789         else v->tt_index = 2;
1790
1791         lowquant = (v->pq > 12) ? 0 : 1;
1792         v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1793         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1794         v->s.mspel = v->s.quarter_sample;
1795
1796         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1797         if (status < 0) return -1;
1798         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1799                "Imode: %i, Invert: %i\n", status>>1, status&1);
1800         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1801         if (status < 0) return -1;
1802         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1803                "Imode: %i, Invert: %i\n", status>>1, status&1);
1804
1805         v->s.mv_table_index = get_bits(gb, 2);
1806         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1807
1808         if (v->dquant)
1809         {
1810             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1811             vop_dquant_decoding(v);
1812         }
1813
1814         v->ttfrm = 0;
1815         if (v->vstransform)
1816         {
1817             v->ttmbf = get_bits(gb, 1);
1818             if (v->ttmbf)
1819             {
1820                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1821             }
1822         } else {
1823             v->ttmbf = 1;
1824             v->ttfrm = TT_8X8;
1825         }
1826         break;
1827     }
1828
1829     /* AC Syntax */
1830     v->c_ac_table_index = decode012(gb);
1831     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1832     {
1833         v->y_ac_table_index = decode012(gb);
1834     }
1835     /* DC Syntax */
1836     v->s.dc_table_index = get_bits(gb, 1);
1837     if ((v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE) && v->dquant) {
1838         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1839         vop_dquant_decoding(v);
1840     }
1841
1842     v->bi_type = 0;
1843     if(v->s.pict_type == BI_TYPE) {
1844         v->s.pict_type = B_TYPE;
1845         v->bi_type = 1;
1846     }
1847     return 0;
1848 }
1849
1850 /***********************************************************************/
1851 /**
1852  * @defgroup block VC-1 Block-level functions
1853  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1854  * @{
1855  */
1856
1857 /**
1858  * @def GET_MQUANT
1859  * @brief Get macroblock-level quantizer scale
1860  */
1861 #define GET_MQUANT()                                           \
1862   if (v->dquantfrm)                                            \
1863   {                                                            \
1864     int edges = 0;                                             \
1865     if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1866     {                                                          \
1867       if (v->dqbilevel)                                        \
1868       {                                                        \
1869         mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
1870       }                                                        \
1871       else                                                     \
1872       {                                                        \
1873         mqdiff = get_bits(gb, 3);                              \
1874         if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1875         else mquant = get_bits(gb, 5);                         \
1876       }                                                        \
1877     }                                                          \
1878     if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
1879         edges = 1 << v->dqsbedge;                              \
1880     else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1881         edges = (3 << v->dqsbedge) % 15;                       \
1882     else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1883         edges = 15;                                            \
1884     if((edges&1) && !s->mb_x)                                  \
1885         mquant = v->altpq;                                     \
1886     if((edges&2) && s->first_slice_line)                       \
1887         mquant = v->altpq;                                     \
1888     if((edges&4) && s->mb_x == (s->mb_width - 1))              \
1889         mquant = v->altpq;                                     \
1890     if((edges&8) && s->mb_y == (s->mb_height - 1))             \
1891         mquant = v->altpq;                                     \
1892   }
1893
1894 /**
1895  * @def GET_MVDATA(_dmv_x, _dmv_y)
1896  * @brief Get MV differentials
1897  * @see MVDATA decoding from 8.3.5.2, p(1)20
1898  * @param _dmv_x Horizontal differential for decoded MV
1899  * @param _dmv_y Vertical differential for decoded MV
1900  */
1901 #define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1902   index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1903                        VC1_MV_DIFF_VLC_BITS, 2);                    \
1904   if (index > 36)                                                   \
1905   {                                                                 \
1906     mb_has_coeffs = 1;                                              \
1907     index -= 37;                                                    \
1908   }                                                                 \
1909   else mb_has_coeffs = 0;                                           \
1910   s->mb_intra = 0;                                                  \
1911   if (!index) { _dmv_x = _dmv_y = 0; }                              \
1912   else if (index == 35)                                             \
1913   {                                                                 \
1914     _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1915     _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1916   }                                                                 \
1917   else if (index == 36)                                             \
1918   {                                                                 \
1919     _dmv_x = 0;                                                     \
1920     _dmv_y = 0;                                                     \
1921     s->mb_intra = 1;                                                \
1922   }                                                                 \
1923   else                                                              \
1924   {                                                                 \
1925     index1 = index%6;                                               \
1926     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1927     else                                   val = 0;                 \
1928     if(size_table[index1] - val > 0)                                \
1929         val = get_bits(gb, size_table[index1] - val);               \
1930     else                                   val = 0;                 \
1931     sign = 0 - (val&1);                                             \
1932     _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1933                                                                     \
1934     index1 = index/6;                                               \
1935     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1936     else                                   val = 0;                 \
1937     if(size_table[index1] - val > 0)                                \
1938         val = get_bits(gb, size_table[index1] - val);               \
1939     else                                   val = 0;                 \
1940     sign = 0 - (val&1);                                             \
1941     _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1942   }
1943
1944 /** Predict and set motion vector
1945  */
1946 static inline void vc1_pred_mv(MpegEncContext *s, int n, int dmv_x, int dmv_y, int mv1, int r_x, int r_y, uint8_t* is_intra)
1947 {
1948     int xy, wrap, off = 0;
1949     int16_t *A, *B, *C;
1950     int px, py;
1951     int sum;
1952
1953     /* scale MV difference to be quad-pel */
1954     dmv_x <<= 1 - s->quarter_sample;
1955     dmv_y <<= 1 - s->quarter_sample;
1956
1957     wrap = s->b8_stride;
1958     xy = s->block_index[n];
1959
1960     if(s->mb_intra){
1961         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1962         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1963         if(mv1) { /* duplicate motion data for 1-MV block */
1964             s->current_picture.motion_val[0][xy + 1][0] = 0;
1965             s->current_picture.motion_val[0][xy + 1][1] = 0;
1966             s->current_picture.motion_val[0][xy + wrap][0] = 0;
1967             s->current_picture.motion_val[0][xy + wrap][1] = 0;
1968             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1969             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1970         }
1971         return;
1972     }
1973
1974     C = s->current_picture.motion_val[0][xy - 1];
1975     A = s->current_picture.motion_val[0][xy - wrap];
1976     if(mv1)
1977         off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1978     else {
1979         //in 4-MV mode different blocks have different B predictor position
1980         switch(n){
1981         case 0:
1982             off = (s->mb_x > 0) ? -1 : 1;
1983             break;
1984         case 1:
1985             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1986             break;
1987         case 2:
1988             off = 1;
1989             break;
1990         case 3:
1991             off = -1;
1992         }
1993     }
1994     B = s->current_picture.motion_val[0][xy - wrap + off];
1995
1996     if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
1997         if(s->mb_width == 1) {
1998             px = A[0];
1999             py = A[1];
2000         } else {
2001             px = mid_pred(A[0], B[0], C[0]);
2002             py = mid_pred(A[1], B[1], C[1]);
2003         }
2004     } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
2005         px = C[0];
2006         py = C[1];
2007     } else {
2008         px = py = 0;
2009     }
2010     /* Pullback MV as specified in 8.3.5.3.4 */
2011     {
2012         int qx, qy, X, Y;
2013         qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
2014         qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
2015         X = (s->mb_width << 6) - 4;
2016         Y = (s->mb_height << 6) - 4;
2017         if(mv1) {
2018             if(qx + px < -60) px = -60 - qx;
2019             if(qy + py < -60) py = -60 - qy;
2020         } else {
2021             if(qx + px < -28) px = -28 - qx;
2022             if(qy + py < -28) py = -28 - qy;
2023         }
2024         if(qx + px > X) px = X - qx;
2025         if(qy + py > Y) py = Y - qy;
2026     }
2027     /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2028     if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
2029         if(is_intra[xy - wrap])
2030             sum = FFABS(px) + FFABS(py);
2031         else
2032             sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2033         if(sum > 32) {
2034             if(get_bits1(&s->gb)) {
2035                 px = A[0];
2036                 py = A[1];
2037             } else {
2038                 px = C[0];
2039                 py = C[1];
2040             }
2041         } else {
2042             if(is_intra[xy - 1])
2043                 sum = FFABS(px) + FFABS(py);
2044             else
2045                 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2046             if(sum > 32) {
2047                 if(get_bits1(&s->gb)) {
2048                     px = A[0];
2049                     py = A[1];
2050                 } else {
2051                     px = C[0];
2052                     py = C[1];
2053                 }
2054             }
2055         }
2056     }
2057     /* store MV using signed modulus of MV range defined in 4.11 */
2058     s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
2059     s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
2060     if(mv1) { /* duplicate motion data for 1-MV block */
2061         s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
2062         s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
2063         s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
2064         s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
2065         s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
2066         s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
2067     }
2068 }
2069
2070 /** Motion compensation for direct or interpolated blocks in B-frames
2071  */
2072 static void vc1_interp_mc(VC1Context *v)
2073 {
2074     MpegEncContext *s = &v->s;
2075     DSPContext *dsp = &v->s.dsp;
2076     uint8_t *srcY, *srcU, *srcV;
2077     int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
2078
2079     if(!v->s.next_picture.data[0])return;
2080
2081     mx = s->mv[1][0][0];
2082     my = s->mv[1][0][1];
2083     uvmx = (mx + ((mx & 3) == 3)) >> 1;
2084     uvmy = (my + ((my & 3) == 3)) >> 1;
2085     if(v->fastuvmc) {
2086         uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
2087         uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
2088     }
2089     srcY = s->next_picture.data[0];
2090     srcU = s->next_picture.data[1];
2091     srcV = s->next_picture.data[2];
2092
2093     src_x = s->mb_x * 16 + (mx >> 2);
2094     src_y = s->mb_y * 16 + (my >> 2);
2095     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
2096     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
2097
2098     src_x   = clip(  src_x, -16, s->mb_width  * 16);
2099     src_y   = clip(  src_y, -16, s->mb_height * 16);
2100     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
2101     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
2102
2103     srcY += src_y * s->linesize + src_x;
2104     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
2105     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
2106
2107     /* for grayscale we should not try to read from unknown area */
2108     if(s->flags & CODEC_FLAG_GRAY) {
2109         srcU = s->edge_emu_buffer + 18 * s->linesize;
2110         srcV = s->edge_emu_buffer + 18 * s->linesize;
2111     }
2112
2113     if(v->rangeredfrm
2114        || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
2115        || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
2116         uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
2117
2118         srcY -= s->mspel * (1 + s->linesize);
2119         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
2120                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
2121         srcY = s->edge_emu_buffer;
2122         ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
2123                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2124         ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
2125                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2126         srcU = uvbuf;
2127         srcV = uvbuf + 16;
2128         /* if we deal with range reduction we need to scale source blocks */
2129         if(v->rangeredfrm) {
2130             int i, j;
2131             uint8_t *src, *src2;
2132
2133             src = srcY;
2134             for(j = 0; j < 17 + s->mspel*2; j++) {
2135                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
2136                 src += s->linesize;
2137             }
2138             src = srcU; src2 = srcV;
2139             for(j = 0; j < 9; j++) {
2140                 for(i = 0; i < 9; i++) {
2141                     src[i] = ((src[i] - 128) >> 1) + 128;
2142                     src2[i] = ((src2[i] - 128) >> 1) + 128;
2143                 }
2144                 src += s->uvlinesize;
2145                 src2 += s->uvlinesize;
2146             }
2147         }
2148         srcY += s->mspel * (1 + s->linesize);
2149     }
2150
2151     mx >>= 1;
2152     my >>= 1;
2153     dxy = ((my & 1) << 1) | (mx & 1);
2154
2155     dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
2156
2157     if(s->flags & CODEC_FLAG_GRAY) return;
2158     /* Chroma MC always uses qpel blilinear */
2159     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
2160     uvmx = (uvmx&3)<<1;
2161     uvmy = (uvmy&3)<<1;
2162     dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
2163     dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
2164 }
2165
2166 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2167 {
2168     int n = bfrac;
2169
2170 #if B_FRACTION_DEN==256
2171     if(inv)
2172         n -= 256;
2173     if(!qs)
2174         return 2 * ((value * n + 255) >> 9);
2175     return (value * n + 128) >> 8;
2176 #else
2177     if(inv)
2178         n -= B_FRACTION_DEN;
2179     if(!qs)
2180         return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2181     return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2182 #endif
2183 }
2184
2185 /** Reconstruct motion vector for B-frame and do motion compensation
2186  */
2187 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
2188 {
2189     if(v->use_ic) {
2190         v->mv_mode2 = v->mv_mode;
2191         v->mv_mode = MV_PMODE_INTENSITY_COMP;
2192     }
2193     if(direct) {
2194         vc1_mc_1mv(v, 0);
2195         vc1_interp_mc(v);
2196         if(v->use_ic) v->mv_mode = v->mv_mode2;
2197         return;
2198     }
2199     if(mode == BMV_TYPE_INTERPOLATED) {
2200         vc1_mc_1mv(v, 0);
2201         vc1_interp_mc(v);
2202         if(v->use_ic) v->mv_mode = v->mv_mode2;
2203         return;
2204     }
2205
2206     if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
2207     vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2208     if(v->use_ic) v->mv_mode = v->mv_mode2;
2209 }
2210
2211 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
2212 {
2213     MpegEncContext *s = &v->s;
2214     int xy, wrap, off = 0;
2215     int16_t *A, *B, *C;
2216     int px, py;
2217     int sum;
2218     int r_x, r_y;
2219     const uint8_t *is_intra = v->mb_type[0];
2220
2221     r_x = v->range_x;
2222     r_y = v->range_y;
2223     /* scale MV difference to be quad-pel */
2224     dmv_x[0] <<= 1 - s->quarter_sample;
2225     dmv_y[0] <<= 1 - s->quarter_sample;
2226     dmv_x[1] <<= 1 - s->quarter_sample;
2227     dmv_y[1] <<= 1 - s->quarter_sample;
2228
2229     wrap = s->b8_stride;
2230     xy = s->block_index[0];
2231
2232     if(s->mb_intra) {
2233         s->current_picture.motion_val[0][xy][0] =
2234         s->current_picture.motion_val[0][xy][1] =
2235         s->current_picture.motion_val[1][xy][0] =
2236         s->current_picture.motion_val[1][xy][1] = 0;
2237         return;
2238     }
2239     s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2240     s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2241     s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2242     s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2243     if(direct) {
2244         s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2245         s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2246         s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2247         s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2248         return;
2249     }
2250
2251     if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2252         C = s->current_picture.motion_val[0][xy - 2];
2253         A = s->current_picture.motion_val[0][xy - wrap*2];
2254         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2255         B = s->current_picture.motion_val[0][xy - wrap*2 + off];
2256
2257         if(!s->first_slice_line) { // predictor A is not out of bounds
2258             if(s->mb_width == 1) {
2259                 px = A[0];
2260                 py = A[1];
2261             } else {
2262                 px = mid_pred(A[0], B[0], C[0]);
2263                 py = mid_pred(A[1], B[1], C[1]);
2264             }
2265         } else if(s->mb_x) { // predictor C is not out of bounds
2266             px = C[0];
2267             py = C[1];
2268         } else {
2269             px = py = 0;
2270         }
2271         /* Pullback MV as specified in 8.3.5.3.4 */
2272         {
2273             int qx, qy, X, Y;
2274             if(v->profile < PROFILE_ADVANCED) {
2275                 qx = (s->mb_x << 5);
2276                 qy = (s->mb_y << 5);
2277                 X = (s->mb_width << 5) - 4;
2278                 Y = (s->mb_height << 5) - 4;
2279                 if(qx + px < -28) px = -28 - qx;
2280                 if(qy + py < -28) py = -28 - qy;
2281                 if(qx + px > X) px = X - qx;
2282                 if(qy + py > Y) py = Y - qy;
2283             } else {
2284                 qx = (s->mb_x << 6);
2285                 qy = (s->mb_y << 6);
2286                 X = (s->mb_width << 6) - 4;
2287                 Y = (s->mb_height << 6) - 4;
2288                 if(qx + px < -60) px = -60 - qx;
2289                 if(qy + py < -60) py = -60 - qy;
2290                 if(qx + px > X) px = X - qx;
2291                 if(qy + py > Y) py = Y - qy;
2292             }
2293         }
2294         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2295         if(0 && !s->first_slice_line && s->mb_x) {
2296             if(is_intra[xy - wrap])
2297                 sum = FFABS(px) + FFABS(py);
2298             else
2299                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2300             if(sum > 32) {
2301                 if(get_bits1(&s->gb)) {
2302                     px = A[0];
2303                     py = A[1];
2304                 } else {
2305                     px = C[0];
2306                     py = C[1];
2307                 }
2308             } else {
2309                 if(is_intra[xy - 2])
2310                     sum = FFABS(px) + FFABS(py);
2311                 else
2312                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2313                 if(sum > 32) {
2314                     if(get_bits1(&s->gb)) {
2315                         px = A[0];
2316                         py = A[1];
2317                     } else {
2318                         px = C[0];
2319                         py = C[1];
2320                     }
2321                 }
2322             }
2323         }
2324         /* store MV using signed modulus of MV range defined in 4.11 */
2325         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2326         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2327     }
2328     if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2329         C = s->current_picture.motion_val[1][xy - 2];
2330         A = s->current_picture.motion_val[1][xy - wrap*2];
2331         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2332         B = s->current_picture.motion_val[1][xy - wrap*2 + off];
2333
2334         if(!s->first_slice_line) { // predictor A is not out of bounds
2335             if(s->mb_width == 1) {
2336                 px = A[0];
2337                 py = A[1];
2338             } else {
2339                 px = mid_pred(A[0], B[0], C[0]);
2340                 py = mid_pred(A[1], B[1], C[1]);
2341             }
2342         } else if(s->mb_x) { // predictor C is not out of bounds
2343             px = C[0];
2344             py = C[1];
2345         } else {
2346             px = py = 0;
2347         }
2348         /* Pullback MV as specified in 8.3.5.3.4 */
2349         {
2350             int qx, qy, X, Y;
2351             if(v->profile < PROFILE_ADVANCED) {
2352                 qx = (s->mb_x << 5);
2353                 qy = (s->mb_y << 5);
2354                 X = (s->mb_width << 5) - 4;
2355                 Y = (s->mb_height << 5) - 4;
2356                 if(qx + px < -28) px = -28 - qx;
2357                 if(qy + py < -28) py = -28 - qy;
2358                 if(qx + px > X) px = X - qx;
2359                 if(qy + py > Y) py = Y - qy;
2360             } else {
2361                 qx = (s->mb_x << 6);
2362                 qy = (s->mb_y << 6);
2363                 X = (s->mb_width << 6) - 4;
2364                 Y = (s->mb_height << 6) - 4;
2365                 if(qx + px < -60) px = -60 - qx;
2366                 if(qy + py < -60) py = -60 - qy;
2367                 if(qx + px > X) px = X - qx;
2368                 if(qy + py > Y) py = Y - qy;
2369             }
2370         }
2371         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2372         if(0 && !s->first_slice_line && s->mb_x) {
2373             if(is_intra[xy - wrap])
2374                 sum = FFABS(px) + FFABS(py);
2375             else
2376                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2377             if(sum > 32) {
2378                 if(get_bits1(&s->gb)) {
2379                     px = A[0];
2380                     py = A[1];
2381                 } else {
2382                     px = C[0];
2383                     py = C[1];
2384                 }
2385             } else {
2386                 if(is_intra[xy - 2])
2387                     sum = FFABS(px) + FFABS(py);
2388                 else
2389                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2390                 if(sum > 32) {
2391                     if(get_bits1(&s->gb)) {
2392                         px = A[0];
2393                         py = A[1];
2394                     } else {
2395                         px = C[0];
2396                         py = C[1];
2397                     }
2398                 }
2399             }
2400         }
2401         /* store MV using signed modulus of MV range defined in 4.11 */
2402
2403         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2404         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2405     }
2406     s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2407     s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2408     s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2409     s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2410 }
2411
2412 /** Get predicted DC value for I-frames only
2413  * prediction dir: left=0, top=1
2414  * @param s MpegEncContext
2415  * @param[in] n block index in the current MB
2416  * @param dc_val_ptr Pointer to DC predictor
2417  * @param dir_ptr Prediction direction for use in AC prediction
2418  */
2419 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2420                               int16_t **dc_val_ptr, int *dir_ptr)
2421 {
2422     int a, b, c, wrap, pred, scale;
2423     int16_t *dc_val;
2424     static const uint16_t dcpred[32] = {
2425     -1, 1024,  512,  341,  256,  205,  171,  146,  128,
2426          114,  102,   93,   85,   79,   73,   68,   64,
2427           60,   57,   54,   51,   49,   47,   45,   43,
2428           41,   39,   38,   37,   35,   34,   33
2429     };
2430
2431     /* find prediction - wmv3_dc_scale always used here in fact */
2432     if (n < 4)     scale = s->y_dc_scale;
2433     else           scale = s->c_dc_scale;
2434
2435     wrap = s->block_wrap[n];
2436     dc_val= s->dc_val[0] + s->block_index[n];
2437
2438     /* B A
2439      * C X
2440      */
2441     c = dc_val[ - 1];
2442     b = dc_val[ - 1 - wrap];
2443     a = dc_val[ - wrap];
2444
2445     if (pq < 9 || !overlap)
2446     {
2447         /* Set outer values */
2448         if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
2449         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
2450     }
2451     else
2452     {
2453         /* Set outer values */
2454         if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
2455         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
2456     }
2457
2458     if (abs(a - b) <= abs(b - c)) {
2459         pred = c;
2460         *dir_ptr = 1;//left
2461     } else {
2462         pred = a;
2463         *dir_ptr = 0;//top
2464     }
2465
2466     /* update predictor */
2467     *dc_val_ptr = &dc_val[0];
2468     return pred;
2469 }
2470
2471
2472 /** Get predicted DC value
2473  * prediction dir: left=0, top=1
2474  * @param s MpegEncContext
2475  * @param[in] n block index in the current MB
2476  * @param dc_val_ptr Pointer to DC predictor
2477  * @param dir_ptr Prediction direction for use in AC prediction
2478  */
2479 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2480                               int a_avail, int c_avail,
2481                               int16_t **dc_val_ptr, int *dir_ptr)
2482 {
2483     int a, b, c, wrap, pred, scale;
2484     int16_t *dc_val;
2485     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2486     int q1, q2 = 0;
2487
2488     /* find prediction - wmv3_dc_scale always used here in fact */
2489     if (n < 4)     scale = s->y_dc_scale;
2490     else           scale = s->c_dc_scale;
2491
2492     wrap = s->block_wrap[n];
2493     dc_val= s->dc_val[0] + s->block_index[n];
2494
2495     /* B A
2496      * C X
2497      */
2498     c = dc_val[ - 1];
2499     b = dc_val[ - 1 - wrap];
2500     a = dc_val[ - wrap];
2501     /* scale predictors if needed */
2502     q1 = s->current_picture.qscale_table[mb_pos];
2503     if(c_avail && (n!= 1 && n!=3)) {
2504         q2 = s->current_picture.qscale_table[mb_pos - 1];
2505         if(q2 && q2 != q1)
2506             c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2507     }
2508     if(a_avail && (n!= 2 && n!=3)) {
2509         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2510         if(q2 && q2 != q1)
2511             a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2512     }
2513     if(a_avail && c_avail && (n!=3)) {
2514         int off = mb_pos;
2515         if(n != 1) off--;
2516         if(n != 2) off -= s->mb_stride;
2517         q2 = s->current_picture.qscale_table[off];
2518         if(q2 && q2 != q1)
2519             b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2520     }
2521
2522     if(a_avail && c_avail) {
2523         if(abs(a - b) <= abs(b - c)) {
2524             pred = c;
2525             *dir_ptr = 1;//left
2526         } else {
2527             pred = a;
2528             *dir_ptr = 0;//top
2529         }
2530     } else if(a_avail) {
2531         pred = a;
2532         *dir_ptr = 0;//top
2533     } else if(c_avail) {
2534         pred = c;
2535         *dir_ptr = 1;//left
2536     } else {
2537         pred = 0;
2538         *dir_ptr = 1;//left
2539     }
2540
2541     /* update predictor */
2542     *dc_val_ptr = &dc_val[0];
2543     return pred;
2544 }
2545
2546
2547 /**
2548  * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2549  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2550  * @{
2551  */
2552
2553 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
2554 {
2555     int xy, wrap, pred, a, b, c;
2556
2557     xy = s->block_index[n];
2558     wrap = s->b8_stride;
2559
2560     /* B C
2561      * A X
2562      */
2563     a = s->coded_block[xy - 1       ];
2564     b = s->coded_block[xy - 1 - wrap];
2565     c = s->coded_block[xy     - wrap];
2566
2567     if (b == c) {
2568         pred = a;
2569     } else {
2570         pred = c;
2571     }
2572
2573     /* store value */
2574     *coded_block_ptr = &s->coded_block[xy];
2575
2576     return pred;
2577 }
2578
2579 /**
2580  * Decode one AC coefficient
2581  * @param v The VC1 context
2582  * @param last Last coefficient
2583  * @param skip How much zero coefficients to skip
2584  * @param value Decoded AC coefficient value
2585  * @see 8.1.3.4
2586  */
2587 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
2588 {
2589     GetBitContext *gb = &v->s.gb;
2590     int index, escape, run = 0, level = 0, lst = 0;
2591
2592     index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2593     if (index != vc1_ac_sizes[codingset] - 1) {
2594         run = vc1_index_decode_table[codingset][index][0];
2595         level = vc1_index_decode_table[codingset][index][1];
2596         lst = index >= vc1_last_decode_table[codingset];
2597         if(get_bits(gb, 1))
2598             level = -level;
2599     } else {
2600         escape = decode210(gb);
2601         if (escape != 2) {
2602             index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2603             run = vc1_index_decode_table[codingset][index][0];
2604             level = vc1_index_decode_table[codingset][index][1];
2605             lst = index >= vc1_last_decode_table[codingset];
2606             if(escape == 0) {
2607                 if(lst)
2608                     level += vc1_last_delta_level_table[codingset][run];
2609                 else
2610                     level += vc1_delta_level_table[codingset][run];
2611             } else {
2612                 if(lst)
2613                     run += vc1_last_delta_run_table[codingset][level] + 1;
2614                 else
2615                     run += vc1_delta_run_table[codingset][level] + 1;
2616             }
2617             if(get_bits(gb, 1))
2618                 level = -level;
2619         } else {
2620             int sign;
2621             lst = get_bits(gb, 1);
2622             if(v->s.esc3_level_length == 0) {
2623                 if(v->pq < 8 || v->dquantfrm) { // table 59
2624                     v->s.esc3_level_length = get_bits(gb, 3);
2625                     if(!v->s.esc3_level_length)
2626                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
2627                 } else { //table 60
2628                     v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
2629                 }
2630                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2631             }
2632             run = get_bits(gb, v->s.esc3_run_length);
2633             sign = get_bits(gb, 1);
2634             level = get_bits(gb, v->s.esc3_level_length);
2635             if(sign)
2636                 level = -level;
2637         }
2638     }
2639
2640     *last = lst;
2641     *skip = run;
2642     *value = level;
2643 }
2644
2645 /** Decode intra block in intra frames - should be faster than decode_intra_block
2646  * @param v VC1Context
2647  * @param block block to decode
2648  * @param coded are AC coeffs present or not
2649  * @param codingset set of VLC to decode data
2650  */
2651 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
2652 {
2653     GetBitContext *gb = &v->s.gb;
2654     MpegEncContext *s = &v->s;
2655     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2656     int run_diff, i;
2657     int16_t *dc_val;
2658     int16_t *ac_val, *ac_val2;
2659     int dcdiff;
2660
2661     /* Get DC differential */
2662     if (n < 4) {
2663         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2664     } else {
2665         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2666     }
2667     if (dcdiff < 0){
2668         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2669         return -1;
2670     }
2671     if (dcdiff)
2672     {
2673         if (dcdiff == 119 /* ESC index value */)
2674         {
2675             /* TODO: Optimize */
2676             if (v->pq == 1) dcdiff = get_bits(gb, 10);
2677             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2678             else dcdiff = get_bits(gb, 8);
2679         }
2680         else
2681         {
2682             if (v->pq == 1)
2683                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2684             else if (v->pq == 2)
2685                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2686         }
2687         if (get_bits(gb, 1))
2688             dcdiff = -dcdiff;
2689     }
2690
2691     /* Prediction */
2692     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2693     *dc_val = dcdiff;
2694
2695     /* Store the quantized DC coeff, used for prediction */
2696     if (n < 4) {
2697         block[0] = dcdiff * s->y_dc_scale;
2698     } else {
2699         block[0] = dcdiff * s->c_dc_scale;
2700     }
2701     /* Skip ? */
2702     run_diff = 0;
2703     i = 0;
2704     if (!coded) {
2705         goto not_coded;
2706     }
2707
2708     //AC Decoding
2709     i = 1;
2710
2711     {
2712         int last = 0, skip, value;
2713         const int8_t *zz_table;
2714         int scale;
2715         int k;
2716
2717         scale = v->pq * 2 + v->halfpq;
2718
2719         if(v->s.ac_pred) {
2720             if(!dc_pred_dir)
2721                 zz_table = vc1_horizontal_zz;
2722             else
2723                 zz_table = vc1_vertical_zz;
2724         } else
2725             zz_table = vc1_normal_zz;
2726
2727         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2728         ac_val2 = ac_val;
2729         if(dc_pred_dir) //left
2730             ac_val -= 16;
2731         else //top
2732             ac_val -= 16 * s->block_wrap[n];
2733
2734         while (!last) {
2735             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2736             i += skip;
2737             if(i > 63)
2738                 break;
2739             block[zz_table[i++]] = value;
2740         }
2741
2742         /* apply AC prediction if needed */
2743         if(s->ac_pred) {
2744             if(dc_pred_dir) { //left
2745                 for(k = 1; k < 8; k++)
2746                     block[k << 3] += ac_val[k];
2747             } else { //top
2748                 for(k = 1; k < 8; k++)
2749                     block[k] += ac_val[k + 8];
2750             }
2751         }
2752         /* save AC coeffs for further prediction */
2753         for(k = 1; k < 8; k++) {
2754             ac_val2[k] = block[k << 3];
2755             ac_val2[k + 8] = block[k];
2756         }
2757
2758         /* scale AC coeffs */
2759         for(k = 1; k < 64; k++)
2760             if(block[k]) {
2761                 block[k] *= scale;
2762                 if(!v->pquantizer)
2763                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
2764             }
2765
2766         if(s->ac_pred) i = 63;
2767     }
2768
2769 not_coded:
2770     if(!coded) {
2771         int k, scale;
2772         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2773         ac_val2 = ac_val;
2774
2775         scale = v->pq * 2 + v->halfpq;
2776         memset(ac_val2, 0, 16 * 2);
2777         if(dc_pred_dir) {//left
2778             ac_val -= 16;
2779             if(s->ac_pred)
2780                 memcpy(ac_val2, ac_val, 8 * 2);
2781         } else {//top
2782             ac_val -= 16 * s->block_wrap[n];
2783             if(s->ac_pred)
2784                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2785         }
2786
2787         /* apply AC prediction if needed */
2788         if(s->ac_pred) {
2789             if(dc_pred_dir) { //left
2790                 for(k = 1; k < 8; k++) {
2791                     block[k << 3] = ac_val[k] * scale;
2792                     if(!v->pquantizer && block[k << 3])
2793                         block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2794                 }
2795             } else { //top
2796                 for(k = 1; k < 8; k++) {
2797                     block[k] = ac_val[k + 8] * scale;
2798                     if(!v->pquantizer && block[k])
2799                         block[k] += (block[k] < 0) ? -v->pq : v->pq;
2800                 }
2801             }
2802             i = 63;
2803         }
2804     }
2805     s->block_last_index[n] = i;
2806
2807     return 0;
2808 }
2809
2810 /** Decode intra block in intra frames - should be faster than decode_intra_block
2811  * @param v VC1Context
2812  * @param block block to decode
2813  * @param coded are AC coeffs present or not
2814  * @param codingset set of VLC to decode data
2815  */
2816 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
2817 {
2818     GetBitContext *gb = &v->s.gb;
2819     MpegEncContext *s = &v->s;
2820     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2821     int run_diff, i;
2822     int16_t *dc_val;
2823     int16_t *ac_val, *ac_val2;
2824     int dcdiff;
2825     int a_avail = v->a_avail, c_avail = v->c_avail;
2826     int use_pred = s->ac_pred;
2827     int scale;
2828     int q1, q2 = 0;
2829     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2830
2831     /* Get DC differential */
2832     if (n < 4) {
2833         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2834     } else {
2835         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2836     }
2837     if (dcdiff < 0){
2838         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2839         return -1;
2840     }
2841     if (dcdiff)
2842     {
2843         if (dcdiff == 119 /* ESC index value */)
2844         {
2845             /* TODO: Optimize */
2846             if (mquant == 1) dcdiff = get_bits(gb, 10);
2847             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2848             else dcdiff = get_bits(gb, 8);
2849         }
2850         else
2851         {
2852             if (mquant == 1)
2853                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2854             else if (mquant == 2)
2855                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2856         }
2857         if (get_bits(gb, 1))
2858             dcdiff = -dcdiff;
2859     }
2860
2861     /* Prediction */
2862     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2863     *dc_val = dcdiff;
2864
2865     /* Store the quantized DC coeff, used for prediction */
2866     if (n < 4) {
2867         block[0] = dcdiff * s->y_dc_scale;
2868     } else {
2869         block[0] = dcdiff * s->c_dc_scale;
2870     }
2871     /* Skip ? */
2872     run_diff = 0;
2873     i = 0;
2874
2875     //AC Decoding
2876     i = 1;
2877
2878     /* check if AC is needed at all and adjust direction if needed */
2879     if(!a_avail) dc_pred_dir = 1;
2880     if(!c_avail) dc_pred_dir = 0;
2881     if(!a_avail && !c_avail) use_pred = 0;
2882     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2883     ac_val2 = ac_val;
2884
2885     scale = mquant * 2 + v->halfpq;
2886
2887     if(dc_pred_dir) //left
2888         ac_val -= 16;
2889     else //top
2890         ac_val -= 16 * s->block_wrap[n];
2891
2892     q1 = s->current_picture.qscale_table[mb_pos];
2893     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
2894     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2895     if(n && n<4) q2 = q1;
2896
2897     if(coded) {
2898         int last = 0, skip, value;
2899         const int8_t *zz_table;
2900         int k;
2901
2902         if(v->s.ac_pred) {
2903             if(!dc_pred_dir)
2904                 zz_table = vc1_horizontal_zz;
2905             else
2906                 zz_table = vc1_vertical_zz;
2907         } else
2908             zz_table = vc1_normal_zz;
2909
2910         while (!last) {
2911             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2912             i += skip;
2913             if(i > 63)
2914                 break;
2915             block[zz_table[i++]] = value;
2916         }
2917
2918         /* apply AC prediction if needed */
2919         if(use_pred) {
2920             /* scale predictors if needed*/
2921             if(q2 && q1!=q2) {
2922                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2923                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2924
2925                 if(dc_pred_dir) { //left
2926                     for(k = 1; k < 8; k++)
2927                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2928                 } else { //top
2929                     for(k = 1; k < 8; k++)
2930                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2931                 }
2932             } else {
2933                 if(dc_pred_dir) { //left
2934                     for(k = 1; k < 8; k++)
2935                         block[k << 3] += ac_val[k];
2936                 } else { //top
2937                     for(k = 1; k < 8; k++)
2938                         block[k] += ac_val[k + 8];
2939                 }
2940             }
2941         }
2942         /* save AC coeffs for further prediction */
2943         for(k = 1; k < 8; k++) {
2944             ac_val2[k] = block[k << 3];
2945             ac_val2[k + 8] = block[k];
2946         }
2947
2948         /* scale AC coeffs */
2949         for(k = 1; k < 64; k++)
2950             if(block[k]) {
2951                 block[k] *= scale;
2952                 if(!v->pquantizer)
2953                     block[k] += (block[k] < 0) ? -mquant : mquant;
2954             }
2955
2956         if(use_pred) i = 63;
2957     } else { // no AC coeffs
2958         int k;
2959
2960         memset(ac_val2, 0, 16 * 2);
2961         if(dc_pred_dir) {//left
2962             if(use_pred) {
2963                 memcpy(ac_val2, ac_val, 8 * 2);
2964                 if(q2 && q1!=q2) {
2965                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2966                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2967                     for(k = 1; k < 8; k++)
2968                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2969                 }
2970             }
2971         } else {//top
2972             if(use_pred) {
2973                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2974                 if(q2 && q1!=q2) {
2975                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2976                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2977                     for(k = 1; k < 8; k++)
2978                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2979                 }
2980             }
2981         }
2982
2983         /* apply AC prediction if needed */
2984         if(use_pred) {
2985             if(dc_pred_dir) { //left
2986                 for(k = 1; k < 8; k++) {
2987                     block[k << 3] = ac_val2[k] * scale;
2988                     if(!v->pquantizer && block[k << 3])
2989                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2990                 }
2991             } else { //top
2992                 for(k = 1; k < 8; k++) {
2993                     block[k] = ac_val2[k + 8] * scale;
2994                     if(!v->pquantizer && block[k])
2995                         block[k] += (block[k] < 0) ? -mquant : mquant;
2996                 }
2997             }
2998             i = 63;
2999         }
3000     }
3001     s->block_last_index[n] = i;
3002
3003     return 0;
3004 }
3005
3006 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
3007  * @param v VC1Context
3008  * @param block block to decode
3009  * @param coded are AC coeffs present or not
3010  * @param mquant block quantizer
3011  * @param codingset set of VLC to decode data
3012  */
3013 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
3014 {
3015     GetBitContext *gb = &v->s.gb;
3016     MpegEncContext *s = &v->s;
3017     int dc_pred_dir = 0; /* Direction of the DC prediction used */
3018     int run_diff, i;
3019     int16_t *dc_val;
3020     int16_t *ac_val, *ac_val2;
3021     int dcdiff;
3022     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3023     int a_avail = v->a_avail, c_avail = v->c_avail;
3024     int use_pred = s->ac_pred;
3025     int scale;
3026     int q1, q2 = 0;
3027
3028     /* XXX: Guard against dumb values of mquant */
3029     mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
3030
3031     /* Set DC scale - y and c use the same */
3032     s->y_dc_scale = s->y_dc_scale_table[mquant];
3033     s->c_dc_scale = s->c_dc_scale_table[mquant];
3034
3035     /* Get DC differential */
3036     if (n < 4) {
3037         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3038     } else {
3039         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3040     }
3041     if (dcdiff < 0){
3042         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3043         return -1;
3044     }
3045     if (dcdiff)
3046     {
3047         if (dcdiff == 119 /* ESC index value */)
3048         {
3049             /* TODO: Optimize */
3050             if (mquant == 1) dcdiff = get_bits(gb, 10);
3051             else if (mquant == 2) dcdiff = get_bits(gb, 9);
3052             else dcdiff = get_bits(gb, 8);
3053         }
3054         else
3055         {
3056             if (mquant == 1)
3057                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
3058             else if (mquant == 2)
3059                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
3060         }
3061         if (get_bits(gb, 1))
3062             dcdiff = -dcdiff;
3063     }
3064
3065     /* Prediction */
3066     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3067     *dc_val = dcdiff;
3068
3069     /* Store the quantized DC coeff, used for prediction */
3070
3071     if (n < 4) {
3072         block[0] = dcdiff * s->y_dc_scale;
3073     } else {
3074         block[0] = dcdiff * s->c_dc_scale;
3075     }
3076     /* Skip ? */
3077     run_diff = 0;
3078     i = 0;
3079
3080     //AC Decoding
3081     i = 1;
3082
3083     /* check if AC is needed at all and adjust direction if needed */
3084     if(!a_avail) dc_pred_dir = 1;
3085     if(!c_avail) dc_pred_dir = 0;
3086     if(!a_avail && !c_avail) use_pred = 0;
3087     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3088     ac_val2 = ac_val;
3089
3090     scale = mquant * 2 + v->halfpq;
3091
3092     if(dc_pred_dir) //left
3093         ac_val -= 16;
3094     else //top
3095         ac_val -= 16 * s->block_wrap[n];
3096
3097     q1 = s->current_picture.qscale_table[mb_pos];
3098     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
3099     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3100     if(n && n<4) q2 = q1;
3101
3102     if(coded) {
3103         int last = 0, skip, value;
3104         const int8_t *zz_table;
3105         int k;
3106
3107         zz_table = vc1_simple_progressive_8x8_zz;
3108
3109         while (!last) {
3110             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3111             i += skip;
3112             if(i > 63)
3113                 break;
3114             block[zz_table[i++]] = value;
3115         }
3116
3117         /* apply AC prediction if needed */
3118         if(use_pred) {
3119             /* scale predictors if needed*/
3120             if(q2 && q1!=q2) {
3121                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3122                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3123
3124                 if(dc_pred_dir) { //left
3125                     for(k = 1; k < 8; k++)
3126                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3127                 } else { //top
3128                     for(k = 1; k < 8; k++)
3129                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3130                 }
3131             } else {
3132                 if(dc_pred_dir) { //left
3133                     for(k = 1; k < 8; k++)
3134                         block[k << 3] += ac_val[k];
3135                 } else { //top
3136                     for(k = 1; k < 8; k++)
3137                         block[k] += ac_val[k + 8];
3138                 }
3139             }
3140         }
3141         /* save AC coeffs for further prediction */
3142         for(k = 1; k < 8; k++) {
3143             ac_val2[k] = block[k << 3];
3144             ac_val2[k + 8] = block[k];
3145         }
3146
3147         /* scale AC coeffs */
3148         for(k = 1; k < 64; k++)
3149             if(block[k]) {
3150                 block[k] *= scale;
3151                 if(!v->pquantizer)
3152                     block[k] += (block[k] < 0) ? -mquant : mquant;
3153             }
3154
3155         if(use_pred) i = 63;
3156     } else { // no AC coeffs
3157         int k;
3158
3159         memset(ac_val2, 0, 16 * 2);
3160         if(dc_pred_dir) {//left
3161             if(use_pred) {
3162                 memcpy(ac_val2, ac_val, 8 * 2);
3163                 if(q2 && q1!=q2) {
3164                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3165                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3166                     for(k = 1; k < 8; k++)
3167                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3168                 }
3169             }
3170         } else {//top
3171             if(use_pred) {
3172                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3173                 if(q2 && q1!=q2) {
3174                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3175                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3176                     for(k = 1; k < 8; k++)
3177                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3178                 }
3179             }
3180         }
3181
3182         /* apply AC prediction if needed */
3183         if(use_pred) {
3184             if(dc_pred_dir) { //left
3185                 for(k = 1; k < 8; k++) {
3186                     block[k << 3] = ac_val2[k] * scale;
3187                     if(!v->pquantizer && block[k << 3])
3188                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3189                 }
3190             } else { //top
3191                 for(k = 1; k < 8; k++) {
3192                     block[k] = ac_val2[k + 8] * scale;
3193                     if(!v->pquantizer && block[k])
3194                         block[k] += (block[k] < 0) ? -mquant : mquant;
3195                 }
3196             }
3197             i = 63;
3198         }
3199     }
3200     s->block_last_index[n] = i;
3201
3202     return 0;
3203 }
3204
3205 /** Decode P block
3206  */
3207 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
3208 {
3209     MpegEncContext *s = &v->s;
3210     GetBitContext *gb = &s->gb;
3211     int i, j;
3212     int subblkpat = 0;
3213     int scale, off, idx, last, skip, value;
3214     int ttblk = ttmb & 7;
3215
3216     if(ttmb == -1) {
3217         ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
3218     }
3219     if(ttblk == TT_4X4) {
3220         subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3221     }
3222     if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
3223         subblkpat = decode012(gb);
3224         if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
3225         if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
3226         if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
3227     }
3228     scale = 2 * mquant + v->halfpq;
3229
3230     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3231     if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3232         subblkpat = 2 - (ttblk == TT_8X4_TOP);
3233         ttblk = TT_8X4;
3234     }
3235     if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3236         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3237         ttblk = TT_4X8;
3238     }
3239     switch(ttblk) {
3240     case TT_8X8:
3241         i = 0;
3242         last = 0;
3243         while (!last) {
3244             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3245             i += skip;
3246             if(i > 63)
3247                 break;
3248             idx = vc1_simple_progressive_8x8_zz[i++];
3249             block[idx] = value * scale;
3250             if(!v->pquantizer)
3251                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3252         }
3253         s->dsp.vc1_inv_trans_8x8(block);
3254         break;
3255     case TT_4X4:
3256         for(j = 0; j < 4; j++) {
3257             last = subblkpat & (1 << (3 - j));
3258             i = 0;
3259             off = (j & 1) * 4 + (j & 2) * 16;
3260             while (!last) {
3261                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3262                 i += skip;
3263                 if(i > 15)
3264                     break;
3265                 idx = vc1_simple_progressive_4x4_zz[i++];
3266                 block[idx + off] = value * scale;
3267                 if(!v->pquantizer)
3268                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3269             }
3270             if(!(subblkpat & (1 << (3 - j))))
3271                 s->dsp.vc1_inv_trans_4x4(block, j);
3272         }
3273         break;
3274     case TT_8X4:
3275         for(j = 0; j < 2; j++) {
3276             last = subblkpat & (1 << (1 - j));
3277             i = 0;
3278             off = j * 32;
3279             while (!last) {
3280                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3281                 i += skip;
3282                 if(i > 31)
3283                     break;
3284                 if(v->profile < PROFILE_ADVANCED)
3285                     idx = vc1_simple_progressive_8x4_zz[i++];
3286                 else
3287                     idx = vc1_adv_progressive_8x4_zz[i++];
3288                 block[idx + off] = value * scale;
3289                 if(!v->pquantizer)
3290                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3291             }
3292             if(!(subblkpat & (1 << (1 - j))))
3293                 s->dsp.vc1_inv_trans_8x4(block, j);
3294         }
3295         break;
3296     case TT_4X8:
3297         for(j = 0; j < 2; j++) {
3298             last = subblkpat & (1 << (1 - j));
3299             i = 0;
3300             off = j * 4;
3301             while (!last) {
3302                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3303                 i += skip;
3304                 if(i > 31)
3305                     break;
3306                 if(v->profile < PROFILE_ADVANCED)
3307                     idx = vc1_simple_progressive_4x8_zz[i++];
3308                 else
3309                     idx = vc1_adv_progressive_4x8_zz[i++];
3310                 block[idx + off] = value * scale;
3311                 if(!v->pquantizer)
3312                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3313             }
3314             if(!(subblkpat & (1 << (1 - j))))
3315                 s->dsp.vc1_inv_trans_4x8(block, j);
3316         }
3317         break;
3318     }
3319     return 0;
3320 }
3321
3322
3323 /** Decode one P-frame MB (in Simple/Main profile)
3324  */
3325 static int vc1_decode_p_mb(VC1Context *v)
3326 {
3327     MpegEncContext *s = &v->s;
3328     GetBitContext *gb = &s->gb;
3329     int i, j;
3330     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3331     int cbp; /* cbp decoding stuff */
3332     int mqdiff, mquant; /* MB quantization */
3333     int ttmb = v->ttfrm; /* MB Transform type */
3334     int status;
3335
3336     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3337       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3338     int mb_has_coeffs = 1; /* last_flag */
3339     int dmv_x, dmv_y; /* Differential MV components */
3340     int index, index1; /* LUT indices */
3341     int val, sign; /* temp values */
3342     int first_block = 1;
3343     int dst_idx, off;
3344     int skipped, fourmv;
3345
3346     mquant = v->pq; /* Loosy initialization */
3347
3348     if (v->mv_type_is_raw)
3349         fourmv = get_bits1(gb);
3350     else
3351         fourmv = v->mv_type_mb_plane[mb_pos];
3352     if (v->skip_is_raw)
3353         skipped = get_bits1(gb);
3354     else
3355         skipped = v->s.mbskip_table[mb_pos];
3356
3357     s->dsp.clear_blocks(s->block[0]);
3358
3359     if (!fourmv) /* 1MV mode */
3360     {
3361         if (!skipped)
3362         {
3363             GET_MVDATA(dmv_x, dmv_y);
3364
3365             if (s->mb_intra) {
3366                 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3367                 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3368             }
3369             s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3370             vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3371
3372             /* FIXME Set DC val for inter block ? */
3373             if (s->mb_intra && !mb_has_coeffs)
3374             {
3375                 GET_MQUANT();
3376                 s->ac_pred = get_bits(gb, 1);
3377                 cbp = 0;
3378             }
3379             else if (mb_has_coeffs)
3380             {
3381                 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
3382                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3383                 GET_MQUANT();
3384             }
3385             else
3386             {
3387                 mquant = v->pq;
3388                 cbp = 0;
3389             }
3390             s->current_picture.qscale_table[mb_pos] = mquant;
3391
3392             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3393                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
3394                                 VC1_TTMB_VLC_BITS, 2);
3395             if(!s->mb_intra) vc1_mc_1mv(v, 0);
3396             dst_idx = 0;
3397             for (i=0; i<6; i++)
3398             {
3399                 s->dc_val[0][s->block_index[i]] = 0;
3400                 dst_idx += i >> 2;
3401                 val = ((cbp >> (5 - i)) & 1);
3402                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3403                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3404                 if(s->mb_intra) {
3405                     /* check if prediction blocks A and C are available */
3406                     v->a_avail = v->c_avail = 0;
3407                     if(i == 2 || i == 3 || !s->first_slice_line)
3408                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3409                     if(i == 1 || i == 3 || s->mb_x)
3410                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3411
3412                     vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3413                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3414                     s->dsp.vc1_inv_trans_8x8(s->block[i]);
3415                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3416                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
3417                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3418                     if(v->pq >= 9 && v->overlap) {
3419                         if(v->c_avail)
3420                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3421                         if(v->a_avail)
3422                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3423                     }
3424                 } else if(val) {
3425                     vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3426                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
3427                     first_block = 0;
3428                     if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3429                         s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3430                 }
3431             }
3432         }
3433         else //Skipped
3434         {
3435             s->mb_intra = 0;
3436             for(i = 0; i < 6; i++) {
3437                 v->mb_type[0][s->block_index[i]] = 0;
3438                 s->dc_val[0][s->block_index[i]] = 0;
3439             }
3440             s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3441             s->current_picture.qscale_table[mb_pos] = 0;
3442             vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3443             vc1_mc_1mv(v, 0);
3444             return 0;
3445         }
3446     } //1MV mode
3447     else //4MV mode
3448     {
3449         if (!skipped /* unskipped MB */)
3450         {
3451             int intra_count = 0, coded_inter = 0;
3452             int is_intra[6], is_coded[6];
3453             /* Get CBPCY */
3454             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3455             for (i=0; i<6; i++)
3456             {
3457                 val = ((cbp >> (5 - i)) & 1);
3458                 s->dc_val[0][s->block_index[i]] = 0;
3459                 s->mb_intra = 0;
3460                 if(i < 4) {
3461                     dmv_x = dmv_y = 0;
3462                     s->mb_intra = 0;
3463                     mb_has_coeffs = 0;
3464                     if(val) {
3465                         GET_MVDATA(dmv_x, dmv_y);
3466                     }
3467                     vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3468                     if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
3469                     intra_count += s->mb_intra;
3470                     is_intra[i] = s->mb_intra;
3471                     is_coded[i] = mb_has_coeffs;
3472                 }
3473                 if(i&4){
3474                     is_intra[i] = (intra_count >= 3);
3475                     is_coded[i] = val;
3476                 }
3477                 if(i == 4) vc1_mc_4mv_chroma(v);
3478                 v->mb_type[0][s->block_index[i]] = is_intra[i];
3479                 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
3480             }
3481             // if there are no coded blocks then don't do anything more
3482             if(!intra_count && !coded_inter) return 0;
3483             dst_idx = 0;
3484             GET_MQUANT();
3485             s->current_picture.qscale_table[mb_pos] = mquant;
3486             /* test if block is intra and has pred */
3487             {
3488                 int intrapred = 0;
3489                 for(i=0; i<6; i++)
3490                     if(is_intra[i]) {
3491                         if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3492                             || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
3493                             intrapred = 1;
3494                             break;
3495                         }
3496                     }
3497                 if(intrapred)s->ac_pred = get_bits(gb, 1);
3498                 else s->ac_pred = 0;
3499             }
3500             if (!v->ttmbf && coded_inter)
3501                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3502             for (i=0; i<6; i++)
3503             {
3504                 dst_idx += i >> 2;
3505                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3506                 s->mb_intra = is_intra[i];
3507                 if (is_intra[i]) {
3508                     /* check if prediction blocks A and C are available */
3509                     v->a_avail = v->c_avail = 0;
3510                     if(i == 2 || i == 3 || !s->first_slice_line)
3511                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3512                     if(i == 1 || i == 3 || s->mb_x)
3513                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3514
3515                     vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
3516                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3517                     s->dsp.vc1_inv_trans_8x8(s->block[i]);
3518                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3519                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
3520                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3521                     if(v->pq >= 9 && v->overlap) {
3522                         if(v->c_avail)
3523                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3524                         if(v->a_avail)
3525                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3526                     }
3527                 } else if(is_coded[i]) {
3528                     status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3529                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
3530                     first_block = 0;
3531                     if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3532                         s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3533                 }
3534             }
3535             return status;
3536         }
3537         else //Skipped MB
3538         {
3539             s->mb_intra = 0;
3540             s->current_picture.qscale_table[mb_pos] = 0;
3541             for (i=0; i<6; i++) {
3542                 v->mb_type[0][s->block_index[i]] = 0;
3543                 s->dc_val[0][s->block_index[i]] = 0;
3544             }
3545             for (i=0; i<4; i++)
3546             {
3547                 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
3548                 vc1_mc_4mv_luma(v, i);
3549             }
3550             vc1_mc_4mv_chroma(v);
3551             s->current_picture.qscale_table[mb_pos] = 0;
3552             return 0;
3553         }
3554     }
3555
3556     /* Should never happen */
3557     return -1;
3558 }
3559
3560 /** Decode one B-frame MB (in Main profile)
3561  */
3562 static void vc1_decode_b_mb(VC1Context *v)
3563 {
3564     MpegEncContext *s = &v->s;
3565     GetBitContext *gb = &s->gb;
3566     int i, j;
3567     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3568     int cbp = 0; /* cbp decoding stuff */
3569     int mqdiff, mquant; /* MB quantization */
3570     int ttmb = v->ttfrm; /* MB Transform type */
3571
3572     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3573       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3574     int mb_has_coeffs = 0; /* last_flag */
3575     int index, index1; /* LUT indices */
3576     int val, sign; /* temp values */
3577     int first_block = 1;
3578     int dst_idx, off;
3579     int skipped, direct;
3580     int dmv_x[2], dmv_y[2];
3581     int bmvtype = BMV_TYPE_BACKWARD;
3582
3583     mquant = v->pq; /* Loosy initialization */
3584     s->mb_intra = 0;
3585
3586     if (v->dmb_is_raw)
3587         direct = get_bits1(gb);
3588     else
3589         direct = v->direct_mb_plane[mb_pos];
3590     if (v->skip_is_raw)
3591         skipped = get_bits1(gb);
3592     else
3593         skipped = v->s.mbskip_table[mb_pos];
3594
3595     s->dsp.clear_blocks(s->block[0]);
3596     dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
3597     for(i = 0; i < 6; i++) {
3598         v->mb_type[0][s->block_index[i]] = 0;
3599         s->dc_val[0][s->block_index[i]] = 0;
3600     }
3601     s->current_picture.qscale_table[mb_pos] = 0;
3602
3603     if (!direct) {
3604         if (!skipped) {
3605             GET_MVDATA(dmv_x[0], dmv_y[0]);
3606             dmv_x[1] = dmv_x[0];
3607             dmv_y[1] = dmv_y[0];
3608         }
3609         if(skipped || !s->mb_intra) {
3610             bmvtype = decode012(gb);
3611             switch(bmvtype) {
3612             case 0:
3613                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
3614                 break;
3615             case 1:
3616                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
3617                 break;
3618             case 2:
3619                 bmvtype = BMV_TYPE_INTERPOLATED;
3620                 dmv_x[0] = dmv_y[0] = 0;
3621             }
3622         }
3623     }
3624     for(i = 0; i < 6; i++)
3625         v->mb_type[0][s->block_index[i]] = s->mb_intra;
3626
3627     if (skipped) {
3628         if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
3629         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3630         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3631         return;
3632     }
3633     if (direct) {
3634         cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3635         GET_MQUANT();
3636         s->mb_intra = 0;
3637         mb_has_coeffs = 0;
3638         s->current_picture.qscale_table[mb_pos] = mquant;
3639         if(!v->ttmbf)
3640             ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3641         dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
3642         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3643         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3644     } else {
3645         if(!mb_has_coeffs && !s->mb_intra) {
3646             /* no coded blocks - effectively skipped */
3647             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3648             vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3649             return;
3650         }
3651         if(s->mb_intra && !mb_has_coeffs) {
3652             GET_MQUANT();
3653             s->current_picture.qscale_table[mb_pos] = mquant;
3654             s->ac_pred = get_bits1(gb);
3655             cbp = 0;
3656             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3657         } else {
3658             if(bmvtype == BMV_TYPE_INTERPOLATED) {
3659                 GET_MVDATA(dmv_x[0], dmv_y[0]);
3660                 if(!mb_has_coeffs) {
3661                     /* interpolated skipped block */
3662                     vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3663                     vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3664                     return;
3665                 }
3666             }
3667             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3668             if(!s->mb_intra) {
3669                 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3670             }
3671             if(s->mb_intra)
3672                 s->ac_pred = get_bits1(gb);
3673             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3674             GET_MQUANT();
3675             s->current_picture.qscale_table[mb_pos] = mquant;
3676             if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3677                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3678         }
3679     }
3680     dst_idx = 0;
3681     for (i=0; i<6; i++)
3682     {
3683         s->dc_val[0][s->block_index[i]] = 0;
3684         dst_idx += i >> 2;
3685         val = ((cbp >> (5 - i)) & 1);
3686         off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3687         v->mb_type[0][s->block_index[i]] = s->mb_intra;
3688         if(s->mb_intra) {
3689             /* check if prediction blocks A and C are available */
3690             v->a_avail = v->c_avail = 0;
3691             if(i == 2 || i == 3 || !s->first_slice_line)
3692                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3693             if(i == 1 || i == 3 || s->mb_x)
3694                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3695
3696             vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3697             if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3698             s->dsp.vc1_inv_trans_8x8(s->block[i]);
3699             if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3700             for(j = 0; j < 64; j++) s->block[i][j] += 128;
3701             s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3702         } else if(val) {
3703             vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3704             if(!v->ttmbf && ttmb < 8) ttmb = -1;
3705             first_block = 0;
3706             if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3707                 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3708         }
3709     }
3710 }
3711
3712 /** Decode blocks of I-frame
3713  */
3714 static void vc1_decode_i_blocks(VC1Context *v)
3715 {
3716     int k, j;
3717     MpegEncContext *s = &v->s;
3718     int cbp, val;
3719     uint8_t *coded_val;
3720     int mb_pos;
3721
3722     /* select codingmode used for VLC tables selection */
3723     switch(v->y_ac_table_index){
3724     case 0:
3725         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3726         break;
3727     case 1:
3728         v->codingset = CS_HIGH_MOT_INTRA;
3729         break;
3730     case 2:
3731         v->codingset = CS_MID_RATE_INTRA;
3732         break;
3733     }
3734
3735     switch(v->c_ac_table_index){
3736     case 0:
3737         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3738         break;
3739     case 1:
3740         v->codingset2 = CS_HIGH_MOT_INTER;
3741         break;
3742     case 2:
3743         v->codingset2 = CS_MID_RATE_INTER;
3744         break;
3745     }
3746
3747     /* Set DC scale - y and c use the same */
3748     s->y_dc_scale = s->y_dc_scale_table[v->pq];
3749     s->c_dc_scale = s->c_dc_scale_table[v->pq];
3750
3751     //do frame decode
3752     s->mb_x = s->mb_y = 0;
3753     s->mb_intra = 1;
3754     s->first_slice_line = 1;
3755     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3756     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3757         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3758             ff_init_block_index(s);
3759             ff_update_block_index(s);
3760             s->dsp.clear_blocks(s->block[0]);
3761             mb_pos = s->mb_x + s->mb_y * s->mb_width;
3762             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3763             s->current_picture.qscale_table[mb_pos] = v->pq;
3764             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3765             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3766
3767             // do actual MB decoding and displaying
3768             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3769             v->s.ac_pred = get_bits(&v->s.gb, 1);
3770
3771             for(k = 0; k < 6; k++) {
3772                 val = ((cbp >> (5 - k)) & 1);
3773
3774                 if (k < 4) {
3775                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3776                     val = val ^ pred;
3777                     *coded_val = val;
3778                 }
3779                 cbp |= val << (5 - k);
3780
3781                 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
3782
3783                 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3784                 if(v->pq >= 9 && v->overlap) {
3785                     for(j = 0; j < 64; j++) s->block[k][j] += 128;
3786                 }
3787             }
3788
3789             vc1_put_block(v, s->block);
3790             if(v->pq >= 9 && v->overlap) {
3791                 if(s->mb_x) {
3792                     s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3793                     s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3794                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3795                         s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3796                         s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3797                     }
3798                 }
3799                 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3800                 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3801                 if(!s->first_slice_line) {
3802                     s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3803                     s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3804                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3805                         s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3806                         s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3807                     }
3808                 }
3809                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3810                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3811             }
3812
3813             if(get_bits_count(&s->gb) > v->bits) {
3814                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3815                 return;
3816             }
3817         }
3818         ff_draw_horiz_band(s, s->mb_y * 16, 16);
3819         s->first_slice_line = 0;
3820     }
3821 }
3822
3823 /** Decode blocks of I-frame for advanced profile
3824  */
3825 static void vc1_decode_i_blocks_adv(VC1Context *v)
3826 {
3827     int k, j;
3828     MpegEncContext *s = &v->s;
3829     int cbp, val;
3830     uint8_t *coded_val;
3831     int mb_pos;
3832     int mquant = v->pq;
3833     int mqdiff;
3834     int overlap;
3835     GetBitContext *gb = &s->gb;
3836
3837     /* select codingmode used for VLC tables selection */
3838     switch(v->y_ac_table_index){
3839     case 0:
3840         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3841         break;
3842     case 1:
3843         v->codingset = CS_HIGH_MOT_INTRA;
3844         break;
3845     case 2:
3846         v->codingset = CS_MID_RATE_INTRA;
3847         break;
3848     }
3849
3850     switch(v->c_ac_table_index){
3851     case 0:
3852         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3853         break;
3854     case 1:
3855         v->codingset2 = CS_HIGH_MOT_INTER;
3856         break;
3857     case 2:
3858         v->codingset2 = CS_MID_RATE_INTER;
3859         break;
3860     }
3861
3862     //do frame decode
3863     s->mb_x = s->mb_y = 0;
3864     s->mb_intra = 1;
3865     s->first_slice_line = 1;
3866     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3867     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3868         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3869             ff_init_block_index(s);
3870             ff_update_block_index(s);
3871             s->dsp.clear_blocks(s->block[0]);
3872             mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3873             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3874             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3875             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3876
3877             // do actual MB decoding and displaying
3878             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3879             if(v->acpred_is_raw)
3880                 v->s.ac_pred = get_bits(&v->s.gb, 1);
3881             else
3882                 v->s.ac_pred = v->acpred_plane[mb_pos];
3883
3884             if(v->condover == CONDOVER_SELECT) {
3885                 if(v->overflg_is_raw)
3886                     overlap = get_bits(&v->s.gb, 1);
3887                 else
3888                     overlap = v->over_flags_plane[mb_pos];
3889             } else
3890                 overlap = (v->condover == CONDOVER_ALL);
3891
3892             GET_MQUANT();
3893
3894             s->current_picture.qscale_table[mb_pos] = mquant;
3895             /* Set DC scale - y and c use the same */
3896             s->y_dc_scale = s->y_dc_scale_table[mquant];
3897             s->c_dc_scale = s->c_dc_scale_table[mquant];
3898
3899             for(k = 0; k < 6; k++) {
3900                 val = ((cbp >> (5 - k)) & 1);
3901
3902                 if (k < 4) {
3903                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3904                     val = val ^ pred;
3905                     *coded_val = val;
3906                 }
3907                 cbp |= val << (5 - k);
3908
3909                 v->a_avail = !s->first_slice_line || (k==2 || k==3);
3910                 v->c_avail = !!s->mb_x || (k==1 || k==3);
3911
3912                 vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
3913
3914                 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3915                 for(j = 0; j < 64; j++) s->block[k][j] += 128;
3916             }
3917
3918             vc1_put_block(v, s->block);
3919             if(overlap) {
3920                 if(s->mb_x) {
3921                     s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3922                     s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3923                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3924                         s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3925                         s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3926                     }
3927                 }
3928                 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3929                 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3930                 if(!s->first_slice_line) {
3931                     s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3932                     s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3933                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3934                         s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3935                         s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3936                     }
3937                 }
3938                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3939                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3940             }
3941
3942             if(get_bits_count(&s->gb) > v->bits) {
3943                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3944                 return;
3945             }
3946         }
3947         ff_draw_horiz_band(s, s->mb_y * 16, 16);
3948         s->first_slice_line = 0;
3949     }
3950 }
3951
3952 static void vc1_decode_p_blocks(VC1Context *v)
3953 {
3954     MpegEncContext *s = &v->s;
3955
3956     /* select codingmode used for VLC tables selection */
3957     switch(v->c_ac_table_index){
3958     case 0:
3959         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3960         break;
3961     case 1:
3962         v->codingset = CS_HIGH_MOT_INTRA;
3963         break;
3964     case 2:
3965         v->codingset = CS_MID_RATE_INTRA;
3966         break;
3967     }
3968
3969     switch(v->c_ac_table_index){
3970     case 0:
3971         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3972         break;
3973     case 1:
3974         v->codingset2 = CS_HIGH_MOT_INTER;
3975         break;
3976     case 2:
3977         v->codingset2 = CS_MID_RATE_INTER;
3978         break;
3979     }
3980
3981     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3982     s->first_slice_line = 1;
3983     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3984         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3985             ff_init_block_index(s);
3986             ff_update_block_index(s);
3987             s->dsp.clear_blocks(s->block[0]);
3988
3989             vc1_decode_p_mb(v);
3990             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
3991                 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);
3992                 return;
3993             }
3994         }
3995         ff_draw_horiz_band(s, s->mb_y * 16, 16);
3996         s->first_slice_line = 0;
3997     }
3998 }
3999
4000 static void vc1_decode_b_blocks(VC1Context *v)
4001 {
4002     MpegEncContext *s = &v->s;
4003
4004     /* select codingmode used for VLC tables selection */
4005     switch(v->c_ac_table_index){
4006     case 0:
4007         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4008         break;
4009     case 1:
4010         v->codingset = CS_HIGH_MOT_INTRA;
4011         break;
4012     case 2:
4013         v->codingset = CS_MID_RATE_INTRA;
4014         break;
4015     }
4016
4017     switch(v->c_ac_table_index){
4018     case 0:
4019         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4020         break;
4021     case 1:
4022         v->codingset2 = CS_HIGH_MOT_INTER;
4023         break;
4024     case 2:
4025         v->codingset2 = CS_MID_RATE_INTER;
4026         break;
4027     }
4028
4029     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4030     s->first_slice_line = 1;
4031     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4032         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
4033             ff_init_block_index(s);
4034             ff_update_block_index(s);
4035             s->dsp.clear_blocks(s->block[0]);
4036
4037             vc1_decode_b_mb(v);
4038             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4039                 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);
4040                 return;
4041             }
4042         }
4043         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4044         s->first_slice_line = 0;
4045     }
4046 }
4047
4048 static void vc1_decode_skip_blocks(VC1Context *v)
4049 {
4050     MpegEncContext *s = &v->s;
4051
4052     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4053     s->first_slice_line = 1;
4054     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4055         s->mb_x = 0;
4056         ff_init_block_index(s);
4057         ff_update_block_index(s);
4058         memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4059         memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4060         memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4061         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4062         s->first_slice_line = 0;
4063     }
4064     s->pict_type = P_TYPE;
4065 }
4066
4067 static void vc1_decode_blocks(VC1Context *v)
4068 {
4069
4070     v->s.esc3_level_length = 0;
4071
4072     switch(v->s.pict_type) {
4073     case I_TYPE:
4074         if(v->profile == PROFILE_ADVANCED)
4075             vc1_decode_i_blocks_adv(v);
4076         else
4077             vc1_decode_i_blocks(v);
4078         break;
4079     case P_TYPE:
4080         if(v->p_frame_skipped)
4081             vc1_decode_skip_blocks(v);
4082         else
4083             vc1_decode_p_blocks(v);
4084         break;
4085     case B_TYPE:
4086         if(v->bi_type){
4087             if(v->profile == PROFILE_ADVANCED)
4088                 vc1_decode_i_blocks_adv(v);
4089             else
4090                 vc1_decode_i_blocks(v);
4091         }else
4092             vc1_decode_b_blocks(v);
4093         break;
4094     }
4095 }
4096
4097
4098 /** Initialize a VC1/WMV3 decoder
4099  * @todo TODO: Handle VC-1 IDUs (Transport level?)
4100  * @todo TODO: Decypher remaining bits in extra_data
4101  */
4102 static int vc1_decode_init(AVCodecContext *avctx)
4103 {
4104     VC1Context *v = avctx->priv_data;
4105     MpegEncContext *s = &v->s;
4106     GetBitContext gb;
4107
4108     if (!avctx->extradata_size || !avctx->extradata) return -1;
4109     if (!(avctx->flags & CODEC_FLAG_GRAY))
4110         avctx->pix_fmt = PIX_FMT_YUV420P;
4111     else
4112         avctx->pix_fmt = PIX_FMT_GRAY8;
4113     v->s.avctx = avctx;
4114     avctx->flags |= CODEC_FLAG_EMU_EDGE;
4115     v->s.flags |= CODEC_FLAG_EMU_EDGE;
4116
4117     if(ff_h263_decode_init(avctx) < 0)
4118         return -1;
4119     if (vc1_init_common(v) < 0) return -1;
4120
4121     avctx->coded_width = avctx->width;
4122     avctx->coded_height = avctx->height;
4123     if (avctx->codec_id == CODEC_ID_WMV3)
4124     {
4125         int count = 0;
4126
4127         // looks like WMV3 has a sequence header stored in the extradata
4128         // advanced sequence header may be before the first frame
4129         // the last byte of the extradata is a version number, 1 for the
4130         // samples we can decode
4131
4132         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
4133
4134         if (decode_sequence_header(avctx, &gb) < 0)
4135           return -1;
4136
4137         count = avctx->extradata_size*8 - get_bits_count(&gb);
4138         if (count>0)
4139         {
4140             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
4141                    count, get_bits(&gb, count));
4142         }
4143         else if (count < 0)
4144         {
4145             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
4146         }
4147     } else { // VC1/WVC1
4148         int edata_size = avctx->extradata_size;
4149         uint8_t *edata = avctx->extradata;
4150
4151         if(avctx->extradata_size < 16) {
4152             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", edata_size);
4153             return -1;