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