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