B-frames could not be determined from broken_link/closed_entry, use fixed value
[ffmpeg.git] / libavcodec / vc1.c
1 /*
2  * VC-1 and WMV3 decoder
3  * Copyright (c) 2006 Konstantin Shishkov
4  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  *
22  */
23
24 /**
25  * @file vc1.c
26  * VC-1 and WMV3 decoder
27  *
28  */
29 #include "common.h"
30 #include "dsputil.h"
31 #include "avcodec.h"
32 #include "mpegvideo.h"
33 #include "vc1data.h"
34 #include "vc1acdata.h"
35
36 #undef NDEBUG
37 #include <assert.h>
38
39 extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];
40 extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];
41 extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];
42 #define MB_INTRA_VLC_BITS 9
43 extern VLC ff_msmp4_mb_i_vlc;
44 extern const uint16_t ff_msmp4_mb_i_table[64][2];
45 #define DC_VLC_BITS 9
46 #define AC_VLC_BITS 9
47 static const uint16_t table_mb_intra[64][2];
48
49 /** 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   = clip(  src_x, -16, s->mb_width  * 16);
825     src_y   = clip(  src_y, -16, s->mb_height * 16);
826     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
827     uvsrc_y = 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   = clip(  src_x, -16, s->mb_width  * 16);
948     src_y   = 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 = clip(uvsrc_x,  -8, s->mb_width  *  8);
1075     uvsrc_y = 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 == 2)
1149     {
1150         av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1151         return -1;
1152     }
1153
1154     if (v->profile == PROFILE_ADVANCED)
1155     {
1156         return decode_sequence_header_adv(v, gb);
1157     }
1158     else
1159     {
1160         v->res_sm = get_bits(gb, 2); //reserved
1161         if (v->res_sm)
1162         {
1163             av_log(avctx, AV_LOG_ERROR,
1164                    "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1165             return -1;
1166         }
1167     }
1168
1169     // (fps-2)/4 (->30)
1170     v->frmrtq_postproc = get_bits(gb, 3); //common
1171     // (bitrate-32kbps)/64kbps
1172     v->bitrtq_postproc = get_bits(gb, 5); //common
1173     v->s.loop_filter = get_bits(gb, 1); //common
1174     if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1175     {
1176         av_log(avctx, AV_LOG_ERROR,
1177                "LOOPFILTER shell not be enabled in simple profile\n");
1178     }
1179
1180     v->res_x8 = get_bits(gb, 1); //reserved
1181     if (v->res_x8)
1182     {
1183         av_log(avctx, AV_LOG_ERROR,
1184                "1 for reserved RES_X8 is forbidden\n");
1185         //return -1;
1186     }
1187     v->multires = get_bits(gb, 1);
1188     v->res_fasttx = get_bits(gb, 1);
1189     if (!v->res_fasttx)
1190     {
1191         av_log(avctx, AV_LOG_ERROR,
1192                "0 for reserved RES_FASTTX is forbidden\n");
1193         //return -1;
1194     }
1195
1196     v->fastuvmc =  get_bits(gb, 1); //common
1197     if (!v->profile && !v->fastuvmc)
1198     {
1199         av_log(avctx, AV_LOG_ERROR,
1200                "FASTUVMC unavailable in Simple Profile\n");
1201         return -1;
1202     }
1203     v->extended_mv =  get_bits(gb, 1); //common
1204     if (!v->profile && v->extended_mv)
1205     {
1206         av_log(avctx, AV_LOG_ERROR,
1207                "Extended MVs unavailable in Simple Profile\n");
1208         return -1;
1209     }
1210     v->dquant =  get_bits(gb, 2); //common
1211     v->vstransform =  get_bits(gb, 1); //common
1212
1213     v->res_transtab = get_bits(gb, 1);
1214     if (v->res_transtab)
1215     {
1216         av_log(avctx, AV_LOG_ERROR,
1217                "1 for reserved RES_TRANSTAB is forbidden\n");
1218         return -1;
1219     }
1220
1221     v->overlap = get_bits(gb, 1); //common
1222
1223     v->s.resync_marker = get_bits(gb, 1);
1224     v->rangered = get_bits(gb, 1);
1225     if (v->rangered && v->profile == PROFILE_SIMPLE)
1226     {
1227         av_log(avctx, AV_LOG_INFO,
1228                "RANGERED should be set to 0 in simple profile\n");
1229     }
1230
1231     v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1232     v->quantizer_mode = get_bits(gb, 2); //common
1233
1234     v->finterpflag = get_bits(gb, 1); //common
1235     v->res_rtm_flag = get_bits(gb, 1); //reserved
1236     if (!v->res_rtm_flag)
1237     {
1238 //            av_log(avctx, AV_LOG_ERROR,
1239 //                   "0 for reserved RES_RTM_FLAG is forbidden\n");
1240         av_log(avctx, AV_LOG_ERROR,
1241                "Old WMV3 version detected, only I-frames will be decoded\n");
1242         //return -1;
1243     }
1244     av_log(avctx, AV_LOG_DEBUG,
1245                "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1246                "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1247                "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1248                "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1249                v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1250                v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1251                v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1252                v->dquant, v->quantizer_mode, avctx->max_b_frames
1253                );
1254     return 0;
1255 }
1256
1257 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
1258 {
1259     v->res_rtm_flag = 1;
1260     v->level = get_bits(gb, 3);
1261     if(v->level >= 5)
1262     {
1263         av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1264     }
1265     v->chromaformat = get_bits(gb, 2);
1266     if (v->chromaformat != 1)
1267     {
1268         av_log(v->s.avctx, AV_LOG_ERROR,
1269                "Only 4:2:0 chroma format supported\n");
1270         return -1;
1271     }
1272
1273     // (fps-2)/4 (->30)
1274     v->frmrtq_postproc = get_bits(gb, 3); //common
1275     // (bitrate-32kbps)/64kbps
1276     v->bitrtq_postproc = get_bits(gb, 5); //common
1277     v->postprocflag = get_bits(gb, 1); //common
1278
1279     v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
1280     v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
1281     v->s.avctx->width = v->s.avctx->coded_width;
1282     v->s.avctx->height = v->s.avctx->coded_height;
1283     v->broadcast = get_bits1(gb);
1284     v->interlace = get_bits1(gb);
1285     if(v->interlace){
1286         av_log(v->s.avctx, AV_LOG_ERROR, "Interlaced mode not supported (yet)\n");
1287         return -1;
1288     }
1289     v->tfcntrflag = get_bits1(gb);
1290     v->finterpflag = get_bits1(gb);
1291     get_bits1(gb); // reserved
1292
1293     av_log(v->s.avctx, AV_LOG_DEBUG,
1294                "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1295                "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
1296                "TFCTRflag=%i, FINTERPflag=%i\n",
1297                v->level, v->frmrtq_postproc, v->bitrtq_postproc,
1298                v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
1299                v->tfcntrflag, v->finterpflag
1300                );
1301
1302     v->psf = get_bits1(gb);
1303     if(v->psf) { //PsF, 6.1.13
1304         av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
1305         return -1;
1306     }
1307     v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
1308     if(get_bits1(gb)) { //Display Info - decoding is not affected by it
1309         int w, h, ar = 0;
1310         av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
1311         v->s.avctx->width  = v->s.width  = w = get_bits(gb, 14) + 1;
1312         v->s.avctx->height = v->s.height = h = get_bits(gb, 14) + 1;
1313         av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
1314         if(get_bits1(gb))
1315             ar = get_bits(gb, 4);
1316         if(ar && ar < 14){
1317             v->s.avctx->sample_aspect_ratio = vc1_pixel_aspect[ar];
1318         }else if(ar == 15){
1319             w = get_bits(gb, 8);
1320             h = get_bits(gb, 8);
1321             v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
1322         }
1323
1324         if(get_bits1(gb)){ //framerate stuff
1325             if(get_bits1(gb)) {
1326                 v->s.avctx->time_base.num = 32;
1327                 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
1328             } else {
1329                 int nr, dr;
1330                 nr = get_bits(gb, 8);
1331                 dr = get_bits(gb, 4);
1332                 if(nr && nr < 8 && dr && dr < 3){
1333                     v->s.avctx->time_base.num = fps_dr[dr - 1];
1334                     v->s.avctx->time_base.den = fps_nr[nr - 1] * 1000;
1335                 }
1336             }
1337         }
1338
1339         if(get_bits1(gb)){
1340             v->color_prim = get_bits(gb, 8);
1341             v->transfer_char = get_bits(gb, 8);
1342             v->matrix_coef = get_bits(gb, 8);
1343         }
1344     }
1345
1346     v->hrd_param_flag = get_bits1(gb);
1347     if(v->hrd_param_flag) {
1348         int i;
1349         v->hrd_num_leaky_buckets = get_bits(gb, 5);
1350         get_bits(gb, 4); //bitrate exponent
1351         get_bits(gb, 4); //buffer size exponent
1352         for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1353             get_bits(gb, 16); //hrd_rate[n]
1354             get_bits(gb, 16); //hrd_buffer[n]
1355         }
1356     }
1357     return 0;
1358 }
1359
1360 static int decode_entry_point(AVCodecContext *avctx, GetBitContext *gb)
1361 {
1362     VC1Context *v = avctx->priv_data;
1363     int i, blink, clentry, refdist;
1364
1365     av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
1366     blink = get_bits1(gb); // broken link
1367     clentry = get_bits1(gb); // closed entry
1368     v->panscanflag = get_bits1(gb);
1369     refdist = get_bits1(gb); // refdist flag
1370     v->s.loop_filter = get_bits1(gb);
1371     v->fastuvmc = get_bits1(gb);
1372     v->extended_mv = get_bits1(gb);
1373     v->dquant = get_bits(gb, 2);
1374     v->vstransform = get_bits1(gb);
1375     v->overlap = get_bits1(gb);
1376     v->quantizer_mode = get_bits(gb, 2);
1377
1378     if(v->hrd_param_flag){
1379         for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1380             get_bits(gb, 8); //hrd_full[n]
1381         }
1382     }
1383
1384     if(get_bits1(gb)){
1385         avctx->coded_width = (get_bits(gb, 12)+1)<<1;
1386         avctx->coded_height = (get_bits(gb, 12)+1)<<1;
1387     }
1388     if(v->extended_mv)
1389         v->extended_dmv = get_bits1(gb);
1390     if(get_bits1(gb)) {
1391         av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
1392         skip_bits(gb, 3); // Y range, ignored for now
1393     }
1394     if(get_bits1(gb)) {
1395         av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
1396         skip_bits(gb, 3); // UV range, ignored for now
1397     }
1398
1399     av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
1400         "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1401         "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1402         "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1403         blink, clentry, v->panscanflag, refdist, v->s.loop_filter,
1404         v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
1405
1406     return 0;
1407 }
1408
1409 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1410 {
1411     int pqindex, lowquant, status;
1412
1413     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1414     skip_bits(gb, 2); //framecnt unused
1415     v->rangeredfrm = 0;
1416     if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1417     v->s.pict_type = get_bits(gb, 1);
1418     if (v->s.avctx->max_b_frames) {
1419         if (!v->s.pict_type) {
1420             if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1421             else v->s.pict_type = B_TYPE;
1422         } else v->s.pict_type = P_TYPE;
1423     } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1424
1425     v->bi_type = 0;
1426     if(v->s.pict_type == B_TYPE) {
1427         v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1428         v->bfraction = vc1_bfraction_lut[v->bfraction];
1429         if(v->bfraction == 0) {
1430             v->s.pict_type = BI_TYPE;
1431         }
1432     }
1433     if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1434         get_bits(gb, 7); // skip buffer fullness
1435
1436     /* calculate RND */
1437     if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1438         v->rnd = 1;
1439     if(v->s.pict_type == P_TYPE)
1440         v->rnd ^= 1;
1441
1442     /* Quantizer stuff */
1443     pqindex = get_bits(gb, 5);
1444     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1445         v->pq = pquant_table[0][pqindex];
1446     else
1447         v->pq = pquant_table[1][pqindex];
1448
1449     v->pquantizer = 1;
1450     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1451         v->pquantizer = pqindex < 9;
1452     if (v->quantizer_mode == QUANT_NON_UNIFORM)
1453         v->pquantizer = 0;
1454     v->pqindex = pqindex;
1455     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1456     else v->halfpq = 0;
1457     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1458         v->pquantizer = get_bits(gb, 1);
1459     v->dquantfrm = 0;
1460     if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1461     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1462     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1463     v->range_x = 1 << (v->k_x - 1);
1464     v->range_y = 1 << (v->k_y - 1);
1465     if (v->profile == PROFILE_ADVANCED)
1466     {
1467         if (v->postprocflag) v->postproc = get_bits(gb, 1);
1468     }
1469     else
1470         if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1471
1472 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1473 //        (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1474
1475     if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
1476
1477     switch(v->s.pict_type) {
1478     case P_TYPE:
1479         if (v->pq < 5) v->tt_index = 0;
1480         else if(v->pq < 13) v->tt_index = 1;
1481         else v->tt_index = 2;
1482
1483         lowquant = (v->pq > 12) ? 0 : 1;
1484         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1485         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1486         {
1487             int scale, shift, i;
1488             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1489             v->lumscale = get_bits(gb, 6);
1490             v->lumshift = get_bits(gb, 6);
1491             v->use_ic = 1;
1492             /* fill lookup tables for intensity compensation */
1493             if(!v->lumscale) {
1494                 scale = -64;
1495                 shift = (255 - v->lumshift * 2) << 6;
1496                 if(v->lumshift > 31)
1497                     shift += 128 << 6;
1498             } else {
1499                 scale = v->lumscale + 32;
1500                 if(v->lumshift > 31)
1501                     shift = (v->lumshift - 64) << 6;
1502                 else
1503                     shift = v->lumshift << 6;
1504             }
1505             for(i = 0; i < 256; i++) {
1506                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1507                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1508             }
1509         }
1510         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1511             v->s.quarter_sample = 0;
1512         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1513             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1514                 v->s.quarter_sample = 0;
1515             else
1516                 v->s.quarter_sample = 1;
1517         } else
1518             v->s.quarter_sample = 1;
1519         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));
1520
1521         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1522                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1523                 || v->mv_mode == MV_PMODE_MIXED_MV)
1524         {
1525             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1526             if (status < 0) return -1;
1527             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1528                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1529         } else {
1530             v->mv_type_is_raw = 0;
1531             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1532         }
1533         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1534         if (status < 0) return -1;
1535         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1536                "Imode: %i, Invert: %i\n", status>>1, status&1);
1537
1538         /* Hopefully this is correct for P frames */
1539         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1540         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1541
1542         if (v->dquant)
1543         {
1544             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1545             vop_dquant_decoding(v);
1546         }
1547
1548         v->ttfrm = 0; //FIXME Is that so ?
1549         if (v->vstransform)
1550         {
1551             v->ttmbf = get_bits(gb, 1);
1552             if (v->ttmbf)
1553             {
1554                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1555             }
1556         } else {
1557             v->ttmbf = 1;
1558             v->ttfrm = TT_8X8;
1559         }
1560         break;
1561     case B_TYPE:
1562         if (v->pq < 5) v->tt_index = 0;
1563         else if(v->pq < 13) v->tt_index = 1;
1564         else v->tt_index = 2;
1565
1566         lowquant = (v->pq > 12) ? 0 : 1;
1567         v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1568         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1569         v->s.mspel = v->s.quarter_sample;
1570
1571         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1572         if (status < 0) return -1;
1573         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1574                "Imode: %i, Invert: %i\n", status>>1, status&1);
1575         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1576         if (status < 0) return -1;
1577         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1578                "Imode: %i, Invert: %i\n", status>>1, status&1);
1579
1580         v->s.mv_table_index = get_bits(gb, 2);
1581         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1582
1583         if (v->dquant)
1584         {
1585             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1586             vop_dquant_decoding(v);
1587         }
1588
1589         v->ttfrm = 0;
1590         if (v->vstransform)
1591         {
1592             v->ttmbf = get_bits(gb, 1);
1593             if (v->ttmbf)
1594             {
1595                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1596             }
1597         } else {
1598             v->ttmbf = 1;
1599             v->ttfrm = TT_8X8;
1600         }
1601         break;
1602     }
1603
1604     /* AC Syntax */
1605     v->c_ac_table_index = decode012(gb);
1606     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1607     {
1608         v->y_ac_table_index = decode012(gb);
1609     }
1610     /* DC Syntax */
1611     v->s.dc_table_index = get_bits(gb, 1);
1612
1613     if(v->s.pict_type == BI_TYPE) {
1614         v->s.pict_type = B_TYPE;
1615         v->bi_type = 1;
1616     }
1617     return 0;
1618 }
1619
1620 static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
1621 {
1622     int pqindex, lowquant;
1623     int status;
1624
1625     v->p_frame_skipped = 0;
1626
1627     if(v->interlace)
1628         v->fcm = decode012(gb);
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     switch(v->s.pict_type) {
1690     case I_TYPE:
1691     case BI_TYPE:
1692         status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1693         if (status < 0) return -1;
1694         av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1695                 "Imode: %i, Invert: %i\n", status>>1, status&1);
1696         v->condover = CONDOVER_NONE;
1697         if(v->overlap && v->pq <= 8) {
1698             v->condover = decode012(gb);
1699             if(v->condover == CONDOVER_SELECT) {
1700                 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1701                 if (status < 0) return -1;
1702                 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1703                         "Imode: %i, Invert: %i\n", status>>1, status&1);
1704             }
1705         }
1706         break;
1707     case P_TYPE:
1708         if(v->postprocflag)
1709             v->postproc = get_bits1(gb);
1710         if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1711         else v->mvrange = 0;
1712         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1713         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1714         v->range_x = 1 << (v->k_x - 1);
1715         v->range_y = 1 << (v->k_y - 1);
1716
1717         if (v->pq < 5) v->tt_index = 0;
1718         else if(v->pq < 13) v->tt_index = 1;
1719         else v->tt_index = 2;
1720
1721         lowquant = (v->pq > 12) ? 0 : 1;
1722         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1723         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1724         {
1725             int scale, shift, i;
1726             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1727             v->lumscale = get_bits(gb, 6);
1728             v->lumshift = get_bits(gb, 6);
1729             /* fill lookup tables for intensity compensation */
1730             if(!v->lumscale) {
1731                 scale = -64;
1732                 shift = (255 - v->lumshift * 2) << 6;
1733                 if(v->lumshift > 31)
1734                     shift += 128 << 6;
1735             } else {
1736                 scale = v->lumscale + 32;
1737                 if(v->lumshift > 31)
1738                     shift = (v->lumshift - 64) << 6;
1739                 else
1740                     shift = v->lumshift << 6;
1741             }
1742             for(i = 0; i < 256; i++) {
1743                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1744                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1745             }
1746         }
1747         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1748             v->s.quarter_sample = 0;
1749         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1750             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1751                 v->s.quarter_sample = 0;
1752             else
1753                 v->s.quarter_sample = 1;
1754         } else
1755             v->s.quarter_sample = 1;
1756         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));
1757
1758         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1759                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1760                 || v->mv_mode == MV_PMODE_MIXED_MV)
1761         {
1762             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1763             if (status < 0) return -1;
1764             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1765                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1766         } else {
1767             v->mv_type_is_raw = 0;
1768             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1769         }
1770         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1771         if (status < 0) return -1;
1772         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1773                "Imode: %i, Invert: %i\n", status>>1, status&1);
1774
1775         /* Hopefully this is correct for P frames */
1776         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1777         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1778         if (v->dquant)
1779         {
1780             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1781             vop_dquant_decoding(v);
1782         }
1783
1784         v->ttfrm = 0; //FIXME Is that so ?
1785         if (v->vstransform)
1786         {
1787             v->ttmbf = get_bits(gb, 1);
1788             if (v->ttmbf)
1789             {
1790                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1791             }
1792         } else {
1793             v->ttmbf = 1;
1794             v->ttfrm = TT_8X8;
1795         }
1796         break;
1797     case B_TYPE:
1798         if(v->postprocflag)
1799             v->postproc = get_bits1(gb);
1800         if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1801         else v->mvrange = 0;
1802         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1803         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1804         v->range_x = 1 << (v->k_x - 1);
1805         v->range_y = 1 << (v->k_y - 1);
1806
1807         if (v->pq < 5) v->tt_index = 0;
1808         else if(v->pq < 13) v->tt_index = 1;
1809         else v->tt_index = 2;
1810
1811         lowquant = (v->pq > 12) ? 0 : 1;
1812         v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1813         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1814         v->s.mspel = v->s.quarter_sample;
1815
1816         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1817         if (status < 0) return -1;
1818         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1819                "Imode: %i, Invert: %i\n", status>>1, status&1);
1820         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1821         if (status < 0) return -1;
1822         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1823                "Imode: %i, Invert: %i\n", status>>1, status&1);
1824
1825         v->s.mv_table_index = get_bits(gb, 2);
1826         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1827
1828         if (v->dquant)
1829         {
1830             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1831             vop_dquant_decoding(v);
1832         }
1833
1834         v->ttfrm = 0;
1835         if (v->vstransform)
1836         {
1837             v->ttmbf = get_bits(gb, 1);
1838             if (v->ttmbf)
1839             {
1840                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1841             }
1842         } else {
1843             v->ttmbf = 1;
1844             v->ttfrm = TT_8X8;
1845         }
1846         break;
1847     }
1848
1849     /* AC Syntax */
1850     v->c_ac_table_index = decode012(gb);
1851     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1852     {
1853         v->y_ac_table_index = decode012(gb);
1854     }
1855     /* DC Syntax */
1856     v->s.dc_table_index = get_bits(gb, 1);
1857     if ((v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE) && v->dquant) {
1858         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1859         vop_dquant_decoding(v);
1860     }
1861
1862     v->bi_type = 0;
1863     if(v->s.pict_type == BI_TYPE) {
1864         v->s.pict_type = B_TYPE;
1865         v->bi_type = 1;
1866     }
1867     return 0;
1868 }
1869
1870 /***********************************************************************/
1871 /**
1872  * @defgroup block VC-1 Block-level functions
1873  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1874  * @{
1875  */
1876
1877 /**
1878  * @def GET_MQUANT
1879  * @brief Get macroblock-level quantizer scale
1880  */
1881 #define GET_MQUANT()                                           \
1882   if (v->dquantfrm)                                            \
1883   {                                                            \
1884     int edges = 0;                                             \
1885     if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1886     {                                                          \
1887       if (v->dqbilevel)                                        \
1888       {                                                        \
1889         mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
1890       }                                                        \
1891       else                                                     \
1892       {                                                        \
1893         mqdiff = get_bits(gb, 3);                              \
1894         if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1895         else mquant = get_bits(gb, 5);                         \
1896       }                                                        \
1897     }                                                          \
1898     if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
1899         edges = 1 << v->dqsbedge;                              \
1900     else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1901         edges = (3 << v->dqsbedge) % 15;                       \
1902     else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1903         edges = 15;                                            \
1904     if((edges&1) && !s->mb_x)                                  \
1905         mquant = v->altpq;                                     \
1906     if((edges&2) && s->first_slice_line)                       \
1907         mquant = v->altpq;                                     \
1908     if((edges&4) && s->mb_x == (s->mb_width - 1))              \
1909         mquant = v->altpq;                                     \
1910     if((edges&8) && s->mb_y == (s->mb_height - 1))             \
1911         mquant = v->altpq;                                     \
1912   }
1913
1914 /**
1915  * @def GET_MVDATA(_dmv_x, _dmv_y)
1916  * @brief Get MV differentials
1917  * @see MVDATA decoding from 8.3.5.2, p(1)20
1918  * @param _dmv_x Horizontal differential for decoded MV
1919  * @param _dmv_y Vertical differential for decoded MV
1920  */
1921 #define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1922   index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1923                        VC1_MV_DIFF_VLC_BITS, 2);                    \
1924   if (index > 36)                                                   \
1925   {                                                                 \
1926     mb_has_coeffs = 1;                                              \
1927     index -= 37;                                                    \
1928   }                                                                 \
1929   else mb_has_coeffs = 0;                                           \
1930   s->mb_intra = 0;                                                  \
1931   if (!index) { _dmv_x = _dmv_y = 0; }                              \
1932   else if (index == 35)                                             \
1933   {                                                                 \
1934     _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1935     _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1936   }                                                                 \
1937   else if (index == 36)                                             \
1938   {                                                                 \
1939     _dmv_x = 0;                                                     \
1940     _dmv_y = 0;                                                     \
1941     s->mb_intra = 1;                                                \
1942   }                                                                 \
1943   else                                                              \
1944   {                                                                 \
1945     index1 = index%6;                                               \
1946     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1947     else                                   val = 0;                 \
1948     if(size_table[index1] - val > 0)                                \
1949         val = get_bits(gb, size_table[index1] - val);               \
1950     else                                   val = 0;                 \
1951     sign = 0 - (val&1);                                             \
1952     _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1953                                                                     \
1954     index1 = index/6;                                               \
1955     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1956     else                                   val = 0;                 \
1957     if(size_table[index1] - val > 0)                                \
1958         val = get_bits(gb, size_table[index1] - val);               \
1959     else                                   val = 0;                 \
1960     sign = 0 - (val&1);                                             \
1961     _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1962   }
1963
1964 /** Predict and set motion vector
1965  */
1966 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)
1967 {
1968     int xy, wrap, off = 0;
1969     int16_t *A, *B, *C;
1970     int px, py;
1971     int sum;
1972
1973     /* scale MV difference to be quad-pel */
1974     dmv_x <<= 1 - s->quarter_sample;
1975     dmv_y <<= 1 - s->quarter_sample;
1976
1977     wrap = s->b8_stride;
1978     xy = s->block_index[n];
1979
1980     if(s->mb_intra){
1981         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1982         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1983         if(mv1) { /* duplicate motion data for 1-MV block */
1984             s->current_picture.motion_val[0][xy + 1][0] = 0;
1985             s->current_picture.motion_val[0][xy + 1][1] = 0;
1986             s->current_picture.motion_val[0][xy + wrap][0] = 0;
1987             s->current_picture.motion_val[0][xy + wrap][1] = 0;
1988             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1989             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1990         }
1991         return;
1992     }
1993
1994     C = s->current_picture.motion_val[0][xy - 1];
1995     A = s->current_picture.motion_val[0][xy - wrap];
1996     if(mv1)
1997         off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1998     else {
1999         //in 4-MV mode different blocks have different B predictor position
2000         switch(n){
2001         case 0:
2002             off = (s->mb_x > 0) ? -1 : 1;
2003             break;
2004         case 1:
2005             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
2006             break;
2007         case 2:
2008             off = 1;
2009             break;
2010         case 3:
2011             off = -1;
2012         }
2013     }
2014     B = s->current_picture.motion_val[0][xy - wrap + off];
2015
2016     if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
2017         if(s->mb_width == 1) {
2018             px = A[0];
2019             py = A[1];
2020         } else {
2021             px = mid_pred(A[0], B[0], C[0]);
2022             py = mid_pred(A[1], B[1], C[1]);
2023         }
2024     } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
2025         px = C[0];
2026         py = C[1];
2027     } else {
2028         px = py = 0;
2029     }
2030     /* Pullback MV as specified in 8.3.5.3.4 */
2031     {
2032         int qx, qy, X, Y;
2033         qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
2034         qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
2035         X = (s->mb_width << 6) - 4;
2036         Y = (s->mb_height << 6) - 4;
2037         if(mv1) {
2038             if(qx + px < -60) px = -60 - qx;
2039             if(qy + py < -60) py = -60 - qy;
2040         } else {
2041             if(qx + px < -28) px = -28 - qx;
2042             if(qy + py < -28) py = -28 - qy;
2043         }
2044         if(qx + px > X) px = X - qx;
2045         if(qy + py > Y) py = Y - qy;
2046     }
2047     /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2048     if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
2049         if(is_intra[xy - wrap])
2050             sum = FFABS(px) + FFABS(py);
2051         else
2052             sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2053         if(sum > 32) {
2054             if(get_bits1(&s->gb)) {
2055                 px = A[0];
2056                 py = A[1];
2057             } else {
2058                 px = C[0];
2059                 py = C[1];
2060             }
2061         } else {
2062             if(is_intra[xy - 1])
2063                 sum = FFABS(px) + FFABS(py);
2064             else
2065                 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2066             if(sum > 32) {
2067                 if(get_bits1(&s->gb)) {
2068                     px = A[0];
2069                     py = A[1];
2070                 } else {
2071                     px = C[0];
2072                     py = C[1];
2073                 }
2074             }
2075         }
2076     }
2077     /* store MV using signed modulus of MV range defined in 4.11 */
2078     s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
2079     s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
2080     if(mv1) { /* duplicate motion data for 1-MV block */
2081         s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
2082         s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
2083         s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
2084         s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
2085         s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
2086         s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
2087     }
2088 }
2089
2090 /** Motion compensation for direct or interpolated blocks in B-frames
2091  */
2092 static void vc1_interp_mc(VC1Context *v)
2093 {
2094     MpegEncContext *s = &v->s;
2095     DSPContext *dsp = &v->s.dsp;
2096     uint8_t *srcY, *srcU, *srcV;
2097     int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
2098
2099     if(!v->s.next_picture.data[0])return;
2100
2101     mx = s->mv[1][0][0];
2102     my = s->mv[1][0][1];
2103     uvmx = (mx + ((mx & 3) == 3)) >> 1;
2104     uvmy = (my + ((my & 3) == 3)) >> 1;
2105     if(v->fastuvmc) {
2106         uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
2107         uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
2108     }
2109     srcY = s->next_picture.data[0];
2110     srcU = s->next_picture.data[1];
2111     srcV = s->next_picture.data[2];
2112
2113     src_x = s->mb_x * 16 + (mx >> 2);
2114     src_y = s->mb_y * 16 + (my >> 2);
2115     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
2116     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
2117
2118     src_x   = clip(  src_x, -16, s->mb_width  * 16);
2119     src_y   = clip(  src_y, -16, s->mb_height * 16);
2120     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
2121     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
2122
2123     srcY += src_y * s->linesize + src_x;
2124     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
2125     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
2126
2127     /* for grayscale we should not try to read from unknown area */
2128     if(s->flags & CODEC_FLAG_GRAY) {
2129         srcU = s->edge_emu_buffer + 18 * s->linesize;
2130         srcV = s->edge_emu_buffer + 18 * s->linesize;
2131     }
2132
2133     if(v->rangeredfrm
2134        || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
2135        || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
2136         uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
2137
2138         srcY -= s->mspel * (1 + s->linesize);
2139         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
2140                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
2141         srcY = s->edge_emu_buffer;
2142         ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
2143                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2144         ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
2145                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2146         srcU = uvbuf;
2147         srcV = uvbuf + 16;
2148         /* if we deal with range reduction we need to scale source blocks */
2149         if(v->rangeredfrm) {
2150             int i, j;
2151             uint8_t *src, *src2;
2152
2153             src = srcY;
2154             for(j = 0; j < 17 + s->mspel*2; j++) {
2155                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
2156                 src += s->linesize;
2157             }
2158             src = srcU; src2 = srcV;
2159             for(j = 0; j < 9; j++) {
2160                 for(i = 0; i < 9; i++) {
2161                     src[i] = ((src[i] - 128) >> 1) + 128;
2162                     src2[i] = ((src2[i] - 128) >> 1) + 128;
2163                 }
2164                 src += s->uvlinesize;
2165                 src2 += s->uvlinesize;
2166             }
2167         }
2168         srcY += s->mspel * (1 + s->linesize);
2169     }
2170
2171     mx >>= 1;
2172     my >>= 1;
2173     dxy = ((my & 1) << 1) | (mx & 1);
2174
2175     dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
2176
2177     if(s->flags & CODEC_FLAG_GRAY) return;
2178     /* Chroma MC always uses qpel blilinear */
2179     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
2180     uvmx = (uvmx&3)<<1;
2181     uvmy = (uvmy&3)<<1;
2182     dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
2183     dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
2184 }
2185
2186 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2187 {
2188     int n = bfrac;
2189
2190 #if B_FRACTION_DEN==256
2191     if(inv)
2192         n -= 256;
2193     if(!qs)
2194         return 2 * ((value * n + 255) >> 9);
2195     return (value * n + 128) >> 8;
2196 #else
2197     if(inv)
2198         n -= B_FRACTION_DEN;
2199     if(!qs)
2200         return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2201     return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2202 #endif
2203 }
2204
2205 /** Reconstruct motion vector for B-frame and do motion compensation
2206  */
2207 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
2208 {
2209     if(v->use_ic) {
2210         v->mv_mode2 = v->mv_mode;
2211         v->mv_mode = MV_PMODE_INTENSITY_COMP;
2212     }
2213     if(direct) {
2214         vc1_mc_1mv(v, 0);
2215         vc1_interp_mc(v);
2216         if(v->use_ic) v->mv_mode = v->mv_mode2;
2217         return;
2218     }
2219     if(mode == BMV_TYPE_INTERPOLATED) {
2220         vc1_mc_1mv(v, 0);
2221         vc1_interp_mc(v);
2222         if(v->use_ic) v->mv_mode = v->mv_mode2;
2223         return;
2224     }
2225
2226     if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
2227     vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2228     if(v->use_ic) v->mv_mode = v->mv_mode2;
2229 }
2230
2231 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
2232 {
2233     MpegEncContext *s = &v->s;
2234     int xy, wrap, off = 0;
2235     int16_t *A, *B, *C;
2236     int px, py;
2237     int sum;
2238     int r_x, r_y;
2239     const uint8_t *is_intra = v->mb_type[0];
2240
2241     r_x = v->range_x;
2242     r_y = v->range_y;
2243     /* scale MV difference to be quad-pel */
2244     dmv_x[0] <<= 1 - s->quarter_sample;
2245     dmv_y[0] <<= 1 - s->quarter_sample;
2246     dmv_x[1] <<= 1 - s->quarter_sample;
2247     dmv_y[1] <<= 1 - s->quarter_sample;
2248
2249     wrap = s->b8_stride;
2250     xy = s->block_index[0];
2251
2252     if(s->mb_intra) {
2253         s->current_picture.motion_val[0][xy][0] =
2254         s->current_picture.motion_val[0][xy][1] =
2255         s->current_picture.motion_val[1][xy][0] =
2256         s->current_picture.motion_val[1][xy][1] = 0;
2257         return;
2258     }
2259     s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2260     s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2261     s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2262     s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2263     if(direct) {
2264         s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2265         s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2266         s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2267         s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2268         return;
2269     }
2270
2271     if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2272         C = s->current_picture.motion_val[0][xy - 2];
2273         A = s->current_picture.motion_val[0][xy - wrap*2];
2274         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2275         B = s->current_picture.motion_val[0][xy - wrap*2 + off];
2276
2277         if(!s->first_slice_line) { // predictor A is not out of bounds
2278             if(s->mb_width == 1) {
2279                 px = A[0];
2280                 py = A[1];
2281             } else {
2282                 px = mid_pred(A[0], B[0], C[0]);
2283                 py = mid_pred(A[1], B[1], C[1]);
2284             }
2285         } else if(s->mb_x) { // predictor C is not out of bounds
2286             px = C[0];
2287             py = C[1];
2288         } else {
2289             px = py = 0;
2290         }
2291         /* Pullback MV as specified in 8.3.5.3.4 */
2292         {
2293             int qx, qy, X, Y;
2294             if(v->profile < PROFILE_ADVANCED) {
2295                 qx = (s->mb_x << 5);
2296                 qy = (s->mb_y << 5);
2297                 X = (s->mb_width << 5) - 4;
2298                 Y = (s->mb_height << 5) - 4;
2299                 if(qx + px < -28) px = -28 - qx;
2300                 if(qy + py < -28) py = -28 - qy;
2301                 if(qx + px > X) px = X - qx;
2302                 if(qy + py > Y) py = Y - qy;
2303             } else {
2304                 qx = (s->mb_x << 6);
2305                 qy = (s->mb_y << 6);
2306                 X = (s->mb_width << 6) - 4;
2307                 Y = (s->mb_height << 6) - 4;
2308                 if(qx + px < -60) px = -60 - qx;
2309                 if(qy + py < -60) py = -60 - qy;
2310                 if(qx + px > X) px = X - qx;
2311                 if(qy + py > Y) py = Y - qy;
2312             }
2313         }
2314         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2315         if(0 && !s->first_slice_line && s->mb_x) {
2316             if(is_intra[xy - wrap])
2317                 sum = FFABS(px) + FFABS(py);
2318             else
2319                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2320             if(sum > 32) {
2321                 if(get_bits1(&s->gb)) {
2322                     px = A[0];
2323                     py = A[1];
2324                 } else {
2325                     px = C[0];
2326                     py = C[1];
2327                 }
2328             } else {
2329                 if(is_intra[xy - 2])
2330                     sum = FFABS(px) + FFABS(py);
2331                 else
2332                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2333                 if(sum > 32) {
2334                     if(get_bits1(&s->gb)) {
2335                         px = A[0];
2336                         py = A[1];
2337                     } else {
2338                         px = C[0];
2339                         py = C[1];
2340                     }
2341                 }
2342             }
2343         }
2344         /* store MV using signed modulus of MV range defined in 4.11 */
2345         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2346         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2347     }
2348     if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2349         C = s->current_picture.motion_val[1][xy - 2];
2350         A = s->current_picture.motion_val[1][xy - wrap*2];
2351         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2352         B = s->current_picture.motion_val[1][xy - wrap*2 + off];
2353
2354         if(!s->first_slice_line) { // predictor A is not out of bounds
2355             if(s->mb_width == 1) {
2356                 px = A[0];
2357                 py = A[1];
2358             } else {
2359                 px = mid_pred(A[0], B[0], C[0]);
2360                 py = mid_pred(A[1], B[1], C[1]);
2361             }
2362         } else if(s->mb_x) { // predictor C is not out of bounds
2363             px = C[0];
2364             py = C[1];
2365         } else {
2366             px = py = 0;
2367         }
2368         /* Pullback MV as specified in 8.3.5.3.4 */
2369         {
2370             int qx, qy, X, Y;
2371             if(v->profile < PROFILE_ADVANCED) {
2372                 qx = (s->mb_x << 5);
2373                 qy = (s->mb_y << 5);
2374                 X = (s->mb_width << 5) - 4;
2375                 Y = (s->mb_height << 5) - 4;
2376                 if(qx + px < -28) px = -28 - qx;
2377                 if(qy + py < -28) py = -28 - qy;
2378                 if(qx + px > X) px = X - qx;
2379                 if(qy + py > Y) py = Y - qy;
2380             } else {
2381                 qx = (s->mb_x << 6);
2382                 qy = (s->mb_y << 6);
2383                 X = (s->mb_width << 6) - 4;
2384                 Y = (s->mb_height << 6) - 4;
2385                 if(qx + px < -60) px = -60 - qx;
2386                 if(qy + py < -60) py = -60 - qy;
2387                 if(qx + px > X) px = X - qx;
2388                 if(qy + py > Y) py = Y - qy;
2389             }
2390         }
2391         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2392         if(0 && !s->first_slice_line && s->mb_x) {
2393             if(is_intra[xy - wrap])
2394                 sum = FFABS(px) + FFABS(py);
2395             else
2396                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2397             if(sum > 32) {
2398                 if(get_bits1(&s->gb)) {
2399                     px = A[0];
2400                     py = A[1];
2401                 } else {
2402                     px = C[0];
2403                     py = C[1];
2404                 }
2405             } else {
2406                 if(is_intra[xy - 2])
2407                     sum = FFABS(px) + FFABS(py);
2408                 else
2409                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2410                 if(sum > 32) {
2411                     if(get_bits1(&s->gb)) {
2412                         px = A[0];
2413                         py = A[1];
2414                     } else {
2415                         px = C[0];
2416                         py = C[1];
2417                     }
2418                 }
2419             }
2420         }
2421         /* store MV using signed modulus of MV range defined in 4.11 */
2422
2423         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2424         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2425     }
2426     s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2427     s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2428     s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2429     s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2430 }
2431
2432 /** Get predicted DC value for I-frames only
2433  * prediction dir: left=0, top=1
2434  * @param s MpegEncContext
2435  * @param[in] n block index in the current MB
2436  * @param dc_val_ptr Pointer to DC predictor
2437  * @param dir_ptr Prediction direction for use in AC prediction
2438  */
2439 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2440                               int16_t **dc_val_ptr, int *dir_ptr)
2441 {
2442     int a, b, c, wrap, pred, scale;
2443     int16_t *dc_val;
2444     static const uint16_t dcpred[32] = {
2445     -1, 1024,  512,  341,  256,  205,  171,  146,  128,
2446          114,  102,   93,   85,   79,   73,   68,   64,
2447           60,   57,   54,   51,   49,   47,   45,   43,
2448           41,   39,   38,   37,   35,   34,   33
2449     };
2450
2451     /* find prediction - wmv3_dc_scale always used here in fact */
2452     if (n < 4)     scale = s->y_dc_scale;
2453     else           scale = s->c_dc_scale;
2454
2455     wrap = s->block_wrap[n];
2456     dc_val= s->dc_val[0] + s->block_index[n];
2457
2458     /* B A
2459      * C X
2460      */
2461     c = dc_val[ - 1];
2462     b = dc_val[ - 1 - wrap];
2463     a = dc_val[ - wrap];
2464
2465     if (pq < 9 || !overlap)
2466     {
2467         /* Set outer values */
2468         if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
2469         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
2470     }
2471     else
2472     {
2473         /* Set outer values */
2474         if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
2475         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
2476     }
2477
2478     if (abs(a - b) <= abs(b - c)) {
2479         pred = c;
2480         *dir_ptr = 1;//left
2481     } else {
2482         pred = a;
2483         *dir_ptr = 0;//top
2484     }
2485
2486     /* update predictor */
2487     *dc_val_ptr = &dc_val[0];
2488     return pred;
2489 }
2490
2491
2492 /** Get predicted DC value
2493  * prediction dir: left=0, top=1
2494  * @param s MpegEncContext
2495  * @param[in] n block index in the current MB
2496  * @param dc_val_ptr Pointer to DC predictor
2497  * @param dir_ptr Prediction direction for use in AC prediction
2498  */
2499 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2500                               int a_avail, int c_avail,
2501                               int16_t **dc_val_ptr, int *dir_ptr)
2502 {
2503     int a, b, c, wrap, pred, scale;
2504     int16_t *dc_val;
2505     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2506     int q1, q2 = 0;
2507
2508     /* find prediction - wmv3_dc_scale always used here in fact */
2509     if (n < 4)     scale = s->y_dc_scale;
2510     else           scale = s->c_dc_scale;
2511
2512     wrap = s->block_wrap[n];
2513     dc_val= s->dc_val[0] + s->block_index[n];
2514
2515     /* B A
2516      * C X
2517      */
2518     c = dc_val[ - 1];
2519     b = dc_val[ - 1 - wrap];
2520     a = dc_val[ - wrap];
2521     /* scale predictors if needed */
2522     q1 = s->current_picture.qscale_table[mb_pos];
2523     if(c_avail && (n!= 1 && n!=3)) {
2524         q2 = s->current_picture.qscale_table[mb_pos - 1];
2525         if(q2 && q2 != q1)
2526             c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2527     }
2528     if(a_avail && (n!= 2 && n!=3)) {
2529         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2530         if(q2 && q2 != q1)
2531             a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2532     }
2533     if(a_avail && c_avail && (n!=3)) {
2534         int off = mb_pos;
2535         if(n != 1) off--;
2536         if(n != 2) off -= s->mb_stride;
2537         q2 = s->current_picture.qscale_table[off];
2538         if(q2 && q2 != q1)
2539             b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2540     }
2541
2542     if(a_avail && c_avail) {
2543         if(abs(a - b) <= abs(b - c)) {
2544             pred = c;
2545             *dir_ptr = 1;//left
2546         } else {
2547             pred = a;
2548             *dir_ptr = 0;//top
2549         }
2550     } else if(a_avail) {
2551         pred = a;
2552         *dir_ptr = 0;//top
2553     } else if(c_avail) {
2554         pred = c;
2555         *dir_ptr = 1;//left
2556     } else {
2557         pred = 0;
2558         *dir_ptr = 1;//left
2559     }
2560
2561     /* update predictor */
2562     *dc_val_ptr = &dc_val[0];
2563     return pred;
2564 }
2565
2566
2567 /**
2568  * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2569  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2570  * @{
2571  */
2572
2573 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
2574 {
2575     int xy, wrap, pred, a, b, c;
2576
2577     xy = s->block_index[n];
2578     wrap = s->b8_stride;
2579
2580     /* B C
2581      * A X
2582      */
2583     a = s->coded_block[xy - 1       ];
2584     b = s->coded_block[xy - 1 - wrap];
2585     c = s->coded_block[xy     - wrap];
2586
2587     if (b == c) {
2588         pred = a;
2589     } else {
2590         pred = c;
2591     }
2592
2593     /* store value */
2594     *coded_block_ptr = &s->coded_block[xy];
2595
2596     return pred;
2597 }
2598
2599 /**
2600  * Decode one AC coefficient
2601  * @param v The VC1 context
2602  * @param last Last coefficient
2603  * @param skip How much zero coefficients to skip
2604  * @param value Decoded AC coefficient value
2605  * @see 8.1.3.4
2606  */
2607 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
2608 {
2609     GetBitContext *gb = &v->s.gb;
2610     int index, escape, run = 0, level = 0, lst = 0;
2611
2612     index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2613     if (index != vc1_ac_sizes[codingset] - 1) {
2614         run = vc1_index_decode_table[codingset][index][0];
2615         level = vc1_index_decode_table[codingset][index][1];
2616         lst = index >= vc1_last_decode_table[codingset];
2617         if(get_bits(gb, 1))
2618             level = -level;
2619     } else {
2620         escape = decode210(gb);
2621         if (escape != 2) {
2622             index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2623             run = vc1_index_decode_table[codingset][index][0];
2624             level = vc1_index_decode_table[codingset][index][1];
2625             lst = index >= vc1_last_decode_table[codingset];
2626             if(escape == 0) {
2627                 if(lst)
2628                     level += vc1_last_delta_level_table[codingset][run];
2629                 else
2630                     level += vc1_delta_level_table[codingset][run];
2631             } else {
2632                 if(lst)
2633                     run += vc1_last_delta_run_table[codingset][level] + 1;
2634                 else
2635                     run += vc1_delta_run_table[codingset][level] + 1;
2636             }
2637             if(get_bits(gb, 1))
2638                 level = -level;
2639         } else {
2640             int sign;
2641             lst = get_bits(gb, 1);
2642             if(v->s.esc3_level_length == 0) {
2643                 if(v->pq < 8 || v->dquantfrm) { // table 59
2644                     v->s.esc3_level_length = get_bits(gb, 3);
2645                     if(!v->s.esc3_level_length)
2646                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
2647                 } else { //table 60
2648                     v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
2649                 }
2650                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2651             }
2652             run = get_bits(gb, v->s.esc3_run_length);
2653             sign = get_bits(gb, 1);
2654             level = get_bits(gb, v->s.esc3_level_length);
2655             if(sign)
2656                 level = -level;
2657         }
2658     }
2659
2660     *last = lst;
2661     *skip = run;
2662     *value = level;
2663 }
2664
2665 /** Decode intra block in intra frames - should be faster than decode_intra_block
2666  * @param v VC1Context
2667  * @param block block to decode
2668  * @param coded are AC coeffs present or not
2669  * @param codingset set of VLC to decode data
2670  */
2671 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
2672 {
2673     GetBitContext *gb = &v->s.gb;
2674     MpegEncContext *s = &v->s;
2675     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2676     int run_diff, i;
2677     int16_t *dc_val;
2678     int16_t *ac_val, *ac_val2;
2679     int dcdiff;
2680
2681     /* Get DC differential */
2682     if (n < 4) {
2683         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2684     } else {
2685         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2686     }
2687     if (dcdiff < 0){
2688         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2689         return -1;
2690     }
2691     if (dcdiff)
2692     {
2693         if (dcdiff == 119 /* ESC index value */)
2694         {
2695             /* TODO: Optimize */
2696             if (v->pq == 1) dcdiff = get_bits(gb, 10);
2697             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2698             else dcdiff = get_bits(gb, 8);
2699         }
2700         else
2701         {
2702             if (v->pq == 1)
2703                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2704             else if (v->pq == 2)
2705                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2706         }
2707         if (get_bits(gb, 1))
2708             dcdiff = -dcdiff;
2709     }
2710
2711     /* Prediction */
2712     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2713     *dc_val = dcdiff;
2714
2715     /* Store the quantized DC coeff, used for prediction */
2716     if (n < 4) {
2717         block[0] = dcdiff * s->y_dc_scale;
2718     } else {
2719         block[0] = dcdiff * s->c_dc_scale;
2720     }
2721     /* Skip ? */
2722     run_diff = 0;
2723     i = 0;
2724     if (!coded) {
2725         goto not_coded;
2726     }
2727
2728     //AC Decoding
2729     i = 1;
2730
2731     {
2732         int last = 0, skip, value;
2733         const int8_t *zz_table;
2734         int scale;
2735         int k;
2736
2737         scale = v->pq * 2 + v->halfpq;
2738
2739         if(v->s.ac_pred) {
2740             if(!dc_pred_dir)
2741                 zz_table = vc1_horizontal_zz;
2742             else
2743                 zz_table = vc1_vertical_zz;
2744         } else
2745             zz_table = vc1_normal_zz;
2746
2747         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2748         ac_val2 = ac_val;
2749         if(dc_pred_dir) //left
2750             ac_val -= 16;
2751         else //top
2752             ac_val -= 16 * s->block_wrap[n];
2753
2754         while (!last) {
2755             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2756             i += skip;
2757             if(i > 63)
2758                 break;
2759             block[zz_table[i++]] = value;
2760         }
2761
2762         /* apply AC prediction if needed */
2763         if(s->ac_pred) {
2764             if(dc_pred_dir) { //left
2765                 for(k = 1; k < 8; k++)
2766                     block[k << 3] += ac_val[k];
2767             } else { //top
2768                 for(k = 1; k < 8; k++)
2769                     block[k] += ac_val[k + 8];
2770             }
2771         }
2772         /* save AC coeffs for further prediction */
2773         for(k = 1; k < 8; k++) {
2774             ac_val2[k] = block[k << 3];
2775             ac_val2[k + 8] = block[k];
2776         }
2777
2778         /* scale AC coeffs */
2779         for(k = 1; k < 64; k++)
2780             if(block[k]) {
2781                 block[k] *= scale;
2782                 if(!v->pquantizer)
2783                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
2784             }
2785
2786         if(s->ac_pred) i = 63;
2787     }
2788
2789 not_coded:
2790     if(!coded) {
2791         int k, scale;
2792         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2793         ac_val2 = ac_val;
2794
2795         scale = v->pq * 2 + v->halfpq;
2796         memset(ac_val2, 0, 16 * 2);
2797         if(dc_pred_dir) {//left
2798             ac_val -= 16;
2799             if(s->ac_pred)
2800                 memcpy(ac_val2, ac_val, 8 * 2);
2801         } else {//top
2802             ac_val -= 16 * s->block_wrap[n];
2803             if(s->ac_pred)
2804                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2805         }
2806
2807         /* apply AC prediction if needed */
2808         if(s->ac_pred) {
2809             if(dc_pred_dir) { //left
2810                 for(k = 1; k < 8; k++) {
2811                     block[k << 3] = ac_val[k] * scale;
2812                     if(!v->pquantizer && block[k << 3])
2813                         block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2814                 }
2815             } else { //top
2816                 for(k = 1; k < 8; k++) {
2817                     block[k] = ac_val[k + 8] * scale;
2818                     if(!v->pquantizer && block[k])
2819                         block[k] += (block[k] < 0) ? -v->pq : v->pq;
2820                 }
2821             }
2822             i = 63;
2823         }
2824     }
2825     s->block_last_index[n] = i;
2826
2827     return 0;
2828 }
2829
2830 /** Decode intra block in intra frames - should be faster than decode_intra_block
2831  * @param v VC1Context
2832  * @param block block to decode
2833  * @param coded are AC coeffs present or not
2834  * @param codingset set of VLC to decode data
2835  */
2836 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
2837 {
2838     GetBitContext *gb = &v->s.gb;
2839     MpegEncContext *s = &v->s;
2840     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2841     int run_diff, i;
2842     int16_t *dc_val;
2843     int16_t *ac_val, *ac_val2;
2844     int dcdiff;
2845     int a_avail = v->a_avail, c_avail = v->c_avail;
2846     int use_pred = s->ac_pred;
2847     int scale;
2848     int q1, q2 = 0;
2849     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2850
2851     /* Get DC differential */
2852     if (n < 4) {
2853         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2854     } else {
2855         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2856     }
2857     if (dcdiff < 0){
2858         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2859         return -1;
2860     }
2861     if (dcdiff)
2862     {
2863         if (dcdiff == 119 /* ESC index value */)
2864         {
2865             /* TODO: Optimize */
2866             if (mquant == 1) dcdiff = get_bits(gb, 10);
2867             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2868             else dcdiff = get_bits(gb, 8);
2869         }
2870         else
2871         {
2872             if (mquant == 1)
2873                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2874             else if (mquant == 2)
2875                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2876         }
2877         if (get_bits(gb, 1))
2878             dcdiff = -dcdiff;
2879     }
2880
2881     /* Prediction */
2882     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2883     *dc_val = dcdiff;
2884
2885     /* Store the quantized DC coeff, used for prediction */
2886     if (n < 4) {
2887         block[0] = dcdiff * s->y_dc_scale;
2888     } else {
2889         block[0] = dcdiff * s->c_dc_scale;
2890     }
2891     /* Skip ? */
2892     run_diff = 0;
2893     i = 0;
2894
2895     //AC Decoding
2896     i = 1;
2897
2898     /* check if AC is needed at all and adjust direction if needed */
2899     if(!a_avail) dc_pred_dir = 1;
2900     if(!c_avail) dc_pred_dir = 0;
2901     if(!a_avail && !c_avail) use_pred = 0;
2902     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2903     ac_val2 = ac_val;
2904
2905     scale = mquant * 2 + v->halfpq;
2906
2907     if(dc_pred_dir) //left
2908         ac_val -= 16;
2909     else //top
2910         ac_val -= 16 * s->block_wrap[n];
2911
2912     q1 = s->current_picture.qscale_table[mb_pos];
2913     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
2914     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2915     if(n && n<4) q2 = q1;
2916
2917     if(coded) {
2918         int last = 0, skip, value;
2919         const int8_t *zz_table;
2920         int k;
2921
2922         if(v->s.ac_pred) {
2923             if(!dc_pred_dir)
2924                 zz_table = vc1_horizontal_zz;
2925             else
2926                 zz_table = vc1_vertical_zz;
2927         } else
2928             zz_table = vc1_normal_zz;
2929
2930         while (!last) {
2931             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2932             i += skip;
2933             if(i > 63)
2934                 break;
2935             block[zz_table[i++]] = value;
2936         }
2937
2938         /* apply AC prediction if needed */
2939         if(use_pred) {
2940             /* scale predictors if needed*/
2941             if(q2 && q1!=q2) {
2942                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2943                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2944
2945                 if(dc_pred_dir) { //left
2946                     for(k = 1; k < 8; k++)
2947                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2948                 } else { //top
2949                     for(k = 1; k < 8; k++)
2950                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2951                 }
2952             } else {
2953                 if(dc_pred_dir) { //left
2954                     for(k = 1; k < 8; k++)
2955                         block[k << 3] += ac_val[k];
2956                 } else { //top
2957                     for(k = 1; k < 8; k++)
2958                         block[k] += ac_val[k + 8];
2959                 }
2960             }
2961         }
2962         /* save AC coeffs for further prediction */
2963         for(k = 1; k < 8; k++) {
2964             ac_val2[k] = block[k << 3];
2965             ac_val2[k + 8] = block[k];
2966         }
2967
2968         /* scale AC coeffs */
2969         for(k = 1; k < 64; k++)
2970             if(block[k]) {
2971                 block[k] *= scale;
2972                 if(!v->pquantizer)
2973                     block[k] += (block[k] < 0) ? -mquant : mquant;
2974             }
2975
2976         if(use_pred) i = 63;
2977     } else { // no AC coeffs
2978         int k;
2979
2980         memset(ac_val2, 0, 16 * 2);
2981         if(dc_pred_dir) {//left
2982             if(use_pred) {
2983                 memcpy(ac_val2, ac_val, 8 * 2);
2984                 if(q2 && q1!=q2) {
2985                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2986                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2987                     for(k = 1; k < 8; k++)
2988                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2989                 }
2990             }
2991         } else {//top
2992             if(use_pred) {
2993                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2994                 if(q2 && q1!=q2) {
2995                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2996                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2997                     for(k = 1; k < 8; k++)
2998                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2999                 }
3000             }
3001         }
3002
3003         /* apply AC prediction if needed */
3004         if(use_pred) {
3005             if(dc_pred_dir) { //left
3006                 for(k = 1; k < 8; k++) {
3007                     block[k << 3] = ac_val2[k] * scale;
3008                     if(!v->pquantizer && block[k << 3])
3009                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3010                 }
3011             } else { //top
3012                 for(k = 1; k < 8; k++) {
3013                     block[k] = ac_val2[k + 8] * scale;
3014                     if(!v->pquantizer && block[k])
3015                         block[k] += (block[k] < 0) ? -mquant : mquant;
3016                 }
3017             }
3018             i = 63;
3019         }
3020     }
3021     s->block_last_index[n] = i;
3022
3023     return 0;
3024 }
3025
3026 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
3027  * @param v VC1Context
3028  * @param block block to decode
3029  * @param coded are AC coeffs present or not
3030  * @param mquant block quantizer
3031  * @param codingset set of VLC to decode data
3032  */
3033 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
3034 {
3035     GetBitContext *gb = &v->s.gb;
3036     MpegEncContext *s = &v->s;
3037     int dc_pred_dir = 0; /* Direction of the DC prediction used */
3038     int run_diff, i;
3039     int16_t *dc_val;
3040     int16_t *ac_val, *ac_val2;
3041     int dcdiff;
3042     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3043     int a_avail = v->a_avail, c_avail = v->c_avail;
3044     int use_pred = s->ac_pred;
3045     int scale;
3046     int q1, q2 = 0;
3047
3048     /* XXX: Guard against dumb values of mquant */
3049     mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
3050
3051     /* Set DC scale - y and c use the same */
3052     s->y_dc_scale = s->y_dc_scale_table[mquant];
3053     s->c_dc_scale = s->c_dc_scale_table[mquant];
3054
3055     /* Get DC differential */
3056     if (n < 4) {
3057         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3058     } else {
3059         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3060     }
3061     if (dcdiff < 0){
3062         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3063         return -1;
3064     }
3065     if (dcdiff)
3066     {
3067         if (dcdiff == 119 /* ESC index value */)
3068         {
3069             /* TODO: Optimize */
3070             if (mquant == 1) dcdiff = get_bits(gb, 10);
3071             else if (mquant == 2) dcdiff = get_bits(gb, 9);
3072             else dcdiff = get_bits(gb, 8);
3073         }
3074         else
3075         {
3076             if (mquant == 1)
3077                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
3078             else if (mquant == 2)
3079                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
3080         }
3081         if (get_bits(gb, 1))
3082             dcdiff = -dcdiff;
3083     }
3084
3085     /* Prediction */
3086     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3087     *dc_val = dcdiff;
3088
3089     /* Store the quantized DC coeff, used for prediction */
3090
3091     if (n < 4) {
3092         block[0] = dcdiff * s->y_dc_scale;
3093     } else {
3094         block[0] = dcdiff * s->c_dc_scale;
3095     }
3096     /* Skip ? */
3097     run_diff = 0;
3098     i = 0;
3099
3100     //AC Decoding
3101     i = 1;
3102
3103     /* check if AC is needed at all and adjust direction if needed */
3104     if(!a_avail) dc_pred_dir = 1;
3105     if(!c_avail) dc_pred_dir = 0;
3106     if(!a_avail && !c_avail) use_pred = 0;
3107     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3108     ac_val2 = ac_val;
3109
3110     scale = mquant * 2 + v->halfpq;
3111
3112     if(dc_pred_dir) //left
3113         ac_val -= 16;
3114     else //top
3115         ac_val -= 16 * s->block_wrap[n];
3116
3117     q1 = s->current_picture.qscale_table[mb_pos];
3118     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
3119     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3120     if(n && n<4) q2 = q1;
3121
3122     if(coded) {
3123         int last = 0, skip, value;
3124         const int8_t *zz_table;
3125         int k;
3126
3127         zz_table = vc1_simple_progressive_8x8_zz;
3128
3129         while (!last) {
3130             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3131             i += skip;
3132             if(i > 63)
3133                 break;
3134             block[zz_table[i++]] = value;
3135         }
3136
3137         /* apply AC prediction if needed */
3138         if(use_pred) {
3139             /* scale predictors if needed*/
3140             if(q2 && q1!=q2) {
3141                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3142                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3143
3144                 if(dc_pred_dir) { //left
3145                     for(k = 1; k < 8; k++)
3146                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3147                 } else { //top
3148                     for(k = 1; k < 8; k++)
3149                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3150                 }
3151             } else {
3152                 if(dc_pred_dir) { //left
3153                     for(k = 1; k < 8; k++)
3154                         block[k << 3] += ac_val[k];
3155                 } else { //top
3156                     for(k = 1; k < 8; k++)
3157                         block[k] += ac_val[k + 8];
3158                 }
3159             }
3160         }
3161         /* save AC coeffs for further prediction */
3162         for(k = 1; k < 8; k++) {
3163             ac_val2[k] = block[k << 3];
3164             ac_val2[k + 8] = block[k];
3165         }
3166
3167         /* scale AC coeffs */
3168         for(k = 1; k < 64; k++)
3169             if(block[k]) {
3170                 block[k] *= scale;
3171                 if(!v->pquantizer)
3172                     block[k] += (block[k] < 0) ? -mquant : mquant;
3173             }
3174
3175         if(use_pred) i = 63;
3176     } else { // no AC coeffs
3177         int k;
3178
3179         memset(ac_val2, 0, 16 * 2);
3180         if(dc_pred_dir) {//left
3181             if(use_pred) {
3182                 memcpy(ac_val2, ac_val, 8 * 2);
3183                 if(q2 && q1!=q2) {
3184                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3185                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3186                     for(k = 1; k < 8; k++)
3187                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3188                 }
3189             }
3190         } else {//top
3191             if(use_pred) {
3192                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3193                 if(q2 && q1!=q2) {
3194                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3195                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3196                     for(k = 1; k < 8; k++)
3197                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3198                 }
3199             }
3200         }
3201
3202         /* apply AC prediction if needed */
3203         if(use_pred) {
3204             if(dc_pred_dir) { //left
3205                 for(k = 1; k < 8; k++) {
3206                     block[k << 3] = ac_val2[k] * scale;
3207                     if(!v->pquantizer && block[k << 3])
3208                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3209                 }
3210             } else { //top
3211                 for(k = 1; k < 8; k++) {
3212                     block[k] = ac_val2[k + 8] * scale;
3213                     if(!v->pquantizer && block[k])
3214                         block[k] += (block[k] < 0) ? -mquant : mquant;
3215                 }
3216             }
3217             i = 63;
3218         }
3219     }
3220     s->block_last_index[n] = i;
3221
3222     return 0;
3223 }
3224
3225 /** Decode P block
3226  */
3227 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
3228 {
3229     MpegEncContext *s = &v->s;
3230     GetBitContext *gb = &s->gb;
3231     int i, j;
3232     int subblkpat = 0;
3233     int scale, off, idx, last, skip, value;
3234     int ttblk = ttmb & 7;
3235
3236     if(ttmb == -1) {
3237         ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
3238     }
3239     if(ttblk == TT_4X4) {
3240         subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3241     }
3242     if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
3243         subblkpat = decode012(gb);
3244         if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
3245         if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
3246         if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
3247     }
3248     scale = 2 * mquant + v->halfpq;
3249
3250     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3251     if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3252         subblkpat = 2 - (ttblk == TT_8X4_TOP);
3253         ttblk = TT_8X4;
3254     }
3255     if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3256         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3257         ttblk = TT_4X8;
3258     }
3259     switch(ttblk) {
3260     case TT_8X8:
3261         i = 0;
3262         last = 0;
3263         while (!last) {
3264             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3265             i += skip;
3266             if(i > 63)
3267                 break;
3268             idx = vc1_simple_progressive_8x8_zz[i++];
3269             block[idx] = value * scale;
3270             if(!v->pquantizer)
3271                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3272         }
3273         s->dsp.vc1_inv_trans_8x8(block);
3274         break;
3275     case TT_4X4:
3276         for(j = 0; j < 4; j++) {
3277             last = subblkpat & (1 << (3 - j));
3278             i = 0;
3279             off = (j & 1) * 4 + (j & 2) * 16;
3280             while (!last) {
3281                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3282                 i += skip;
3283                 if(i > 15)
3284                     break;
3285                 idx = vc1_simple_progressive_4x4_zz[i++];
3286                 block[idx + off] = value * scale;
3287                 if(!v->pquantizer)
3288                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3289             }
3290             if(!(subblkpat & (1 << (3 - j))))
3291                 s->dsp.vc1_inv_trans_4x4(block, j);
3292         }
3293         break;
3294     case TT_8X4:
3295         for(j = 0; j < 2; j++) {
3296             last = subblkpat & (1 << (1 - j));
3297             i = 0;
3298             off = j * 32;
3299             while (!last) {
3300                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3301                 i += skip;
3302                 if(i > 31)
3303                     break;
3304                 if(v->profile < PROFILE_ADVANCED)
3305                     idx = vc1_simple_progressive_8x4_zz[i++];
3306                 else
3307                     idx = vc1_adv_progressive_8x4_zz[i++];
3308                 block[idx + off] = value * scale;
3309                 if(!v->pquantizer)
3310                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3311             }
3312             if(!(subblkpat & (1 << (1 - j))))
3313                 s->dsp.vc1_inv_trans_8x4(block, j);
3314         }
3315         break;
3316     case TT_4X8:
3317         for(j = 0; j < 2; j++) {
3318             last = subblkpat & (1 << (1 - j));
3319             i = 0;
3320             off = j * 4;
3321             while (!last) {
3322                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3323                 i += skip;
3324                 if(i > 31)
3325                     break;
3326                 if(v->profile < PROFILE_ADVANCED)
3327                     idx = vc1_simple_progressive_4x8_zz[i++];
3328                 else
3329                     idx = vc1_adv_progressive_4x8_zz[i++];
3330                 block[idx + off] = value * scale;
3331                 if(!v->pquantizer)
3332                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3333             }
3334             if(!(subblkpat & (1 << (1 - j))))
3335                 s->dsp.vc1_inv_trans_4x8(block, j);
3336         }
3337         break;
3338     }
3339     return 0;
3340 }
3341
3342
3343 /** Decode one P-frame MB (in Simple/Main profile)
3344  */
3345 static int vc1_decode_p_mb(VC1Context *v)
3346 {
3347     MpegEncContext *s = &v->s;
3348     GetBitContext *gb = &s->gb;
3349     int i, j;
3350     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3351     int cbp; /* cbp decoding stuff */
3352     int mqdiff, mquant; /* MB quantization */
3353     int ttmb = v->ttfrm; /* MB Transform type */
3354     int status;
3355
3356     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3357       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3358     int mb_has_coeffs = 1; /* last_flag */
3359     int dmv_x, dmv_y; /* Differential MV components */
3360     int index, index1; /* LUT indices */
3361     int val, sign; /* temp values */
3362     int first_block = 1;
3363     int dst_idx, off;
3364     int skipped, fourmv;
3365
3366     mquant = v->pq; /* Loosy initialization */
3367
3368     if (v->mv_type_is_raw)
3369         fourmv = get_bits1(gb);
3370     else
3371         fourmv = v->mv_type_mb_plane[mb_pos];
3372     if (v->skip_is_raw)
3373         skipped = get_bits1(gb);
3374     else
3375         skipped = v->s.mbskip_table[mb_pos];
3376
3377     s->dsp.clear_blocks(s->block[0]);
3378
3379     if (!fourmv) /* 1MV mode */
3380     {
3381         if (!skipped)
3382         {
3383             GET_MVDATA(dmv_x, dmv_y);
3384
3385             if (s->mb_intra) {
3386                 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3387                 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3388             }
3389             s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3390             vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3391
3392             /* FIXME Set DC val for inter block ? */
3393             if (s->mb_intra && !mb_has_coeffs)
3394             {
3395                 GET_MQUANT();
3396                 s->ac_pred = get_bits(gb, 1);
3397                 cbp = 0;
3398             }
3399             else if (mb_has_coeffs)
3400             {
3401                 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
3402                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3403                 GET_MQUANT();
3404             }
3405             else
3406             {
3407                 mquant = v->pq;
3408                 cbp = 0;
3409             }
3410             s->current_picture.qscale_table[mb_pos] = mquant;
3411
3412             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3413                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
3414                                 VC1_TTMB_VLC_BITS, 2);
3415             if(!s->mb_intra) vc1_mc_1mv(v, 0);
3416             dst_idx = 0;
3417             for (i=0; i<6; i++)
3418             {
3419                 s->dc_val[0][s->block_index[i]] = 0;
3420                 dst_idx += i >> 2;
3421                 val = ((cbp >> (5 - i)) & 1);
3422                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3423                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3424                 if(s->mb_intra) {
3425                     /* check if prediction blocks A and C are available */
3426                     v->a_avail = v->c_avail = 0;
3427                     if(i == 2 || i == 3 || !s->first_slice_line)
3428                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3429                     if(i == 1 || i == 3 || s->mb_x)
3430                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3431
3432                     vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3433                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3434                     s->dsp.vc1_inv_trans_8x8(s->block[i]);
3435                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3436                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
3437                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3438                     if(v->pq >= 9 && v->overlap) {
3439                         if(v->c_avail)
3440                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3441                         if(v->a_avail)
3442                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3443                     }
3444                 } else if(val) {
3445                     vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3446                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
3447                     first_block = 0;
3448                     if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3449                         s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3450                 }
3451             }
3452         }
3453         else //Skipped
3454         {
3455             s->mb_intra = 0;
3456             for(i = 0; i < 6; i++) {
3457                 v->mb_type[0][s->block_index[i]] = 0;
3458                 s->dc_val[0][s->block_index[i]] = 0;
3459             }
3460             s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3461             s->current_picture.qscale_table[mb_pos] = 0;
3462             vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3463             vc1_mc_1mv(v, 0);
3464             return 0;
3465         }
3466     } //1MV mode
3467     else //4MV mode
3468     {
3469         if (!skipped /* unskipped MB */)
3470         {
3471             int intra_count = 0, coded_inter = 0;
3472             int is_intra[6], is_coded[6];
3473             /* Get CBPCY */
3474             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3475             for (i=0; i<6; i++)
3476             {
3477                 val = ((cbp >> (5 - i)) & 1);
3478                 s->dc_val[0][s->block_index[i]] = 0;
3479                 s->mb_intra = 0;
3480                 if(i < 4) {
3481                     dmv_x = dmv_y = 0;
3482                     s->mb_intra = 0;
3483                     mb_has_coeffs = 0;
3484                     if(val) {
3485                         GET_MVDATA(dmv_x, dmv_y);
3486                     }
3487                     vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3488                     if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
3489                     intra_count += s->mb_intra;
3490                     is_intra[i] = s->mb_intra;
3491                     is_coded[i] = mb_has_coeffs;
3492                 }
3493                 if(i&4){
3494                     is_intra[i] = (intra_count >= 3);
3495                     is_coded[i] = val;
3496                 }
3497                 if(i == 4) vc1_mc_4mv_chroma(v);
3498                 v->mb_type[0][s->block_index[i]] = is_intra[i];
3499                 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
3500             }
3501             // if there are no coded blocks then don't do anything more
3502             if(!intra_count && !coded_inter) return 0;
3503             dst_idx = 0;
3504             GET_MQUANT();
3505             s->current_picture.qscale_table[mb_pos] = mquant;
3506             /* test if block is intra and has pred */
3507             {
3508                 int intrapred = 0;
3509                 for(i=0; i<6; i++)
3510                     if(is_intra[i]) {
3511                         if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3512                             || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
3513                             intrapred = 1;
3514                             break;
3515                         }
3516                     }
3517                 if(intrapred)s->ac_pred = get_bits(gb, 1);
3518                 else s->ac_pred = 0;
3519             }
3520             if (!v->ttmbf && coded_inter)
3521                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3522             for (i=0; i<6; i++)
3523             {
3524                 dst_idx += i >> 2;
3525                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3526                 s->mb_intra = is_intra[i];
3527                 if (is_intra[i]) {
3528                     /* check if prediction blocks A and C are available */
3529                     v->a_avail = v->c_avail = 0;
3530                     if(i == 2 || i == 3 || !s->first_slice_line)
3531                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3532                     if(i ==&nb