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