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