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