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