Correct edge MC for chroma
[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 = 3 //XXX: ??
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 /** The VC1 Context
213  * @fixme Change size wherever another size is more efficient
214  * Many members are only used for Advanced Profile
215  */
216 typedef struct VC1Context{
217     MpegEncContext s;
218
219     int bits;
220
221     /** Simple/Main Profile sequence header */
222     //@{
223     int res_sm;           ///< reserved, 2b
224     int res_x8;           ///< reserved
225     int multires;         ///< frame-level RESPIC syntax element present
226     int res_fasttx;       ///< reserved, always 1
227     int res_transtab;     ///< reserved, always 0
228     int rangered;         ///< RANGEREDFRM (range reduction) syntax element present
229                           ///< at frame level
230     int res_rtm_flag;     ///< reserved, set to 1
231     int reserved;         ///< reserved
232     //@}
233
234     /** Advanced Profile */
235     //@{
236     int level;            ///< 3bits, for Advanced/Simple Profile, provided by TS layer
237     int chromaformat;     ///< 2bits, 2=4:2:0, only defined
238     int postprocflag;     ///< Per-frame processing suggestion flag present
239     int broadcast;        ///< TFF/RFF present
240     int interlace;        ///< Progressive/interlaced (RPTFTM syntax element)
241     int tfcntrflag;       ///< TFCNTR present
242     int panscanflag;      ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
243     int extended_dmv;     ///< Additional extended dmv range at P/B frame-level
244     int color_prim;       ///< 8bits, chroma coordinates of the color primaries
245     int transfer_char;    ///< 8bits, Opto-electronic transfer characteristics
246     int matrix_coef;      ///< 8bits, Color primaries->YCbCr transform matrix
247     int hrd_param_flag;   ///< Presence of Hypothetical Reference
248                           ///< Decoder parameters
249     //@}
250
251     /** Sequence header data for all Profiles
252      * TODO: choose between ints, uint8_ts and monobit flags
253      */
254     //@{
255     int profile;          ///< 2bits, Profile
256     int frmrtq_postproc;  ///< 3bits,
257     int bitrtq_postproc;  ///< 5bits, quantized framerate-based postprocessing strength
258     int fastuvmc;         ///< Rounding of qpel vector to hpel ? (not in Simple)
259     int extended_mv;      ///< Ext MV in P/B (not in Simple)
260     int dquant;           ///< How qscale varies with MBs, 2bits (not in Simple)
261     int vstransform;      ///< variable-size [48]x[48] transform type + info
262     int overlap;          ///< overlapped transforms in use
263     int quantizer_mode;   ///< 2bits, quantizer mode used for sequence, see QUANT_*
264     int finterpflag;      ///< INTERPFRM present
265     //@}
266
267     /** Frame decoding info for all profiles */
268     //@{
269     uint8_t mv_mode;      ///< MV coding monde
270     uint8_t mv_mode2;     ///< Secondary MV coding mode (B frames)
271     int k_x;              ///< Number of bits for MVs (depends on MV range)
272     int k_y;              ///< Number of bits for MVs (depends on MV range)
273     int range_x, range_y; ///< MV range
274     uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale
275     /** pquant parameters */
276     //@{
277     uint8_t dquantfrm;
278     uint8_t dqprofile;
279     uint8_t dqsbedge;
280     uint8_t dqbilevel;
281     //@}
282     /** AC coding set indexes
283      * @see 8.1.1.10, p(1)10
284      */
285     //@{
286     int c_ac_table_index; ///< Chroma index from ACFRM element
287     int y_ac_table_index; ///< Luma index from AC2FRM element
288     //@}
289     int ttfrm;            ///< Transform type info present at frame level
290     uint8_t ttmbf;        ///< Transform type flag
291     uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
292     int codingset;        ///< index of current table set from 11.8 to use for luma block decoding
293     int codingset2;       ///< index of current table set from 11.8 to use for chroma block decoding
294     int pqindex;          ///< raw pqindex used in coding set selection
295     int a_avail, c_avail;
296     uint8_t *mb_type_base, *mb_type[3];
297
298
299     /** Luma compensation parameters */
300     //@{
301     uint8_t lumscale;
302     uint8_t lumshift;
303     //@}
304     int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs
305     uint8_t halfpq;       ///< Uniform quant over image and qp+.5
306     uint8_t respic;       ///< Frame-level flag for resized images
307     int buffer_fullness;  ///< HRD info
308     /** Ranges:
309      * -# 0 -> [-64n 63.f] x [-32, 31.f]
310      * -# 1 -> [-128, 127.f] x [-64, 63.f]
311      * -# 2 -> [-512, 511.f] x [-128, 127.f]
312      * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
313      */
314     uint8_t mvrange;
315     uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use
316     VLC *cbpcy_vlc;               ///< CBPCY VLC table
317     int tt_index;                 ///< Index for Transform Type tables
318     uint8_t* mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)
319 //    BitPlane direct_mb_plane;     ///< bitplane for "direct" MBs
320     int mv_type_is_raw;           ///< mv type mb plane is not coded
321     int skip_is_raw;              ///< skip mb plane is not coded
322     uint8_t luty[256], lutuv[256]; // lookup tables used for intensity compensation
323     int rnd;                      ///< rounding control
324
325     /** Frame decoding info for S/M profiles only */
326     //@{
327     uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
328     uint8_t interpfrm;
329     //@}
330
331     /** Frame decoding info for Advanced profile */
332     //@{
333     uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
334     uint8_t numpanscanwin;
335     uint8_t tfcntr;
336     uint8_t rptfrm, tff, rff;
337     uint16_t topleftx;
338     uint16_t toplefty;
339     uint16_t bottomrightx;
340     uint16_t bottomrighty;
341     uint8_t uvsamp;
342     uint8_t postproc;
343     int hrd_num_leaky_buckets;
344     uint8_t bit_rate_exponent;
345     uint8_t buffer_size_exponent;
346 //    BitPlane ac_pred_plane;       ///< AC prediction flags bitplane
347 //    BitPlane over_flags_plane;    ///< Overflags bitplane
348     uint8_t condover;
349     uint16_t *hrd_rate, *hrd_buffer;
350     uint8_t *hrd_fullness;
351     uint8_t range_mapy_flag;
352     uint8_t range_mapuv_flag;
353     uint8_t range_mapy;
354     uint8_t range_mapuv;
355     //@}
356 } VC1Context;
357
358 /**
359  * Get unary code of limited length
360  * @fixme FIXME Slow and ugly
361  * @param gb GetBitContext
362  * @param[in] stop The bitstop value (unary code of 1's or 0's)
363  * @param[in] len Maximum length
364  * @return Unary length/index
365  */
366 static int get_prefix(GetBitContext *gb, int stop, int len)
367 {
368 #if 1
369     int i;
370
371     for(i = 0; i < len && get_bits1(gb) != stop; i++);
372     return i;
373 /*  int i = 0, tmp = !stop;
374
375   while (i != len && tmp != stop)
376   {
377     tmp = get_bits(gb, 1);
378     i++;
379   }
380   if (i == len && tmp != stop) return len+1;
381   return i;*/
382 #else
383   unsigned int buf;
384   int log;
385
386   OPEN_READER(re, gb);
387   UPDATE_CACHE(re, gb);
388   buf=GET_CACHE(re, gb); //Still not sure
389   if (stop) buf = ~buf;
390
391   log= av_log2(-buf); //FIXME: -?
392   if (log < limit){
393     LAST_SKIP_BITS(re, gb, log+1);
394     CLOSE_READER(re, gb);
395     return log;
396   }
397
398   LAST_SKIP_BITS(re, gb, limit);
399   CLOSE_READER(re, gb);
400   return limit;
401 #endif
402 }
403
404 static inline int decode210(GetBitContext *gb){
405     int n;
406     n = get_bits1(gb);
407     if (n == 1)
408         return 0;
409     else
410         return 2 - get_bits1(gb);
411 }
412
413 /**
414  * Init VC-1 specific tables and VC1Context members
415  * @param v The VC1Context to initialize
416  * @return Status
417  */
418 static int vc1_init_common(VC1Context *v)
419 {
420     static int done = 0;
421     int i = 0;
422
423     v->hrd_rate = v->hrd_buffer = NULL;
424
425     /* VLC tables */
426     if(!done)
427     {
428         done = 1;
429         init_vlc(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
430                  vc1_bfraction_bits, 1, 1,
431                  vc1_bfraction_codes, 1, 1, 1);
432         init_vlc(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
433                  vc1_norm2_bits, 1, 1,
434                  vc1_norm2_codes, 1, 1, 1);
435         init_vlc(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
436                  vc1_norm6_bits, 1, 1,
437                  vc1_norm6_codes, 2, 2, 1);
438         init_vlc(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
439                  vc1_imode_bits, 1, 1,
440                  vc1_imode_codes, 1, 1, 1);
441         for (i=0; i<3; i++)
442         {
443             init_vlc(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
444                      vc1_ttmb_bits[i], 1, 1,
445                      vc1_ttmb_codes[i], 2, 2, 1);
446             init_vlc(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
447                      vc1_ttblk_bits[i], 1, 1,
448                      vc1_ttblk_codes[i], 1, 1, 1);
449             init_vlc(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
450                      vc1_subblkpat_bits[i], 1, 1,
451                      vc1_subblkpat_codes[i], 1, 1, 1);
452         }
453         for(i=0; i<4; i++)
454         {
455             init_vlc(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
456                      vc1_4mv_block_pattern_bits[i], 1, 1,
457                      vc1_4mv_block_pattern_codes[i], 1, 1, 1);
458             init_vlc(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
459                      vc1_cbpcy_p_bits[i], 1, 1,
460                      vc1_cbpcy_p_codes[i], 2, 2, 1);
461             init_vlc(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
462                      vc1_mv_diff_bits[i], 1, 1,
463                      vc1_mv_diff_codes[i], 2, 2, 1);
464         }
465         for(i=0; i<8; i++)
466             init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
467                      &vc1_ac_tables[i][0][1], 8, 4,
468                      &vc1_ac_tables[i][0][0], 8, 4, 1);
469         init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
470                  &ff_msmp4_mb_i_table[0][1], 4, 2,
471                  &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
472     }
473
474     /* Other defaults */
475     v->pq = -1;
476     v->mvrange = 0; /* 7.1.1.18, p80 */
477
478     return 0;
479 }
480
481 /***********************************************************************/
482 /**
483  * @defgroup bitplane VC9 Bitplane decoding
484  * @see 8.7, p56
485  * @{
486  */
487
488 /** @addtogroup bitplane
489  * Imode types
490  * @{
491  */
492 enum Imode {
493     IMODE_RAW,
494     IMODE_NORM2,
495     IMODE_DIFF2,
496     IMODE_NORM6,
497     IMODE_DIFF6,
498     IMODE_ROWSKIP,
499     IMODE_COLSKIP
500 };
501 /** @} */ //imode defines
502
503 /** Decode rows by checking if they are skipped
504  * @param plane Buffer to store decoded bits
505  * @param[in] width Width of this buffer
506  * @param[in] height Height of this buffer
507  * @param[in] stride of this buffer
508  */
509 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
510     int x, y;
511
512     for (y=0; y<height; y++){
513         if (!get_bits(gb, 1)) //rowskip
514             memset(plane, 0, width);
515         else
516             for (x=0; x<width; x++)
517                 plane[x] = get_bits(gb, 1);
518         plane += stride;
519     }
520 }
521
522 /** Decode columns by checking if they are skipped
523  * @param plane Buffer to store decoded bits
524  * @param[in] width Width of this buffer
525  * @param[in] height Height of this buffer
526  * @param[in] stride of this buffer
527  * @fixme FIXME: Optimize
528  */
529 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
530     int x, y;
531
532     for (x=0; x<width; x++){
533         if (!get_bits(gb, 1)) //colskip
534             for (y=0; y<height; y++)
535                 plane[y*stride] = 0;
536         else
537             for (y=0; y<height; y++)
538                 plane[y*stride] = get_bits(gb, 1);
539         plane ++;
540     }
541 }
542
543 /** Decode a bitplane's bits
544  * @param bp Bitplane where to store the decode bits
545  * @param v VC-1 context for bit reading and logging
546  * @return Status
547  * @fixme FIXME: Optimize
548  * @todo TODO: Decide if a struct is needed
549  */
550 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
551 {
552     GetBitContext *gb = &v->s.gb;
553
554     int imode, x, y, code, offset;
555     uint8_t invert, *planep = data;
556     int width, height, stride;
557
558     width = v->s.mb_width;
559     height = v->s.mb_height;
560     stride = v->s.mb_stride;
561     invert = get_bits(gb, 1);
562     imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
563
564     *raw_flag = 0;
565     switch (imode)
566     {
567     case IMODE_RAW:
568         //Data is actually read in the MB layer (same for all tests == "raw")
569         *raw_flag = 1; //invert ignored
570         return invert;
571     case IMODE_DIFF2:
572     case IMODE_NORM2:
573         if ((height * width) & 1)
574         {
575             *planep++ = get_bits(gb, 1);
576             offset = 1;
577         }
578         else offset = 0;
579         // decode bitplane as one long line
580         for (y = offset; y < height * width; y += 2) {
581             code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
582             *planep++ = code & 1;
583             offset++;
584             if(offset == width) {
585                 offset = 0;
586                 planep += stride - width;
587             }
588             *planep++ = code >> 1;
589             offset++;
590             if(offset == width) {
591                 offset = 0;
592                 planep += stride - width;
593             }
594         }
595         break;
596     case IMODE_DIFF6:
597     case IMODE_NORM6:
598         if(!(height % 3) && (width % 3)) { // use 2x3 decoding
599             for(y = 0; y < height; y+= 3) {
600                 for(x = width & 1; x < width; x += 2) {
601                     code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
602                     if(code < 0){
603                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
604                         return -1;
605                     }
606                     planep[x + 0] = (code >> 0) & 1;
607                     planep[x + 1] = (code >> 1) & 1;
608                     planep[x + 0 + stride] = (code >> 2) & 1;
609                     planep[x + 1 + stride] = (code >> 3) & 1;
610                     planep[x + 0 + stride * 2] = (code >> 4) & 1;
611                     planep[x + 1 + stride * 2] = (code >> 5) & 1;
612                 }
613                 planep += stride * 3;
614             }
615             if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
616         } else { // 3x2
617             planep += (height & 1) * stride;
618             for(y = height & 1; y < height; y += 2) {
619                 for(x = width % 3; x < width; x += 3) {
620                     code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
621                     if(code < 0){
622                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
623                         return -1;
624                     }
625                     planep[x + 0] = (code >> 0) & 1;
626                     planep[x + 1] = (code >> 1) & 1;
627                     planep[x + 2] = (code >> 2) & 1;
628                     planep[x + 0 + stride] = (code >> 3) & 1;
629                     planep[x + 1 + stride] = (code >> 4) & 1;
630                     planep[x + 2 + stride] = (code >> 5) & 1;
631                 }
632                 planep += stride * 2;
633             }
634             x = width % 3;
635             if(x) decode_colskip(data  ,             x, height    , stride, &v->s.gb);
636             if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
637         }
638         break;
639     case IMODE_ROWSKIP:
640         decode_rowskip(data, width, height, stride, &v->s.gb);
641         break;
642     case IMODE_COLSKIP:
643         decode_colskip(data, width, height, stride, &v->s.gb);
644         break;
645     default: break;
646     }
647
648     /* Applying diff operator */
649     if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
650     {
651         planep = data;
652         planep[0] ^= invert;
653         for (x=1; x<width; x++)
654             planep[x] ^= planep[x-1];
655         for (y=1; y<height; y++)
656         {
657             planep += stride;
658             planep[0] ^= planep[-stride];
659             for (x=1; x<width; x++)
660             {
661                 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
662                 else                                 planep[x] ^= planep[x-1];
663             }
664         }
665     }
666     else if (invert)
667     {
668         planep = data;
669         for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
670     }
671     return (imode<<1) + invert;
672 }
673
674 /** @} */ //Bitplane group
675
676 /***********************************************************************/
677 /** VOP Dquant decoding
678  * @param v VC-1 Context
679  */
680 static int vop_dquant_decoding(VC1Context *v)
681 {
682     GetBitContext *gb = &v->s.gb;
683     int pqdiff;
684
685     //variable size
686     if (v->dquant == 2)
687     {
688         pqdiff = get_bits(gb, 3);
689         if (pqdiff == 7) v->altpq = get_bits(gb, 5);
690         else v->altpq = v->pq + pqdiff + 1;
691     }
692     else
693     {
694         v->dquantfrm = get_bits(gb, 1);
695         if ( v->dquantfrm )
696         {
697             v->dqprofile = get_bits(gb, 2);
698             switch (v->dqprofile)
699             {
700             case DQPROFILE_SINGLE_EDGE:
701             case DQPROFILE_DOUBLE_EDGES:
702                 v->dqsbedge = get_bits(gb, 2);
703                 break;
704             case DQPROFILE_ALL_MBS:
705                 v->dqbilevel = get_bits(gb, 1);
706             default: break; //Forbidden ?
707             }
708             if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
709             {
710                 pqdiff = get_bits(gb, 3);
711                 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
712                 else v->altpq = v->pq + pqdiff + 1;
713             }
714         }
715     }
716     return 0;
717 }
718
719
720 /** Do inverse transform
721  */
722 static void vc1_inv_trans(DCTELEM block[64], int M, int N)
723 {
724     int i;
725     register int t1,t2,t3,t4,t5,t6,t7,t8;
726     DCTELEM *src, *dst;
727
728     src = block;
729     dst = block;
730     if(M==4){
731         for(i = 0; i < N; i++){
732             t1 = 17 * (src[0] + src[2]);
733             t2 = 17 * (src[0] - src[2]);
734             t3 = 22 * src[1];
735             t4 = 22 * src[3];
736             t5 = 10 * src[1];
737             t6 = 10 * src[3];
738
739             dst[0] = (t1 + t3 + t6 + 4) >> 3;
740             dst[1] = (t2 - t4 + t5 + 4) >> 3;
741             dst[2] = (t2 + t4 - t5 + 4) >> 3;
742             dst[3] = (t1 - t3 - t6 + 4) >> 3;
743
744             src += 8;
745             dst += 8;
746         }
747     }else{
748         for(i = 0; i < N; i++){
749             t1 = 12 * (src[0] + src[4]);
750             t2 = 12 * (src[0] - src[4]);
751             t3 = 16 * src[2] +  6 * src[6];
752             t4 =  6 * src[2] - 16 * src[6];
753
754             t5 = t1 + t3;
755             t6 = t2 + t4;
756             t7 = t2 - t4;
757             t8 = t1 - t3;
758
759             t1 = 16 * src[1] + 15 * src[3] +  9 * src[5] +  4 * src[7];
760             t2 = 15 * src[1] -  4 * src[3] - 16 * src[5] -  9 * src[7];
761             t3 =  9 * src[1] - 16 * src[3] +  4 * src[5] + 15 * src[7];
762             t4 =  4 * src[1] -  9 * src[3] + 15 * src[5] - 16 * src[7];
763
764             dst[0] = (t5 + t1 + 4) >> 3;
765             dst[1] = (t6 + t2 + 4) >> 3;
766             dst[2] = (t7 + t3 + 4) >> 3;
767             dst[3] = (t8 + t4 + 4) >> 3;
768             dst[4] = (t8 - t4 + 4) >> 3;
769             dst[5] = (t7 - t3 + 4) >> 3;
770             dst[6] = (t6 - t2 + 4) >> 3;
771             dst[7] = (t5 - t1 + 4) >> 3;
772
773             src += 8;
774             dst += 8;
775         }
776     }
777
778     src = block;
779     dst = block;
780     if(N==4){
781         for(i = 0; i < M; i++){
782             t1 = 17 * (src[ 0] + src[16]);
783             t2 = 17 * (src[ 0] - src[16]);
784             t3 = 22 * src[ 8];
785             t4 = 22 * src[24];
786             t5 = 10 * src[ 8];
787             t6 = 10 * src[24];
788
789             dst[ 0] = (t1 + t3 + t6 + 64) >> 7;
790             dst[ 8] = (t2 - t4 + t5 + 64) >> 7;
791             dst[16] = (t2 + t4 - t5 + 64) >> 7;
792             dst[24] = (t1 - t3 - t6 + 64) >> 7;
793
794             src ++;
795             dst ++;
796         }
797     }else{
798         for(i = 0; i < M; i++){
799             t1 = 12 * (src[ 0] + src[32]);
800             t2 = 12 * (src[ 0] - src[32]);
801             t3 = 16 * src[16] +  6 * src[48];
802             t4 =  6 * src[16] - 16 * src[48];
803
804             t5 = t1 + t3;
805             t6 = t2 + t4;
806             t7 = t2 - t4;
807             t8 = t1 - t3;
808
809             t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
810             t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
811             t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
812             t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
813
814             dst[ 0] = (t5 + t1 + 64) >> 7;
815             dst[ 8] = (t6 + t2 + 64) >> 7;
816             dst[16] = (t7 + t3 + 64) >> 7;
817             dst[24] = (t8 + t4 + 64) >> 7;
818             dst[32] = (t8 - t4 + 64 + 1) >> 7;
819             dst[40] = (t7 - t3 + 64 + 1) >> 7;
820             dst[48] = (t6 - t2 + 64 + 1) >> 7;
821             dst[56] = (t5 - t1 + 64 + 1) >> 7;
822
823             src++;
824             dst++;
825         }
826     }
827 }
828
829 /** Apply overlap transform to vertical edge
830  * @todo optimize
831  * @todo move to DSPContext
832  */
833 static void vc1_v_overlap(uint8_t* src, int stride)
834 {
835     int i;
836     int a, b, c, d;
837     for(i = 0; i < 8; i++) {
838         a = src[-2*stride];
839         b = src[-stride];
840         c = src[0];
841         d = src[stride];
842
843         src[-2*stride] = clip_uint8((7*a + d + 3) >> 3);
844         src[-stride] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
845         src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
846         src[stride] = clip_uint8((a + 7*d + 3) >> 3);
847         src++;
848     }
849 }
850
851 /** Apply overlap transform to horizontal edge
852  * @todo optimize
853  * @todo move to DSPContext
854  */
855 static void vc1_h_overlap(uint8_t* src, int stride)
856 {
857     int i;
858     int a, b, c, d;
859     for(i = 0; i < 8; i++) {
860         a = src[-2];
861         b = src[-1];
862         c = src[0];
863         d = src[1];
864
865         src[-2] = clip_uint8((7*a + d + 3) >> 3);
866         src[-1] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
867         src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
868         src[1] = clip_uint8((a + 7*d + 3) >> 3);
869         src += stride;
870     }
871 }
872
873 /** Put block onto picture
874  * @todo move to DSPContext
875  */
876 static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
877 {
878     uint8_t *Y;
879     int ys, us, vs;
880     DSPContext *dsp = &v->s.dsp;
881
882     ys = v->s.current_picture.linesize[0];
883     us = v->s.current_picture.linesize[1];
884     vs = v->s.current_picture.linesize[2];
885     Y = v->s.dest[0];
886
887     dsp->put_pixels_clamped(block[0], Y, ys);
888     dsp->put_pixels_clamped(block[1], Y + 8, ys);
889     Y += ys * 8;
890     dsp->put_pixels_clamped(block[2], Y, ys);
891     dsp->put_pixels_clamped(block[3], Y + 8, ys);
892
893     dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
894     dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
895 }
896
897 /** Do motion compensation over 1 macroblock
898  * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
899  */
900 static void vc1_mc_1mv(VC1Context *v)
901 {
902     MpegEncContext *s = &v->s;
903     DSPContext *dsp = &v->s.dsp;
904     uint8_t *srcY, *srcU, *srcV;
905     int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
906
907     if(!v->s.last_picture.data[0])return;
908
909     mx = s->mv[0][0][0];
910     my = s->mv[0][0][1];
911     uvmx = (mx + ((mx & 3) == 3)) >> 1;
912     uvmy = (my + ((my & 3) == 3)) >> 1;
913     srcY = s->last_picture.data[0];
914     srcU = s->last_picture.data[1];
915     srcV = s->last_picture.data[2];
916
917     src_x = s->mb_x * 16 + (mx >> 2);
918     src_y = s->mb_y * 16 + (my >> 2);
919     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
920     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
921
922     src_x   = clip(  src_x, -16, s->mb_width  * 16);
923     src_y   = clip(  src_y, -16, s->mb_height * 16);
924     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
925     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
926
927     srcY += src_y * s->linesize + src_x;
928     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
929     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
930
931     if((v->mv_mode == MV_PMODE_INTENSITY_COMP)
932        || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
933        || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
934         uint8_t *uvbuf= s->edge_emu_buffer + 18 * s->linesize;
935
936         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
937                             src_x, src_y, s->h_edge_pos, s->v_edge_pos);
938         srcY = s->edge_emu_buffer;
939         ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
940                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
941         ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
942                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
943         srcU = uvbuf;
944         srcV = uvbuf + 16;
945         /* if we deal with intensity compensation we need to scale source blocks */
946         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
947             int i, j;
948             uint8_t *src, *src2;
949
950             src = srcY;
951             for(j = 0; j < 17; j++) {
952                 for(i = 0; i < 17; i++) src[i] = v->luty[src[i]];
953                 src += s->linesize;
954             }
955             src = srcU; src2 = srcV;
956             for(j = 0; j < 9; j++) {
957                 for(i = 0; i < 9; i++) {
958                     src[i] = v->lutuv[src[i]];
959                     src2[i] = v->lutuv[src2[i]];
960                 }
961                 src += s->uvlinesize;
962                 src2 += s->uvlinesize;
963             }
964         }
965     }
966
967     if(v->fastuvmc) {
968         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
969         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
970     }
971
972     if(!s->quarter_sample) { // hpel mc
973         mx >>= 1;
974         my >>= 1;
975         dxy = ((my & 1) << 1) | (mx & 1);
976
977         if(!v->rnd)
978             dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
979         else
980             dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
981     } else {
982         dxy = ((my & 3) << 2) | (mx & 3);
983
984         if(!v->rnd)
985             dsp->put_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
986         else
987             dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
988     }
989     /* Chroma MC always uses qpel blilinear */
990     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
991     if(!v->rnd){
992         dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
993         dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
994     }else{
995         dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
996         dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
997     }
998 }
999
1000 /** Do motion compensation for 4-MV macroblock - luminance block
1001  */
1002 static void vc1_mc_4mv_luma(VC1Context *v, int n)
1003 {
1004     MpegEncContext *s = &v->s;
1005     DSPContext *dsp = &v->s.dsp;
1006     uint8_t *srcY;
1007     int dxy, mx, my, src_x, src_y;
1008     int off;
1009
1010     if(!v->s.last_picture.data[0])return;
1011     mx = s->mv[0][n][0];
1012     my = s->mv[0][n][1];
1013     srcY = s->last_picture.data[0];
1014
1015     off = s->linesize * 4 * (n&2) + (n&1) * 8;
1016
1017     src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
1018     src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
1019
1020     src_x   = clip(  src_x, -16, s->mb_width  * 16);
1021     src_y   = clip(  src_y, -16, s->mb_height * 16);
1022
1023     srcY += src_y * s->linesize + src_x;
1024
1025     if((unsigned)src_x > s->h_edge_pos - (mx&3) - 16
1026        || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
1027         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
1028                             src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1029         srcY = s->edge_emu_buffer;
1030     }
1031
1032     if(!s->quarter_sample) { // hpel mc
1033         mx >>= 1;
1034         my >>= 1;
1035         dxy = ((my & 1) << 1) | (mx & 1);
1036
1037         if(!v->rnd)
1038             dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1039         else
1040             dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1041     } else {
1042         dxy = ((my & 3) << 2) | (mx & 3);
1043
1044         if(!v->rnd)
1045             dsp->put_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
1046         else
1047             dsp->put_no_rnd_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
1048     }
1049 }
1050
1051 static inline int median4(int a, int b, int c, int d)
1052 {
1053     if(a < b) {
1054         if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
1055         else      return (FFMIN(b, c) + FFMAX(a, d)) / 2;
1056     } else {
1057         if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
1058         else      return (FFMIN(a, c) + FFMAX(b, d)) / 2;
1059     }
1060 }
1061
1062
1063 /** Do motion compensation for 4-MV macroblock - both chroma blocks
1064  */
1065 static void vc1_mc_4mv_chroma(VC1Context *v)
1066 {
1067     MpegEncContext *s = &v->s;
1068     DSPContext *dsp = &v->s.dsp;
1069     uint8_t *srcU, *srcV;
1070     int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1071     int i, idx, tx = 0, ty = 0;
1072     int mvx[4], mvy[4], intra[4];
1073     static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1074
1075     if(!v->s.last_picture.data[0])return;
1076
1077     for(i = 0; i < 4; i++) {
1078         mvx[i] = s->mv[0][i][0];
1079         mvy[i] = s->mv[0][i][1];
1080         intra[i] = v->mb_type[0][s->block_index[i]];
1081     }
1082
1083     /* calculate chroma MV vector from four luma MVs */
1084     idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1085     if(!idx) { // all blocks are inter
1086         tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1087         ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1088     } else if(count[idx] == 1) { // 3 inter blocks
1089         switch(idx) {
1090         case 0x1:
1091             tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1092             ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1093             break;
1094         case 0x2:
1095             tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1096             ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1097             break;
1098         case 0x4:
1099             tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1100             ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1101             break;
1102         case 0x8:
1103             tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1104             ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1105             break;
1106         }
1107     } else if(count[idx] == 2) {
1108         int t1 = 0, t2 = 0;
1109         for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1110         for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1111         tx = (mvx[t1] + mvx[t2]) / 2;
1112         ty = (mvy[t1] + mvy[t2]) / 2;
1113     } else
1114         return; //no need to do MC for inter blocks
1115
1116     uvmx = (tx + ((tx&3) == 3)) >> 1;
1117     uvmy = (ty + ((ty&3) == 3)) >> 1;
1118
1119     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1120     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1121
1122     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
1123     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
1124     srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1125     srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1126     if((unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
1127        || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
1128         ff_emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize, 8+1, 8+1,
1129                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1130         ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1131                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1132         srcU = s->edge_emu_buffer;
1133         srcV = s->edge_emu_buffer + 16;
1134     }
1135
1136     if(v->fastuvmc) {
1137         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1138         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1139     }
1140
1141     /* Chroma MC always uses qpel blilinear */
1142     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
1143     if(!v->rnd){
1144         dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
1145         dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1146     }else{
1147         dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
1148         dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1149     }
1150 }
1151
1152 /**
1153  * Decode Simple/Main Profiles sequence header
1154  * @see Figure 7-8, p16-17
1155  * @param avctx Codec context
1156  * @param gb GetBit context initialized from Codec context extra_data
1157  * @return Status
1158  */
1159 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1160 {
1161     VC1Context *v = avctx->priv_data;
1162
1163     av_log(avctx, AV_LOG_INFO, "Header: %0X\n", show_bits(gb, 32));
1164     v->profile = get_bits(gb, 2);
1165     if (v->profile == 2)
1166     {
1167         av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1168         return -1;
1169     }
1170
1171     if (v->profile == PROFILE_ADVANCED)
1172     {
1173         v->level = get_bits(gb, 3);
1174         if(v->level >= 5)
1175         {
1176             av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1177         }
1178         v->chromaformat = get_bits(gb, 2);
1179         if (v->chromaformat != 1)
1180         {
1181             av_log(avctx, AV_LOG_ERROR,
1182                    "Only 4:2:0 chroma format supported\n");
1183             return -1;
1184         }
1185     }
1186     else
1187     {
1188         v->res_sm = get_bits(gb, 2); //reserved
1189         if (v->res_sm)
1190         {
1191             av_log(avctx, AV_LOG_ERROR,
1192                    "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1193             return -1;
1194         }
1195     }
1196
1197     // (fps-2)/4 (->30)
1198     v->frmrtq_postproc = get_bits(gb, 3); //common
1199     // (bitrate-32kbps)/64kbps
1200     v->bitrtq_postproc = get_bits(gb, 5); //common
1201     v->s.loop_filter = get_bits(gb, 1); //common
1202     if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1203     {
1204         av_log(avctx, AV_LOG_ERROR,
1205                "LOOPFILTER shell not be enabled in simple profile\n");
1206     }
1207
1208     if (v->profile < PROFILE_ADVANCED)
1209     {
1210         v->res_x8 = get_bits(gb, 1); //reserved
1211         if (v->res_x8)
1212         {
1213             av_log(avctx, AV_LOG_ERROR,
1214                    "1 for reserved RES_X8 is forbidden\n");
1215             //return -1;
1216         }
1217         v->multires = get_bits(gb, 1);
1218         v->res_fasttx = get_bits(gb, 1);
1219         if (!v->res_fasttx)
1220         {
1221             av_log(avctx, AV_LOG_ERROR,
1222                    "0 for reserved RES_FASTTX is forbidden\n");
1223             //return -1;
1224         }
1225     }
1226
1227     v->fastuvmc =  get_bits(gb, 1); //common
1228     if (!v->profile && !v->fastuvmc)
1229     {
1230         av_log(avctx, AV_LOG_ERROR,
1231                "FASTUVMC unavailable in Simple Profile\n");
1232         return -1;
1233     }
1234     v->extended_mv =  get_bits(gb, 1); //common
1235     if (!v->profile && v->extended_mv)
1236     {
1237         av_log(avctx, AV_LOG_ERROR,
1238                "Extended MVs unavailable in Simple Profile\n");
1239         return -1;
1240     }
1241     v->dquant =  get_bits(gb, 2); //common
1242     v->vstransform =  get_bits(gb, 1); //common
1243
1244     if (v->profile < PROFILE_ADVANCED)
1245     {
1246         v->res_transtab = get_bits(gb, 1);
1247         if (v->res_transtab)
1248         {
1249             av_log(avctx, AV_LOG_ERROR,
1250                    "1 for reserved RES_TRANSTAB is forbidden\n");
1251             return -1;
1252         }
1253     }
1254
1255     v->overlap = get_bits(gb, 1); //common
1256
1257     if (v->profile < PROFILE_ADVANCED)
1258     {
1259         v->s.resync_marker = get_bits(gb, 1);
1260         v->rangered = get_bits(gb, 1);
1261         if (v->rangered && v->profile == PROFILE_SIMPLE)
1262         {
1263             av_log(avctx, AV_LOG_INFO,
1264                    "RANGERED should be set to 0 in simple profile\n");
1265         }
1266     }
1267
1268     v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1269     v->quantizer_mode = get_bits(gb, 2); //common
1270
1271     if (v->profile < PROFILE_ADVANCED)
1272     {
1273         v->finterpflag = get_bits(gb, 1); //common
1274         v->res_rtm_flag = get_bits(gb, 1); //reserved
1275         if (!v->res_rtm_flag)
1276         {
1277             av_log(avctx, AV_LOG_ERROR,
1278                    "0 for reserved RES_RTM_FLAG is forbidden\n");
1279             //return -1;
1280         }
1281         av_log(avctx, AV_LOG_DEBUG,
1282                "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1283                "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1284                "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1285                "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1286                v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1287                v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1288                v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1289                v->dquant, v->quantizer_mode, avctx->max_b_frames
1290                );
1291         return 0;
1292     }
1293     return -1;
1294 }
1295
1296
1297 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1298 {
1299     int pqindex, lowquant, status;
1300
1301     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1302     skip_bits(gb, 2); //framecnt unused
1303     v->rangeredfrm = 0;
1304     if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1305     v->s.pict_type = get_bits(gb, 1);
1306     if (v->s.avctx->max_b_frames) {
1307         if (!v->s.pict_type) {
1308             if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1309             else v->s.pict_type = B_TYPE;
1310         } else v->s.pict_type = P_TYPE;
1311     } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1312
1313     if(v->s.pict_type == I_TYPE)
1314         get_bits(gb, 7); // skip buffer fullness
1315
1316     /* calculate RND */
1317     if(v->s.pict_type == I_TYPE)
1318         v->rnd = 1;
1319     if(v->s.pict_type == P_TYPE)
1320         v->rnd ^= 1;
1321
1322     /* Quantizer stuff */
1323     pqindex = get_bits(gb, 5);
1324     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1325         v->pq = pquant_table[0][pqindex];
1326     else
1327         v->pq = pquant_table[1][pqindex];
1328
1329     v->pquantizer = 1;
1330     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1331         v->pquantizer = pqindex < 9;
1332     if (v->quantizer_mode == QUANT_NON_UNIFORM)
1333         v->pquantizer = 0;
1334     v->pqindex = pqindex;
1335     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1336     else v->halfpq = 0;
1337     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1338         v->pquantizer = get_bits(gb, 1);
1339     v->dquantfrm = 0;
1340     if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1341     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1342     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1343     v->range_x = 1 << (v->k_x - 1);
1344     v->range_y = 1 << (v->k_y - 1);
1345     if (v->profile == PROFILE_ADVANCED)
1346     {
1347         if (v->postprocflag) v->postproc = get_bits(gb, 1);
1348     }
1349     else
1350         if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1351
1352 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1353 //        (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1354
1355     //TODO: complete parsing for P/B/BI frames
1356     switch(v->s.pict_type) {
1357     case P_TYPE:
1358         if (v->pq < 5) v->tt_index = 0;
1359         else if(v->pq < 13) v->tt_index = 1;
1360         else v->tt_index = 2;
1361
1362         lowquant = (v->pq > 12) ? 0 : 1;
1363         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1364         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1365         {
1366             int scale, shift, i;
1367             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1368             v->lumscale = get_bits(gb, 6);
1369             v->lumshift = get_bits(gb, 6);
1370             /* fill lookup tables for intensity compensation */
1371             if(!v->lumscale) {
1372                 scale = -64;
1373                 shift = (255 - v->lumshift * 2) << 6;
1374                 if(v->lumshift > 31)
1375                     shift += 128 << 6;
1376             } else {
1377                 scale = v->lumscale + 32;
1378                 if(v->lumshift > 31)
1379                     shift = (v->lumshift - 64) << 6;
1380                 else
1381                     shift = v->lumshift << 6;
1382             }
1383             for(i = 0; i < 256; i++) {
1384                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1385                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1386             }
1387         }
1388         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1389             v->s.quarter_sample = 0;
1390         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1391             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1392                 v->s.quarter_sample = 0;
1393             else
1394                 v->s.quarter_sample = 1;
1395         } else
1396             v->s.quarter_sample = 1;
1397
1398         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1399                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1400                 || v->mv_mode == MV_PMODE_MIXED_MV)
1401         {
1402             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1403             if (status < 0) return -1;
1404             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1405                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1406         } else {
1407             v->mv_type_is_raw = 0;
1408             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1409         }
1410         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1411         if (status < 0) return -1;
1412         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1413                "Imode: %i, Invert: %i\n", status>>1, status&1);
1414
1415         /* Hopefully this is correct for P frames */
1416         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1417         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1418
1419         if (v->dquant)
1420         {
1421             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1422             vop_dquant_decoding(v);
1423         }
1424
1425         v->ttfrm = 0; //FIXME Is that so ?
1426         if (v->vstransform)
1427         {
1428             v->ttmbf = get_bits(gb, 1);
1429             if (v->ttmbf)
1430             {
1431                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1432             }
1433         } else {
1434             v->ttmbf = 1;
1435             v->ttfrm = TT_8X8;
1436         }
1437         break;
1438     case B_TYPE:
1439         break;
1440     }
1441
1442     /* AC Syntax */
1443     v->c_ac_table_index = decode012(gb);
1444     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1445     {
1446         v->y_ac_table_index = decode012(gb);
1447     }
1448     /* DC Syntax */
1449     v->s.dc_table_index = get_bits(gb, 1);
1450
1451     return 0;
1452 }
1453
1454 /***********************************************************************/
1455 /**
1456  * @defgroup block VC-1 Block-level functions
1457  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1458  * @todo TODO: Integrate to MpegEncContext facilities
1459  * @{
1460  */
1461
1462 /**
1463  * @def GET_MQUANT
1464  * @brief Get macroblock-level quantizer scale
1465  * @warning XXX: qdiff to the frame quant, not previous quant ?
1466  * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1467  */
1468 #define GET_MQUANT()                                           \
1469   if (v->dquantfrm)                                            \
1470   {                                                            \
1471     int edges = 0;                                             \
1472     if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1473     {                                                          \
1474       if (v->dqbilevel)                                        \
1475       {                                                        \
1476         mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
1477       }                                                        \
1478       else                                                     \
1479       {                                                        \
1480         mqdiff = get_bits(gb, 3);                              \
1481         if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1482         else mquant = get_bits(gb, 5);                         \
1483       }                                                        \
1484     }                                                          \
1485     if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
1486         edges = 1 << v->dqsbedge;                              \
1487     else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1488         edges = (3 << v->dqsbedge) % 15;                       \
1489     else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1490         edges = 15;                                            \
1491     if((edges&1) && !s->mb_x)                                  \
1492         mquant = v->altpq;                                     \
1493     if((edges&2) && s->first_slice_line)                       \
1494         mquant = v->altpq;                                     \
1495     if((edges&4) && s->mb_x == (s->mb_width - 1))              \
1496         mquant = v->altpq;                                     \
1497     if((edges&8) && s->mb_y == (s->mb_height - 1))             \
1498         mquant = v->altpq;                                     \
1499   }
1500
1501 /**
1502  * @def GET_MVDATA(_dmv_x, _dmv_y)
1503  * @brief Get MV differentials
1504  * @see MVDATA decoding from 8.3.5.2, p(1)20
1505  * @param _dmv_x Horizontal differential for decoded MV
1506  * @param _dmv_y Vertical differential for decoded MV
1507  * @todo TODO: Use MpegEncContext arrays to store them
1508  */
1509 #define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1510   index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1511                        VC1_MV_DIFF_VLC_BITS, 2);                    \
1512   if (index > 36)                                                   \
1513   {                                                                 \
1514     mb_has_coeffs = 1;                                              \
1515     index -= 37;                                                    \
1516   }                                                                 \
1517   else mb_has_coeffs = 0;                                           \
1518   s->mb_intra = 0;                                                  \
1519   if (!index) { _dmv_x = _dmv_y = 0; }                              \
1520   else if (index == 35)                                             \
1521   {                                                                 \
1522     _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1523     _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1524   }                                                                 \
1525   else if (index == 36)                                             \
1526   {                                                                 \
1527     _dmv_x = 0;                                                     \
1528     _dmv_y = 0;                                                     \
1529     s->mb_intra = 1;                                                \
1530   }                                                                 \
1531   else                                                              \
1532   {                                                                 \
1533     index1 = index%6;                                               \
1534     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1535     else                                   val = 0;                 \
1536     if(size_table[index1] - val > 0)                                \
1537         val = get_bits(gb, size_table[index1] - val);               \
1538     else                                   val = 0;                 \
1539     sign = 0 - (val&1);                                             \
1540     _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1541                                                                     \
1542     index1 = index/6;                                               \
1543     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1544     else                                   val = 0;                 \
1545     if(size_table[index1] - val > 0)                                \
1546         val = get_bits(gb, size_table[index1] - val);               \
1547     else                                   val = 0;                 \
1548     sign = 0 - (val&1);                                             \
1549     _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1550   }
1551
1552 /** Predict and set motion vector
1553  */
1554 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)
1555 {
1556     int xy, wrap, off = 0;
1557     int16_t *A, *B, *C;
1558     int px, py;
1559     int sum;
1560
1561     /* scale MV difference to be quad-pel */
1562     dmv_x <<= 1 - s->quarter_sample;
1563     dmv_y <<= 1 - s->quarter_sample;
1564
1565     wrap = s->b8_stride;
1566     xy = s->block_index[n];
1567
1568     if(s->mb_intra){
1569         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1570         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1571         if(mv1) { /* duplicate motion data for 1-MV block */
1572             s->current_picture.motion_val[0][xy + 1][0] = 0;
1573             s->current_picture.motion_val[0][xy + 1][1] = 0;
1574             s->current_picture.motion_val[0][xy + wrap][0] = 0;
1575             s->current_picture.motion_val[0][xy + wrap][1] = 0;
1576             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1577             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1578         }
1579         return;
1580     }
1581
1582     C = s->current_picture.motion_val[0][xy - 1];
1583     A = s->current_picture.motion_val[0][xy - wrap];
1584     if(mv1)
1585         off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1586     else {
1587         //in 4-MV mode different blocks have different B predictor position
1588         switch(n){
1589         case 0:
1590             off = (s->mb_x > 0) ? -1 : 1;
1591             break;
1592         case 1:
1593             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1594             break;
1595         case 2:
1596             off = 1;
1597             break;
1598         case 3:
1599             off = -1;
1600         }
1601     }
1602     B = s->current_picture.motion_val[0][xy - wrap + off];
1603
1604     if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
1605         if(s->mb_width == 1) {
1606             px = A[0];
1607             py = A[1];
1608         } else {
1609             px = mid_pred(A[0], B[0], C[0]);
1610             py = mid_pred(A[1], B[1], C[1]);
1611         }
1612     } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
1613         px = C[0];
1614         py = C[1];
1615     } else {
1616         px = py = 0;
1617     }
1618     /* Pullback MV as specified in 8.3.5.3.4 */
1619     {
1620         int qx, qy, X, Y;
1621         qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
1622         qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
1623         X = (s->mb_width << 6) - 4;
1624         Y = (s->mb_height << 6) - 4;
1625         if(mv1) {
1626             if(qx + px < -60) px = -60 - qx;
1627             if(qy + py < -60) py = -60 - qy;
1628         } else {
1629             if(qx + px < -28) px = -28 - qx;
1630             if(qy + py < -28) py = -28 - qy;
1631         }
1632         if(qx + px > X) px = X - qx;
1633         if(qy + py > Y) py = Y - qy;
1634     }
1635     /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1636     if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
1637         if(is_intra[xy - wrap])
1638             sum = ABS(px) + ABS(py);
1639         else
1640             sum = ABS(px - A[0]) + ABS(py - A[1]);
1641         if(sum > 32) {
1642             if(get_bits1(&s->gb)) {
1643                 px = A[0];
1644                 py = A[1];
1645             } else {
1646                 px = C[0];
1647                 py = C[1];
1648             }
1649         } else {
1650             if(is_intra[xy - 1])
1651                 sum = ABS(px) + ABS(py);
1652             else
1653                 sum = ABS(px - C[0]) + ABS(py - C[1]);
1654             if(sum > 32) {
1655                 if(get_bits1(&s->gb)) {
1656                     px = A[0];
1657                     py = A[1];
1658                 } else {
1659                     px = C[0];
1660                     py = C[1];
1661                 }
1662             }
1663         }
1664     }
1665     /* store MV using signed modulus of MV range defined in 4.11 */
1666     s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1667     s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1668     if(mv1) { /* duplicate motion data for 1-MV block */
1669         s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
1670         s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
1671         s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
1672         s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
1673         s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
1674         s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
1675     }
1676 }
1677
1678 /** Get predicted DC value for I-frames only
1679  * prediction dir: left=0, top=1
1680  * @param s MpegEncContext
1681  * @param[in] n block index in the current MB
1682  * @param dc_val_ptr Pointer to DC predictor
1683  * @param dir_ptr Prediction direction for use in AC prediction
1684  */
1685 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1686                               int16_t **dc_val_ptr, int *dir_ptr)
1687 {
1688     int a, b, c, wrap, pred, scale;
1689     int16_t *dc_val;
1690     static const uint16_t dcpred[32] = {
1691     -1, 1024,  512,  341,  256,  205,  171,  146,  128,
1692          114,  102,   93,   85,   79,   73,   68,   64,
1693           60,   57,   54,   51,   49,   47,   45,   43,
1694           41,   39,   38,   37,   35,   34,   33
1695     };
1696
1697     /* find prediction - wmv3_dc_scale always used here in fact */
1698     if (n < 4)     scale = s->y_dc_scale;
1699     else           scale = s->c_dc_scale;
1700
1701     wrap = s->block_wrap[n];
1702     dc_val= s->dc_val[0] + s->block_index[n];
1703
1704     /* B A
1705      * C X
1706      */
1707     c = dc_val[ - 1];
1708     b = dc_val[ - 1 - wrap];
1709     a = dc_val[ - wrap];
1710
1711     if (pq < 9 || !overlap)
1712     {
1713         /* Set outer values */
1714         if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
1715         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1716     }
1717     else
1718     {
1719         /* Set outer values */
1720         if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
1721         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1722     }
1723
1724     if (abs(a - b) <= abs(b - c)) {
1725         pred = c;
1726         *dir_ptr = 1;//left
1727     } else {
1728         pred = a;
1729         *dir_ptr = 0;//top
1730     }
1731
1732     /* update predictor */
1733     *dc_val_ptr = &dc_val[0];
1734     return pred;
1735 }
1736
1737
1738 /** Get predicted DC value
1739  * prediction dir: left=0, top=1
1740  * @param s MpegEncContext
1741  * @param[in] n block index in the current MB
1742  * @param dc_val_ptr Pointer to DC predictor
1743  * @param dir_ptr Prediction direction for use in AC prediction
1744  */
1745 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1746                               int a_avail, int c_avail,
1747                               int16_t **dc_val_ptr, int *dir_ptr)
1748 {
1749     int a, b, c, wrap, pred, scale;
1750     int16_t *dc_val;
1751     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1752     int q1, q2 = 0;
1753
1754     /* find prediction - wmv3_dc_scale always used here in fact */
1755     if (n < 4)     scale = s->y_dc_scale;
1756     else           scale = s->c_dc_scale;
1757
1758     wrap = s->block_wrap[n];
1759     dc_val= s->dc_val[0] + s->block_index[n];
1760
1761     /* B A
1762      * C X
1763      */
1764     c = dc_val[ - 1];
1765     b = dc_val[ - 1 - wrap];
1766     a = dc_val[ - wrap];
1767     /* scale predictors if needed */
1768     q1 = s->current_picture.qscale_table[mb_pos];
1769     if(c_avail && (n!= 1 && n!=3)) {
1770         q2 = s->current_picture.qscale_table[mb_pos - 1];
1771         if(q2 && q2 != q1)
1772             c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1773     }
1774     if(a_avail && (n!= 2 && n!=3)) {
1775         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
1776         if(q2 && q2 != q1)
1777             a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1778     }
1779     if(a_avail && c_avail && (n!=3)) {
1780         int off = mb_pos;
1781         if(n != 1) off--;
1782         if(n != 2) off -= s->mb_stride;
1783         q2 = s->current_picture.qscale_table[off];
1784         if(q2 && q2 != q1)
1785             b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1786     }
1787
1788     if(a_avail && c_avail) {
1789         if(abs(a - b) <= abs(b - c)) {
1790             pred = c;
1791             *dir_ptr = 1;//left
1792         } else {
1793             pred = a;
1794             *dir_ptr = 0;//top
1795         }
1796     } else if(a_avail) {
1797         pred = a;
1798         *dir_ptr = 0;//top
1799     } else if(c_avail) {
1800         pred = c;
1801         *dir_ptr = 1;//left
1802     } else {
1803         pred = 0;
1804         *dir_ptr = 1;//left
1805     }
1806
1807     /* update predictor */
1808     *dc_val_ptr = &dc_val[0];
1809     return pred;
1810 }
1811
1812
1813 /**
1814  * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
1815  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1816  * @todo TODO: Integrate to MpegEncContext facilities
1817  * @{
1818  */
1819
1820 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1821 {
1822     int xy, wrap, pred, a, b, c;
1823
1824     xy = s->block_index[n];
1825     wrap = s->b8_stride;
1826
1827     /* B C
1828      * A X
1829      */
1830     a = s->coded_block[xy - 1       ];
1831     b = s->coded_block[xy - 1 - wrap];
1832     c = s->coded_block[xy     - wrap];
1833
1834     if (b == c) {
1835         pred = a;
1836     } else {
1837         pred = c;
1838     }
1839
1840     /* store value */
1841     *coded_block_ptr = &s->coded_block[xy];
1842
1843     return pred;
1844 }
1845
1846 /**
1847  * Decode one AC coefficient
1848  * @param v The VC1 context
1849  * @param last Last coefficient
1850  * @param skip How much zero coefficients to skip
1851  * @param value Decoded AC coefficient value
1852  * @see 8.1.3.4
1853  */
1854 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
1855 {
1856     GetBitContext *gb = &v->s.gb;
1857     int index, escape, run = 0, level = 0, lst = 0;
1858
1859     index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1860     if (index != vc1_ac_sizes[codingset] - 1) {
1861         run = vc1_index_decode_table[codingset][index][0];
1862         level = vc1_index_decode_table[codingset][index][1];
1863         lst = index >= vc1_last_decode_table[codingset];
1864         if(get_bits(gb, 1))
1865             level = -level;
1866     } else {
1867         escape = decode210(gb);
1868         if (escape != 2) {
1869             index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1870             run = vc1_index_decode_table[codingset][index][0];
1871             level = vc1_index_decode_table[codingset][index][1];
1872             lst = index >= vc1_last_decode_table[codingset];
1873             if(escape == 0) {
1874                 if(lst)
1875                     level += vc1_last_delta_level_table[codingset][run];
1876                 else
1877                     level += vc1_delta_level_table[codingset][run];
1878             } else {
1879                 if(lst)
1880                     run += vc1_last_delta_run_table[codingset][level] + 1;
1881                 else
1882                     run += vc1_delta_run_table[codingset][level] + 1;
1883             }
1884             if(get_bits(gb, 1))
1885                 level = -level;
1886         } else {
1887             int sign;
1888             lst = get_bits(gb, 1);
1889             if(v->s.esc3_level_length == 0) {
1890                 if(v->pq < 8 || v->dquantfrm) { // table 59
1891                     v->s.esc3_level_length = get_bits(gb, 3);
1892                     if(!v->s.esc3_level_length)
1893                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
1894                 } else { //table 60
1895                     v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
1896                 }
1897                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
1898             }
1899             run = get_bits(gb, v->s.esc3_run_length);
1900             sign = get_bits(gb, 1);
1901             level = get_bits(gb, v->s.esc3_level_length);
1902             if(sign)
1903                 level = -level;
1904         }
1905     }
1906
1907     *last = lst;
1908     *skip = run;
1909     *value = level;
1910 }
1911
1912 /** Decode intra block in intra frames - should be faster than decode_intra_block
1913  * @param v VC1Context
1914  * @param block block to decode
1915  * @param coded are AC coeffs present or not
1916  * @param codingset set of VLC to decode data
1917  */
1918 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
1919 {
1920     GetBitContext *gb = &v->s.gb;
1921     MpegEncContext *s = &v->s;
1922     int dc_pred_dir = 0; /* Direction of the DC prediction used */
1923     int run_diff, i;
1924     int16_t *dc_val;
1925     int16_t *ac_val, *ac_val2;
1926     int dcdiff;
1927
1928     /* Get DC differential */
1929     if (n < 4) {
1930         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1931     } else {
1932         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1933     }
1934     if (dcdiff < 0){
1935         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1936         return -1;
1937     }
1938     if (dcdiff)
1939     {
1940         if (dcdiff == 119 /* ESC index value */)
1941         {
1942             /* TODO: Optimize */
1943             if (v->pq == 1) dcdiff = get_bits(gb, 10);
1944             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
1945             else dcdiff = get_bits(gb, 8);
1946         }
1947         else
1948         {
1949             if (v->pq == 1)
1950                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1951             else if (v->pq == 2)
1952                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1953         }
1954         if (get_bits(gb, 1))
1955             dcdiff = -dcdiff;
1956     }
1957
1958     /* Prediction */
1959     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
1960     *dc_val = dcdiff;
1961
1962     /* Store the quantized DC coeff, used for prediction */
1963     if (n < 4) {
1964         block[0] = dcdiff * s->y_dc_scale;
1965     } else {
1966         block[0] = dcdiff * s->c_dc_scale;
1967     }
1968     /* Skip ? */
1969     run_diff = 0;
1970     i = 0;
1971     if (!coded) {
1972         goto not_coded;
1973     }
1974
1975     //AC Decoding
1976     i = 1;
1977
1978     {
1979         int last = 0, skip, value;
1980         const int8_t *zz_table;
1981         int scale;
1982         int k;
1983
1984         scale = v->pq * 2 + v->halfpq;
1985
1986         if(v->s.ac_pred) {
1987             if(!dc_pred_dir)
1988                 zz_table = vc1_horizontal_zz;
1989             else
1990                 zz_table = vc1_vertical_zz;
1991         } else
1992             zz_table = vc1_normal_zz;
1993
1994         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1995         ac_val2 = ac_val;
1996         if(dc_pred_dir) //left
1997             ac_val -= 16;
1998         else //top
1999             ac_val -= 16 * s->block_wrap[n];
2000
2001         while (!last) {
2002             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2003             i += skip;
2004             if(i > 63)
2005                 break;
2006             block[zz_table[i++]] = value;
2007         }
2008
2009         /* apply AC prediction if needed */
2010         if(s->ac_pred) {
2011             if(dc_pred_dir) { //left
2012                 for(k = 1; k < 8; k++)
2013                     block[k << 3] += ac_val[k];
2014             } else { //top
2015                 for(k = 1; k < 8; k++)
2016                     block[k] += ac_val[k + 8];
2017             }
2018         }
2019         /* save AC coeffs for further prediction */
2020         for(k = 1; k < 8; k++) {
2021             ac_val2[k] = block[k << 3];
2022             ac_val2[k + 8] = block[k];
2023         }
2024
2025         /* scale AC coeffs */
2026         for(k = 1; k < 64; k++)
2027             if(block[k]) {
2028                 block[k] *= scale;
2029                 if(!v->pquantizer)
2030                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
2031             }
2032
2033         if(s->ac_pred) i = 63;
2034     }
2035
2036 not_coded:
2037     if(!coded) {
2038         int k, scale;
2039         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2040         ac_val2 = ac_val;
2041
2042         scale = v->pq * 2 + v->halfpq;
2043         memset(ac_val2, 0, 16 * 2);
2044         if(dc_pred_dir) {//left
2045             ac_val -= 16;
2046             if(s->ac_pred)
2047                 memcpy(ac_val2, ac_val, 8 * 2);
2048         } else {//top
2049             ac_val -= 16 * s->block_wrap[n];
2050             if(s->ac_pred)
2051                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2052         }
2053
2054         /* apply AC prediction if needed */
2055         if(s->ac_pred) {
2056             if(dc_pred_dir) { //left
2057                 for(k = 1; k < 8; k++) {
2058                     block[k << 3] = ac_val[k] * scale;
2059                     if(!v->pquantizer && block[k << 3])
2060                         block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2061                 }
2062             } else { //top
2063                 for(k = 1; k < 8; k++) {
2064                     block[k] = ac_val[k + 8] * scale;
2065                     if(!v->pquantizer && block[k])
2066                         block[k] += (block[k] < 0) ? -v->pq : v->pq;
2067                 }
2068             }
2069             i = 63;
2070         }
2071     }
2072     s->block_last_index[n] = i;
2073
2074     return 0;
2075 }
2076
2077 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2078  * @param v VC1Context
2079  * @param block block to decode
2080  * @param coded are AC coeffs present or not
2081  * @param mquant block quantizer
2082  * @param codingset set of VLC to decode data
2083  */
2084 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
2085 {
2086     GetBitContext *gb = &v->s.gb;
2087     MpegEncContext *s = &v->s;
2088     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2089     int run_diff, i;
2090     int16_t *dc_val;
2091     int16_t *ac_val, *ac_val2;
2092     int dcdiff;
2093     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2094     int a_avail = v->a_avail, c_avail = v->c_avail;
2095     int use_pred = s->ac_pred;
2096     int scale;
2097     int q1, q2 = 0;
2098
2099     /* XXX: Guard against dumb values of mquant */
2100     mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
2101
2102     /* Set DC scale - y and c use the same */
2103     s->y_dc_scale = s->y_dc_scale_table[mquant];
2104     s->c_dc_scale = s->c_dc_scale_table[mquant];
2105
2106     /* Get DC differential */
2107     if (n < 4) {
2108         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2109     } else {
2110         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2111     }
2112     if (dcdiff < 0){
2113         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2114         return -1;
2115     }
2116     if (dcdiff)
2117     {
2118         if (dcdiff == 119 /* ESC index value */)
2119         {
2120             /* TODO: Optimize */
2121             if (mquant == 1) dcdiff = get_bits(gb, 10);
2122             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2123             else dcdiff = get_bits(gb, 8);
2124         }
2125         else
2126         {
2127             if (mquant == 1)
2128                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2129             else if (mquant == 2)
2130                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2131         }
2132         if (get_bits(gb, 1))
2133             dcdiff = -dcdiff;
2134     }
2135
2136     /* Prediction */
2137     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2138     *dc_val = dcdiff;
2139
2140     /* Store the quantized DC coeff, used for prediction */
2141
2142     if (n < 4) {
2143         block[0] = dcdiff * s->y_dc_scale;
2144     } else {
2145         block[0] = dcdiff * s->c_dc_scale;
2146     }
2147     /* Skip ? */
2148     run_diff = 0;
2149     i = 0;
2150
2151     //AC Decoding
2152     i = 1;
2153
2154     /* check if AC is needed at all and adjust direction if needed */
2155     if(!a_avail) dc_pred_dir = 1;
2156     if(!c_avail) dc_pred_dir = 0;
2157     if(!a_avail && !c_avail) use_pred = 0;
2158     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2159     ac_val2 = ac_val;
2160
2161     scale = mquant * 2 + v->halfpq;
2162
2163     if(dc_pred_dir) //left
2164         ac_val -= 16;
2165     else //top
2166         ac_val -= 16 * s->block_wrap[n];
2167
2168     q1 = s->current_picture.qscale_table[mb_pos];
2169     if(dc_pred_dir && c_avail) q2 = s->current_picture.qscale_table[mb_pos - 1];
2170     if(!dc_pred_dir && a_avail) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2171     if(n && n<4) q2 = q1;
2172
2173     if(coded) {
2174         int last = 0, skip, value;
2175         const int8_t *zz_table;
2176         int k;
2177
2178         zz_table = vc1_simple_progressive_8x8_zz;
2179
2180         while (!last) {
2181             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2182             i += skip;
2183             if(i > 63)
2184                 break;
2185             block[zz_table[i++]] = value;
2186         }
2187
2188         /* apply AC prediction if needed */
2189         if(use_pred) {
2190             /* scale predictors if needed*/
2191             if(q2 && q1!=q2) {
2192                 q1 = q1 * 2 - 1;
2193                 q2 = q2 * 2 - 1;
2194
2195                 if(dc_pred_dir) { //left
2196                     for(k = 1; k < 8; k++)
2197                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2198                 } else { //top
2199                     for(k = 1; k < 8; k++)
2200                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2201                 }
2202             } else {
2203                 if(dc_pred_dir) { //left
2204                     for(k = 1; k < 8; k++)
2205                         block[k << 3] += ac_val[k];
2206                 } else { //top
2207                     for(k = 1; k < 8; k++)
2208                         block[k] += ac_val[k + 8];
2209                 }
2210             }
2211         }
2212         /* save AC coeffs for further prediction */
2213         for(k = 1; k < 8; k++) {
2214             ac_val2[k] = block[k << 3];
2215             ac_val2[k + 8] = block[k];
2216         }
2217
2218         /* scale AC coeffs */
2219         for(k = 1; k < 64; k++)
2220             if(block[k]) {
2221                 block[k] *= scale;
2222                 if(!v->pquantizer)
2223                     block[k] += (block[k] < 0) ? -mquant : mquant;
2224             }
2225
2226         if(use_pred) i = 63;
2227     } else { // no AC coeffs
2228         int k;
2229
2230         memset(ac_val2, 0, 16 * 2);
2231         if(dc_pred_dir) {//left
2232             if(use_pred) {
2233                 memcpy(ac_val2, ac_val, 8 * 2);
2234                 if(q2 && q1!=q2) {
2235                     q1 = q1 * 2 - 1;
2236                     q2 = q2 * 2 - 1;
2237                     for(k = 1; k < 8; k++)
2238                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2239                 }
2240             }
2241         } else {//top
2242             if(use_pred) {
2243                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2244                 if(q2 && q1!=q2) {
2245                     q1 = q1 * 2 - 1;
2246                     q2 = q2 * 2 - 1;
2247                     for(k = 1; k < 8; k++)
2248                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2249                 }
2250             }
2251         }
2252
2253         /* apply AC prediction if needed */
2254         if(use_pred) {
2255             if(dc_pred_dir) { //left
2256                 for(k = 1; k < 8; k++) {
2257                     block[k << 3] = ac_val2[k] * scale;
2258                     if(!v->pquantizer && block[k << 3])
2259                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2260                 }
2261             } else { //top
2262                 for(k = 1; k < 8; k++) {
2263                     block[k] = ac_val2[k + 8] * scale;
2264                     if(!v->pquantizer && block[k])
2265                         block[k] += (block[k] < 0) ? -mquant : mquant;
2266                 }
2267             }
2268             i = 63;
2269         }
2270     }
2271     s->block_last_index[n] = i;
2272
2273     return 0;
2274 }
2275
2276 /** Decode P block
2277  */
2278 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
2279 {
2280     MpegEncContext *s = &v->s;
2281     GetBitContext *gb = &s->gb;
2282     int i, j;
2283     int subblkpat = 0;
2284     int scale, off, idx, last, skip, value;
2285     int ttblk = ttmb & 7;
2286
2287     if(ttmb == -1) {
2288         ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
2289     }
2290     if(ttblk == TT_4X4) {
2291         subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
2292     }
2293     if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
2294         subblkpat = decode012(gb);
2295         if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
2296         if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
2297         if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
2298     }
2299     scale = 2 * mquant + v->halfpq;
2300
2301     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2302     if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
2303         subblkpat = 2 - (ttblk == TT_8X4_TOP);
2304         ttblk = TT_8X4;
2305     }
2306     if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
2307         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
2308         ttblk = TT_4X8;
2309     }
2310     switch(ttblk) {
2311     case TT_8X8:
2312         i = 0;
2313         last = 0;
2314         while (!last) {
2315             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2316             i += skip;
2317             if(i > 63)
2318                 break;
2319             idx = vc1_simple_progressive_8x8_zz[i++];
2320             block[idx] = value * scale;
2321             if(!v->pquantizer)
2322                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
2323         }
2324         vc1_inv_trans(block, 8, 8);
2325         break;
2326     case TT_4X4:
2327         for(j = 0; j < 4; j++) {
2328             last = subblkpat & (1 << (3 - j));
2329             i = 0;
2330             off = (j & 1) * 4 + (j & 2) * 16;
2331             while (!last) {
2332                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2333                 i += skip;
2334                 if(i > 15)
2335                     break;
2336                 idx = vc1_simple_progressive_4x4_zz[i++];
2337                 block[idx + off] = value * scale;
2338                 if(!v->pquantizer)
2339                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2340             }
2341             if(!(subblkpat & (1 << (3 - j))))
2342                 vc1_inv_trans(block + off, 4, 4);
2343         }
2344         break;
2345     case TT_8X4:
2346         for(j = 0; j < 2; j++) {
2347             last = subblkpat & (1 << (1 - j));
2348             i = 0;
2349             off = j * 32;
2350             while (!last) {
2351                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2352                 i += skip;
2353                 if(i > 31)
2354                     break;
2355                 idx = vc1_simple_progressive_8x4_zz[i++];
2356                 block[idx + off] = value * scale;
2357                 if(!v->pquantizer)
2358                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2359             }
2360             if(!(subblkpat & (1 << (1 - j))))
2361                 vc1_inv_trans(block + off, 8, 4);
2362         }
2363         break;
2364     case TT_4X8:
2365         for(j = 0; j < 2; j++) {
2366             last = subblkpat & (1 << (1 - j));
2367             i = 0;
2368             off = j * 4;
2369             while (!last) {
2370                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2371                 i += skip;
2372                 if(i > 31)
2373                     break;
2374                 idx = vc1_simple_progressive_4x8_zz[i++];
2375                 block[idx + off] = value * scale;
2376                 if(!v->pquantizer)
2377                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2378             }
2379             if(!(subblkpat & (1 << (1 - j))))
2380                 vc1_inv_trans(block + off, 4, 8);
2381         }
2382         break;
2383     }
2384     return 0;
2385 }
2386
2387
2388 /** Decode one P-frame MB (in Simple/Main profile)
2389  * @todo TODO: Extend to AP
2390  * @fixme FIXME: DC value for inter blocks not set
2391  */
2392 static int vc1_decode_p_mb(VC1Context *v)
2393 {
2394     MpegEncContext *s = &v->s;
2395     GetBitContext *gb = &s->gb;
2396     int i, j;
2397     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2398     int cbp; /* cbp decoding stuff */
2399     int mqdiff, mquant; /* MB quantization */
2400     int ttmb = v->ttfrm; /* MB Transform type */
2401     int status;
2402
2403     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2404       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2405     int mb_has_coeffs = 1; /* last_flag */
2406     int dmv_x, dmv_y; /* Differential MV components */
2407     int index, index1; /* LUT indices */
2408     int val, sign; /* temp values */
2409     int first_block = 1;
2410     int dst_idx, off;
2411     int skipped, fourmv;
2412
2413     mquant = v->pq; /* Loosy initialization */
2414
2415     if (v->mv_type_is_raw)
2416         fourmv = get_bits1(gb);
2417     else
2418         fourmv = v->mv_type_mb_plane[mb_pos];
2419     if (v->skip_is_raw)
2420         skipped = get_bits1(gb);
2421     else
2422         skipped = v->s.mbskip_table[mb_pos];
2423
2424     s->dsp.clear_blocks(s->block[0]);
2425
2426     if (!fourmv) /* 1MV mode */
2427     {
2428         if (!skipped)
2429         {
2430             GET_MVDATA(dmv_x, dmv_y);
2431
2432             s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
2433             vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
2434
2435             /* FIXME Set DC val for inter block ? */
2436             if (s->mb_intra && !mb_has_coeffs)
2437             {
2438                 GET_MQUANT();
2439                 s->ac_pred = get_bits(gb, 1);
2440                 cbp = 0;
2441             }
2442             else if (mb_has_coeffs)
2443             {
2444                 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2445                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2446                 GET_MQUANT();
2447             }
2448             else
2449             {
2450                 mquant = v->pq;
2451                 cbp = 0;
2452             }
2453             s->current_picture.qscale_table[mb_pos] = mquant;
2454
2455             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2456                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2457                                 VC1_TTMB_VLC_BITS, 2);
2458             if(!s->mb_intra) vc1_mc_1mv(v);
2459             dst_idx = 0;
2460             for (i=0; i<6; i++)
2461             {
2462                 s->dc_val[0][s->block_index[i]] = 0;
2463                 dst_idx += i >> 2;
2464                 val = ((cbp >> (5 - i)) & 1);
2465                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2466                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
2467                 if(s->mb_intra) {
2468                     /* check if prediction blocks A and C are available */
2469                     v->a_avail = v->c_avail = 0;
2470                     if(i == 2 || i == 3 || !s->first_slice_line)
2471                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2472                     if(i == 1 || i == 3 || s->mb_x)
2473                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2474
2475                     vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2476                     vc1_inv_trans(s->block[i], 8, 8);
2477                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
2478                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2479                     /* TODO: proper loop filtering */
2480                     if(v->pq >= 9 && v->overlap) {
2481                         if(v->a_avail)
2482                             vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2483                         if(v->c_avail)
2484                             vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2485                     }
2486                 } else if(val) {
2487                     vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2488                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
2489                     first_block = 0;
2490                     s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2491                 }
2492             }
2493         }
2494         else //Skipped
2495         {
2496             s->mb_intra = 0;
2497             for(i = 0; i < 6; i++) {
2498                 v->mb_type[0][s->block_index[i]] = 0;
2499                 s->dc_val[0][s->block_index[i]] = 0;
2500             }
2501             s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
2502             s->current_picture.qscale_table[mb_pos] = 0;
2503             vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
2504             vc1_mc_1mv(v);
2505             return 0;
2506         }
2507     } //1MV mode
2508     else //4MV mode
2509     {
2510         if (!skipped /* unskipped MB */)
2511         {
2512             int intra_count = 0, coded_inter = 0;
2513             int is_intra[6], is_coded[6];
2514             /* Get CBPCY */
2515             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2516             for (i=0; i<6; i++)
2517             {
2518                 val = ((cbp >> (5 - i)) & 1);
2519                 s->dc_val[0][s->block_index[i]] = 0;
2520                 s->mb_intra = 0;
2521                 if(i < 4) {
2522                     dmv_x = dmv_y = 0;
2523                     s->mb_intra = 0;
2524                     mb_has_coeffs = 0;
2525                     if(val) {
2526                         GET_MVDATA(dmv_x, dmv_y);
2527                     }
2528                     vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
2529                     if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
2530                     intra_count += s->mb_intra;
2531                     is_intra[i] = s->mb_intra;
2532                     is_coded[i] = mb_has_coeffs;
2533                 }
2534                 if(i&4){
2535                     is_intra[i] = (intra_count >= 3);
2536                     is_coded[i] = val;
2537                 }
2538                 if(i == 4) vc1_mc_4mv_chroma(v);
2539                 v->mb_type[0][s->block_index[i]] = is_intra[i];
2540                 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
2541             }
2542             // if there are no coded blocks then don't do anything more
2543             if(!intra_count && !coded_inter) return;
2544             dst_idx = 0;
2545             GET_MQUANT();
2546             s->current_picture.qscale_table[mb_pos] = mquant;
2547             /* test if block is intra and has pred */
2548             {
2549                 int intrapred = 0;
2550                 for(i=0; i<6; i++)
2551                     if(is_intra[i]) {
2552                         if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
2553                             || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
2554                             intrapred = 1;
2555                             break;
2556                         }
2557                     }
2558                 if(intrapred)s->ac_pred = get_bits(gb, 1);
2559                 else s->ac_pred = 0;
2560             }
2561             if (!v->ttmbf && coded_inter)
2562                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 12);
2563             for (i=0; i<6; i++)
2564             {
2565                 dst_idx += i >> 2;
2566                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2567                 s->mb_intra = is_intra[i];
2568                 if (is_intra[i]) {
2569                     /* check if prediction blocks A and C are available */
2570                     v->a_avail = v->c_avail = 0;
2571                     if(i == 2 || i == 3 || !s->first_slice_line)
2572                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2573                     if(i == 1 || i == 3 || s->mb_x)
2574                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2575
2576                     vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
2577                     vc1_inv_trans(s->block[i], 8, 8);
2578                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
2579                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2580                     /* TODO: proper loop filtering */
2581                     if(v->pq >= 9 && v->overlap) {
2582                         if(v->a_avail)
2583                             vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2584                         if(v->c_avail)
2585                             vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2586                     }
2587                 } else if(is_coded[i]) {
2588                     status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2589                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
2590                     first_block = 0;
2591                     s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2592                 }
2593             }
2594             return status;
2595         }
2596         else //Skipped MB
2597         {
2598             s->mb_intra = 0;
2599             for (i=0; i<6; i++) {
2600                 v->mb_type[0][s->block_index[i]] = 0;
2601                 s->dc_val[0][s->block_index[i]] = 0;
2602             }
2603             for (i=0; i<4; i++)
2604             {
2605                 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
2606                 vc1_mc_4mv_luma(v, i);
2607             }
2608             vc1_mc_4mv_chroma(v);
2609             s->current_picture.qscale_table[mb_pos] = 0;
2610             return 0;
2611         }
2612     }
2613
2614     /* Should never happen */
2615     return -1;
2616 }
2617
2618 /** Decode blocks of I-frame
2619  */
2620 static void vc1_decode_i_blocks(VC1Context *v)
2621 {
2622     int k, j;
2623     MpegEncContext *s = &v->s;
2624     int cbp, val;
2625     uint8_t *coded_val;
2626     int mb_pos;
2627
2628     /* select codingmode used for VLC tables selection */
2629     switch(v->y_ac_table_index){
2630     case 0:
2631         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2632         break;
2633     case 1:
2634         v->codingset = CS_HIGH_MOT_INTRA;
2635         break;
2636     case 2:
2637         v->codingset = CS_MID_RATE_INTRA;
2638         break;
2639     }
2640
2641     switch(v->c_ac_table_index){
2642     case 0:
2643         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2644         break;
2645     case 1:
2646         v->codingset2 = CS_HIGH_MOT_INTER;
2647         break;
2648     case 2:
2649         v->codingset2 = CS_MID_RATE_INTER;
2650         break;
2651     }
2652
2653     /* Set DC scale - y and c use the same */
2654     s->y_dc_scale = s->y_dc_scale_table[v->pq];
2655     s->c_dc_scale = s->c_dc_scale_table[v->pq];
2656
2657     //do frame decode
2658     s->mb_x = s->mb_y = 0;
2659     s->mb_intra = 1;
2660     s->first_slice_line = 1;
2661     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2662     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2663         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2664             ff_init_block_index(s);
2665             ff_update_block_index(s);
2666             s->dsp.clear_blocks(s->block[0]);
2667             mb_pos = s->mb_x + s->mb_y * s->mb_width;
2668             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2669             s->current_picture.qscale_table[mb_pos] = v->pq;
2670
2671             // do actual MB decoding and displaying
2672             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2673             v->s.ac_pred = get_bits(&v->s.gb, 1);
2674
2675             for(k = 0; k < 6; k++) {
2676                 val = ((cbp >> (5 - k)) & 1);
2677
2678                 if (k < 4) {
2679                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2680                     val = val ^ pred;
2681                     *coded_val = val;
2682                 }
2683                 cbp |= val << (5 - k);
2684
2685                 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
2686
2687                 vc1_inv_trans(s->block[k], 8, 8);
2688                 if(v->pq >= 9 && v->overlap) {
2689                     for(j = 0; j < 64; j++) s->block[k][j] += 128;
2690                 }
2691             }
2692
2693             vc1_put_block(v, s->block);
2694             if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
2695                 if(!s->first_slice_line) {
2696                     vc1_v_overlap(s->dest[0], s->linesize);
2697                     vc1_v_overlap(s->dest[0] + 8, s->linesize);
2698                     vc1_v_overlap(s->dest[1], s->uvlinesize);
2699                     vc1_v_overlap(s->dest[2], s->uvlinesize);
2700                 }
2701                 vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2702                 vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2703                 if(s->mb_x) {
2704                     vc1_h_overlap(s->dest[0], s->linesize);
2705                     vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2706                     vc1_h_overlap(s->dest[1], s->uvlinesize);
2707                     vc1_h_overlap(s->dest[2], s->uvlinesize);
2708                 }
2709                 vc1_h_overlap(s->dest[0] + 8, s->linesize);
2710                 vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2711             }
2712
2713             if(get_bits_count(&s->gb) > v->bits) {
2714                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
2715                 return;
2716             }
2717         }
2718         ff_draw_horiz_band(s, s->mb_y * 16, 16);
2719         s->first_slice_line = 0;
2720     }
2721 }
2722
2723 static void vc1_decode_p_blocks(VC1Context *v)
2724 {
2725     MpegEncContext *s = &v->s;
2726
2727     /* select codingmode used for VLC tables selection */
2728     switch(v->c_ac_table_index){
2729     case 0:
2730         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2731         break;
2732     case 1:
2733         v->codingset = CS_HIGH_MOT_INTRA;
2734         break;
2735     case 2:
2736         v->codingset = CS_MID_RATE_INTRA;
2737         break;
2738     }
2739
2740     switch(v->c_ac_table_index){
2741     case 0:
2742         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2743         break;
2744     case 1:
2745         v->codingset2 = CS_HIGH_MOT_INTER;
2746         break;
2747     case 2:
2748         v->codingset2 = CS_MID_RATE_INTER;
2749         break;
2750     }
2751
2752     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2753     s->first_slice_line = 1;
2754     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2755         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2756             ff_init_block_index(s);
2757             ff_update_block_index(s);
2758             s->dsp.clear_blocks(s->block[0]);
2759
2760             vc1_decode_p_mb(v);
2761             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
2762                 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);
2763                 return;
2764             }
2765         }
2766         ff_draw_horiz_band(s, s->mb_y * 16, 16);
2767         s->first_slice_line = 0;
2768     }
2769 }
2770
2771 static void vc1_decode_blocks(VC1Context *v)
2772 {
2773
2774     v->s.esc3_level_length = 0;
2775
2776     switch(v->s.pict_type) {
2777     case I_TYPE:
2778         vc1_decode_i_blocks(v);
2779         break;
2780     case P_TYPE:
2781         vc1_decode_p_blocks(v);
2782         break;
2783     }
2784 }
2785
2786
2787 /** Initialize a VC1/WMV3 decoder
2788  * @todo TODO: Handle VC-1 IDUs (Transport level?)
2789  * @todo TODO: Decypher remaining bits in extra_data
2790  */
2791 static int vc1_decode_init(AVCodecContext *avctx)
2792 {
2793     VC1Context *v = avctx->priv_data;
2794     MpegEncContext *s = &v->s;
2795     GetBitContext gb;
2796
2797     if (!avctx->extradata_size || !avctx->extradata) return -1;
2798     avctx->pix_fmt = PIX_FMT_YUV420P;
2799     v->s.avctx = avctx;
2800     avctx->flags |= CODEC_FLAG_EMU_EDGE;
2801     v->s.flags |= CODEC_FLAG_EMU_EDGE;
2802
2803     if(ff_h263_decode_init(avctx) < 0)
2804         return -1;
2805     if (vc1_init_common(v) < 0) return -1;
2806
2807     av_log(avctx, AV_LOG_INFO, "This decoder is not supposed to produce picture. Dont report this as a bug!\n");
2808     av_log(avctx, AV_LOG_INFO, "If you see a picture, don't believe your eyes.\n");
2809
2810     avctx->coded_width = avctx->width;
2811     avctx->coded_height = avctx->height;
2812     if (avctx->codec_id == CODEC_ID_WMV3)
2813     {
2814         int count = 0;
2815
2816         // looks like WMV3 has a sequence header stored in the extradata
2817         // advanced sequence header may be before the first frame
2818         // the last byte of the extradata is a version number, 1 for the
2819         // samples we can decode
2820
2821         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2822
2823         if (decode_sequence_header(avctx, &gb) < 0)
2824           return -1;
2825
2826         count = avctx->extradata_size*8 - get_bits_count(&gb);
2827         if (count>0)
2828         {
2829             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2830                    count, get_bits(&gb, count));
2831         }
2832         else if (count < 0)
2833         {
2834             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2835         }
2836     }
2837     avctx->has_b_frames= !!(avctx->max_b_frames);
2838
2839     s->mb_width = (avctx->coded_width+15)>>4;
2840     s->mb_height = (avctx->coded_height+15)>>4;
2841
2842     /* Allocate mb bitplanes */
2843     v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
2844
2845     /* allocate block type info in that way so it could be used with s->block_index[] */
2846     v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
2847     v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
2848     v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
2849     v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
2850
2851     /* Init coded blocks info */
2852     if (v->profile == PROFILE_ADVANCED)
2853     {
2854 //        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2855 //            return -1;
2856 //        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2857 //            return -1;
2858     }
2859
2860     return 0;
2861 }
2862
2863
2864 /** Decode a VC1/WMV3 frame
2865  * @todo TODO: Handle VC-1 IDUs (Transport level?)
2866  * @warning Initial try at using MpegEncContext stuff
2867  */
2868 static int vc1_decode_frame(AVCodecContext *avctx,
2869                             void *data, int *data_size,
2870                             uint8_t *buf, int buf_size)
2871 {
2872     VC1Context *v = avctx->priv_data;
2873     MpegEncContext *s = &v->s;
2874     AVFrame *pict = data;
2875
2876     /* no supplementary picture */
2877     if (buf_size == 0) {
2878         /* special case for last picture */
2879         if (s->low_delay==0 && s->next_picture_ptr) {
2880             *pict= *(AVFrame*)s->next_picture_ptr;
2881             s->next_picture_ptr= NULL;
2882
2883             *data_size = sizeof(AVFrame);
2884         }
2885
2886         return 0;
2887     }
2888
2889     //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2890     if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2891         int i= ff_find_unused_picture(s, 0);
2892         s->current_picture_ptr= &s->picture[i];
2893     }
2894
2895     avctx->has_b_frames= !s->low_delay;
2896
2897     init_get_bits(&s->gb, buf, buf_size*8);
2898     // do parse frame header
2899     if(vc1_parse_frame_header(v, &s->gb) == -1)
2900         return -1;
2901
2902     if(s->pict_type != I_TYPE && s->pict_type != P_TYPE)return -1;
2903
2904     // for hurry_up==5
2905     s->current_picture.pict_type= s->pict_type;
2906     s->current_picture.key_frame= s->pict_type == I_TYPE;
2907
2908     /* skip B-frames if we don't have reference frames */
2909     if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return -1;//buf_size;
2910     /* skip b frames if we are in a hurry */
2911     if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
2912     if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
2913        || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
2914        ||  avctx->skip_frame >= AVDISCARD_ALL)
2915         return buf_size;
2916     /* skip everything if we are in a hurry>=5 */
2917     if(avctx->hurry_up>=5) return -1;//buf_size;
2918
2919     if(s->next_p_frame_damaged){
2920         if(s->pict_type==B_TYPE)
2921             return buf_size;
2922         else
2923             s->next_p_frame_damaged=0;
2924     }
2925
2926     if(MPV_frame_start(s, avctx) < 0)
2927         return -1;
2928
2929     ff_er_frame_start(s);
2930
2931     v->bits = buf_size * 8;
2932     vc1_decode_blocks(v);
2933 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
2934 //  if(get_bits_count(&s->gb) > buf_size * 8)
2935 //      return -1;
2936     ff_er_frame_end(s);
2937
2938     MPV_frame_end(s);
2939
2940 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2941 assert(s->current_picture.pict_type == s->pict_type);
2942     if (s->pict_type == B_TYPE || s->low_delay) {
2943         *pict= *(AVFrame*)s->current_picture_ptr;
2944     } else if (s->last_picture_ptr != NULL) {
2945         *pict= *(AVFrame*)s->last_picture_ptr;
2946     }
2947
2948     if(s->last_picture_ptr || s->low_delay){
2949         *data_size = sizeof(AVFrame);
2950         ff_print_debug_info(s, pict);
2951     }
2952
2953     /* Return the Picture timestamp as the frame number */
2954     /* we substract 1 because it is added on utils.c    */
2955     avctx->frame_number = s->picture_number - 1;
2956
2957     return buf_size;
2958 }
2959
2960
2961 /** Close a VC1/WMV3 decoder
2962  * @warning Initial try at using MpegEncContext stuff
2963  */
2964 static int vc1_decode_end(AVCodecContext *avctx)
2965 {
2966     VC1Context *v = avctx->priv_data;
2967
2968     av_freep(&v->hrd_rate);
2969     av_freep(&v->hrd_buffer);
2970     MPV_common_end(&v->s);
2971     av_freep(&v->mv_type_mb_plane);
2972     av_freep(&v->mb_type_base);
2973     return 0;
2974 }
2975
2976
2977 AVCodec vc1_decoder = {
2978     "vc1",
2979     CODEC_TYPE_VIDEO,
2980     CODEC_ID_VC1,
2981     sizeof(VC1Context),
2982     vc1_decode_init,
2983     NULL,
2984     vc1_decode_end,
2985     vc1_decode_frame,
2986     CODEC_CAP_DELAY,
2987     NULL
2988 };
2989
2990 AVCodec wmv3_decoder = {
2991     "wmv3",
2992     CODEC_TYPE_VIDEO,
2993     CODEC_ID_WMV3,
2994     sizeof(VC1Context),
2995     vc1_decode_init,
2996     NULL,
2997     vc1_decode_end,
2998     vc1_decode_frame,
2999     CODEC_CAP_DELAY,
3000     NULL
3001 };