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