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