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