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