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