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