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