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