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
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.
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.
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
24 * VC-1 and WMV3 decoder
30 #include "mpegvideo.h"
32 #include "vc1acdata.h"
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];
45 static const uint16_t table_mb_intra[64][2];
48 /** Available Profiles */
53 PROFILE_COMPLEX, ///< TODO: WMV9 specific
58 /** Sequence quantizer mode */
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
68 /** Where quant can be changed */
72 DQPROFILE_DOUBLE_EDGES,
73 DQPROFILE_SINGLE_EDGE,
78 /** @name Where quant can be changed
89 /** Which pair of edges is quantized with ALTPQUANT */
92 DQDOUBLE_BEDGE_TOPLEFT,
93 DQDOUBLE_BEDGE_TOPRIGHT,
94 DQDOUBLE_BEDGE_BOTTOMRIGHT,
95 DQDOUBLE_BEDGE_BOTTOMLEFT
99 /** MV modes for P frames */
102 MV_PMODE_1MV_HPEL_BILIN,
106 MV_PMODE_INTENSITY_COMP
110 /** @name MV types for B frames */
115 BMV_TYPE_INTERPOLATED = 3 //XXX: ??
119 /** @name Block types for P/B frames */
121 enum TransformTypes {
125 TT_8X4, //Both halves
128 TT_4X8, //Both halves
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 }
140 static const int ttfrm_to_tt[4] = { TT_8X8, TT_8X4, TT_4X8, TT_4X4 };
142 /** MV P mode - the 5th element is only used for mode 1 */
143 static const uint8_t mv_pmode_table[2][5] = {
144 { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV },
145 { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN }
147 static const uint8_t mv_pmode_table2[2][4] = {
148 { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV },
149 { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN }
152 /** One more frame type */
155 static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
156 fps_dr[2] = { 1000, 1001 };
157 static const uint8_t pquant_table[3][32] = {
158 { /* Implicit quantizer */
159 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 7, 8, 9, 10, 11, 12,
160 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
162 { /* Explicit quantizer, pquantizer uniform */
163 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
164 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
166 { /* Explicit quantizer, pquantizer non-uniform */
167 0, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
168 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
172 /** @name VC-1 VLC tables and defines
173 * @todo TODO move this into the context
176 #define VC1_BFRACTION_VLC_BITS 7
177 static VLC vc1_bfraction_vlc;
178 #define VC1_IMODE_VLC_BITS 4
179 static VLC vc1_imode_vlc;
180 #define VC1_NORM2_VLC_BITS 3
181 static VLC vc1_norm2_vlc;
182 #define VC1_NORM6_VLC_BITS 9
183 static VLC vc1_norm6_vlc;
184 /* Could be optimized, one table only needs 8 bits */
185 #define VC1_TTMB_VLC_BITS 9 //12
186 static VLC vc1_ttmb_vlc[3];
187 #define VC1_MV_DIFF_VLC_BITS 9 //15
188 static VLC vc1_mv_diff_vlc[4];
189 #define VC1_CBPCY_P_VLC_BITS 9 //14
190 static VLC vc1_cbpcy_p_vlc[4];
191 #define VC1_4MV_BLOCK_PATTERN_VLC_BITS 6
192 static VLC vc1_4mv_block_pattern_vlc[4];
193 #define VC1_TTBLK_VLC_BITS 5
194 static VLC vc1_ttblk_vlc[3];
195 #define VC1_SUBBLKPAT_VLC_BITS 6
196 static VLC vc1_subblkpat_vlc[3];
198 static VLC vc1_ac_coeff_table[8];
202 CS_HIGH_MOT_INTRA = 0,
213 * @fixme Change size wherever another size is more efficient
214 * Many members are only used for Advanced Profile
216 typedef struct VC1Context{
221 /** Simple/Main Profile sequence header */
223 int res_sm; ///< reserved, 2b
224 int res_x8; ///< reserved
225 int multires; ///< frame-level RESPIC syntax element present
226 int res_fasttx; ///< reserved, always 1
227 int res_transtab; ///< reserved, always 0
228 int rangered; ///< RANGEREDFRM (range reduction) syntax element present
230 int res_rtm_flag; ///< reserved, set to 1
231 int reserved; ///< reserved
234 /** Advanced Profile */
236 int level; ///< 3bits, for Advanced/Simple Profile, provided by TS layer
237 int chromaformat; ///< 2bits, 2=4:2:0, only defined
238 int postprocflag; ///< Per-frame processing suggestion flag present
239 int broadcast; ///< TFF/RFF present
240 int interlace; ///< Progressive/interlaced (RPTFTM syntax element)
241 int tfcntrflag; ///< TFCNTR present
242 int panscanflag; ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
243 int extended_dmv; ///< Additional extended dmv range at P/B frame-level
244 int color_prim; ///< 8bits, chroma coordinates of the color primaries
245 int transfer_char; ///< 8bits, Opto-electronic transfer characteristics
246 int matrix_coef; ///< 8bits, Color primaries->YCbCr transform matrix
247 int hrd_param_flag; ///< Presence of Hypothetical Reference
248 ///< Decoder parameters
251 /** Sequence header data for all Profiles
252 * TODO: choose between ints, uint8_ts and monobit flags
255 int profile; ///< 2bits, Profile
256 int frmrtq_postproc; ///< 3bits,
257 int bitrtq_postproc; ///< 5bits, quantized framerate-based postprocessing strength
258 int fastuvmc; ///< Rounding of qpel vector to hpel ? (not in Simple)
259 int extended_mv; ///< Ext MV in P/B (not in Simple)
260 int dquant; ///< How qscale varies with MBs, 2bits (not in Simple)
261 int vstransform; ///< variable-size [48]x[48] transform type + info
262 int overlap; ///< overlapped transforms in use
263 int quantizer_mode; ///< 2bits, quantizer mode used for sequence, see QUANT_*
264 int finterpflag; ///< INTERPFRM present
267 /** Frame decoding info for all profiles */
269 uint8_t mv_mode; ///< MV coding monde
270 uint8_t mv_mode2; ///< Secondary MV coding mode (B frames)
271 int k_x; ///< Number of bits for MVs (depends on MV range)
272 int k_y; ///< Number of bits for MVs (depends on MV range)
273 int range_x, range_y; ///< MV range
274 uint8_t pq, altpq; ///< Current/alternate frame quantizer scale
275 /** pquant parameters */
282 /** AC coding set indexes
283 * @see 8.1.1.10, p(1)10
286 int c_ac_table_index; ///< Chroma index from ACFRM element
287 int y_ac_table_index; ///< Luma index from AC2FRM element
289 int ttfrm; ///< Transform type info present at frame level
290 uint8_t ttmbf; ///< Transform type flag
291 uint8_t ttblk4x4; ///< Value of ttblk which indicates a 4x4 transform
292 int codingset; ///< index of current table set from 11.8 to use for luma block decoding
293 int codingset2; ///< index of current table set from 11.8 to use for chroma block decoding
294 int pqindex; ///< raw pqindex used in coding set selection
295 int a_avail, c_avail;
296 uint8_t *mb_type_base, *mb_type[3];
299 /** Luma compensation parameters */
304 int16_t bfraction; ///< Relative position % anchors=> how to scale MVs
305 uint8_t halfpq; ///< Uniform quant over image and qp+.5
306 uint8_t respic; ///< Frame-level flag for resized images
307 int buffer_fullness; ///< HRD info
309 * -# 0 -> [-64n 63.f] x [-32, 31.f]
310 * -# 1 -> [-128, 127.f] x [-64, 63.f]
311 * -# 2 -> [-512, 511.f] x [-128, 127.f]
312 * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
315 uint8_t pquantizer; ///< Uniform (over sequence) quantizer in use
316 VLC *cbpcy_vlc; ///< CBPCY VLC table
317 int tt_index; ///< Index for Transform Type tables
318 uint8_t* mv_type_mb_plane; ///< bitplane for mv_type == (4MV)
319 // BitPlane direct_mb_plane; ///< bitplane for "direct" MBs
320 int mv_type_is_raw; ///< mv type mb plane is not coded
321 int skip_is_raw; ///< skip mb plane is not coded
322 uint8_t luty[256], lutuv[256]; // lookup tables used for intensity compensation
323 int rnd; ///< rounding control
325 /** Frame decoding info for S/M profiles only */
327 uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
331 /** Frame decoding info for Advanced profile */
333 uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
334 uint8_t numpanscanwin;
336 uint8_t rptfrm, tff, rff;
339 uint16_t bottomrightx;
340 uint16_t bottomrighty;
343 int hrd_num_leaky_buckets;
344 uint8_t bit_rate_exponent;
345 uint8_t buffer_size_exponent;
346 // BitPlane ac_pred_plane; ///< AC prediction flags bitplane
347 // BitPlane over_flags_plane; ///< Overflags bitplane
349 uint16_t *hrd_rate, *hrd_buffer;
350 uint8_t *hrd_fullness;
351 uint8_t range_mapy_flag;
352 uint8_t range_mapuv_flag;
359 * Get unary code of limited length
360 * @fixme FIXME Slow and ugly
361 * @param gb GetBitContext
362 * @param[in] stop The bitstop value (unary code of 1's or 0's)
363 * @param[in] len Maximum length
364 * @return Unary length/index
366 static int get_prefix(GetBitContext *gb, int stop, int len)
371 for(i = 0; i < len && get_bits1(gb) != stop; i++);
373 /* int i = 0, tmp = !stop;
375 while (i != len && tmp != stop)
377 tmp = get_bits(gb, 1);
380 if (i == len && tmp != stop) return len+1;
387 UPDATE_CACHE(re, gb);
388 buf=GET_CACHE(re, gb); //Still not sure
389 if (stop) buf = ~buf;
391 log= av_log2(-buf); //FIXME: -?
393 LAST_SKIP_BITS(re, gb, log+1);
394 CLOSE_READER(re, gb);
398 LAST_SKIP_BITS(re, gb, limit);
399 CLOSE_READER(re, gb);
404 static inline int decode210(GetBitContext *gb){
410 return 2 - get_bits1(gb);
414 * Init VC-1 specific tables and VC1Context members
415 * @param v The VC1Context to initialize
418 static int vc1_init_common(VC1Context *v)
423 v->hrd_rate = v->hrd_buffer = NULL;
429 init_vlc(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
430 vc1_bfraction_bits, 1, 1,
431 vc1_bfraction_codes, 1, 1, 1);
432 init_vlc(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
433 vc1_norm2_bits, 1, 1,
434 vc1_norm2_codes, 1, 1, 1);
435 init_vlc(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
436 vc1_norm6_bits, 1, 1,
437 vc1_norm6_codes, 2, 2, 1);
438 init_vlc(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
439 vc1_imode_bits, 1, 1,
440 vc1_imode_codes, 1, 1, 1);
443 init_vlc(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
444 vc1_ttmb_bits[i], 1, 1,
445 vc1_ttmb_codes[i], 2, 2, 1);
446 init_vlc(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
447 vc1_ttblk_bits[i], 1, 1,
448 vc1_ttblk_codes[i], 1, 1, 1);
449 init_vlc(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
450 vc1_subblkpat_bits[i], 1, 1,
451 vc1_subblkpat_codes[i], 1, 1, 1);
455 init_vlc(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
456 vc1_4mv_block_pattern_bits[i], 1, 1,
457 vc1_4mv_block_pattern_codes[i], 1, 1, 1);
458 init_vlc(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
459 vc1_cbpcy_p_bits[i], 1, 1,
460 vc1_cbpcy_p_codes[i], 2, 2, 1);
461 init_vlc(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
462 vc1_mv_diff_bits[i], 1, 1,
463 vc1_mv_diff_codes[i], 2, 2, 1);
466 init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
467 &vc1_ac_tables[i][0][1], 8, 4,
468 &vc1_ac_tables[i][0][0], 8, 4, 1);
469 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
470 &ff_msmp4_mb_i_table[0][1], 4, 2,
471 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
476 v->mvrange = 0; /* 7.1.1.18, p80 */
481 /***********************************************************************/
483 * @defgroup bitplane VC9 Bitplane decoding
488 /** @addtogroup bitplane
501 /** @} */ //imode defines
503 /** Decode rows by checking if they are skipped
504 * @param plane Buffer to store decoded bits
505 * @param[in] width Width of this buffer
506 * @param[in] height Height of this buffer
507 * @param[in] stride of this buffer
509 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
512 for (y=0; y<height; y++){
513 if (!get_bits(gb, 1)) //rowskip
514 memset(plane, 0, width);
516 for (x=0; x<width; x++)
517 plane[x] = get_bits(gb, 1);
522 /** Decode columns by checking if they are skipped
523 * @param plane Buffer to store decoded bits
524 * @param[in] width Width of this buffer
525 * @param[in] height Height of this buffer
526 * @param[in] stride of this buffer
527 * @fixme FIXME: Optimize
529 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
532 for (x=0; x<width; x++){
533 if (!get_bits(gb, 1)) //colskip
534 for (y=0; y<height; y++)
537 for (y=0; y<height; y++)
538 plane[y*stride] = get_bits(gb, 1);
543 /** Decode a bitplane's bits
544 * @param bp Bitplane where to store the decode bits
545 * @param v VC-1 context for bit reading and logging
547 * @fixme FIXME: Optimize
548 * @todo TODO: Decide if a struct is needed
550 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
552 GetBitContext *gb = &v->s.gb;
554 int imode, x, y, code, offset;
555 uint8_t invert, *planep = data;
556 int width, height, stride;
558 width = v->s.mb_width;
559 height = v->s.mb_height;
560 stride = v->s.mb_stride;
561 invert = get_bits(gb, 1);
562 imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
568 //Data is actually read in the MB layer (same for all tests == "raw")
569 *raw_flag = 1; //invert ignored
573 if ((height * width) & 1)
575 *planep++ = get_bits(gb, 1);
579 // decode bitplane as one long line
580 for (y = offset; y < height * width; y += 2) {
581 code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
582 *planep++ = code & 1;
584 if(offset == width) {
586 planep += stride - width;
588 *planep++ = code >> 1;
590 if(offset == width) {
592 planep += stride - width;
598 if(!(height % 3) && (width % 3)) { // use 2x3 decoding
599 for(y = 0; y < height; y+= 3) {
600 for(x = width & 1; x < width; x += 2) {
601 code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
603 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
606 planep[x + 0] = (code >> 0) & 1;
607 planep[x + 1] = (code >> 1) & 1;
608 planep[x + 0 + stride] = (code >> 2) & 1;
609 planep[x + 1 + stride] = (code >> 3) & 1;
610 planep[x + 0 + stride * 2] = (code >> 4) & 1;
611 planep[x + 1 + stride * 2] = (code >> 5) & 1;
613 planep += stride * 3;
615 if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
617 planep += (height & 1) * stride;
618 for(y = height & 1; y < height; y += 2) {
619 for(x = width % 3; x < width; x += 3) {
620 code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
622 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
625 planep[x + 0] = (code >> 0) & 1;
626 planep[x + 1] = (code >> 1) & 1;
627 planep[x + 2] = (code >> 2) & 1;
628 planep[x + 0 + stride] = (code >> 3) & 1;
629 planep[x + 1 + stride] = (code >> 4) & 1;
630 planep[x + 2 + stride] = (code >> 5) & 1;
632 planep += stride * 2;
635 if(x) decode_colskip(data , x, height , stride, &v->s.gb);
636 if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
640 decode_rowskip(data, width, height, stride, &v->s.gb);
643 decode_colskip(data, width, height, stride, &v->s.gb);
648 /* Applying diff operator */
649 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
653 for (x=1; x<width; x++)
654 planep[x] ^= planep[x-1];
655 for (y=1; y<height; y++)
658 planep[0] ^= planep[-stride];
659 for (x=1; x<width; x++)
661 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
662 else planep[x] ^= planep[x-1];
669 for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
671 return (imode<<1) + invert;
674 /** @} */ //Bitplane group
676 /***********************************************************************/
677 /** VOP Dquant decoding
678 * @param v VC-1 Context
680 static int vop_dquant_decoding(VC1Context *v)
682 GetBitContext *gb = &v->s.gb;
688 pqdiff = get_bits(gb, 3);
689 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
690 else v->altpq = v->pq + pqdiff + 1;
694 v->dquantfrm = get_bits(gb, 1);
697 v->dqprofile = get_bits(gb, 2);
698 switch (v->dqprofile)
700 case DQPROFILE_SINGLE_EDGE:
701 case DQPROFILE_DOUBLE_EDGES:
702 v->dqsbedge = get_bits(gb, 2);
704 case DQPROFILE_ALL_MBS:
705 v->dqbilevel = get_bits(gb, 1);
706 default: break; //Forbidden ?
708 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
710 pqdiff = get_bits(gb, 3);
711 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
712 else v->altpq = v->pq + pqdiff + 1;
720 /** Do inverse transform
722 static void vc1_inv_trans(DCTELEM block[64], int M, int N)
725 register int t1,t2,t3,t4,t5,t6,t7,t8;
731 for(i = 0; i < N; i++){
732 t1 = 17 * (src[0] + src[2]);
733 t2 = 17 * (src[0] - src[2]);
739 dst[0] = (t1 + t3 + t6 + 4) >> 3;
740 dst[1] = (t2 - t4 + t5 + 4) >> 3;
741 dst[2] = (t2 + t4 - t5 + 4) >> 3;
742 dst[3] = (t1 - t3 - t6 + 4) >> 3;
748 for(i = 0; i < N; i++){
749 t1 = 12 * (src[0] + src[4]);
750 t2 = 12 * (src[0] - src[4]);
751 t3 = 16 * src[2] + 6 * src[6];
752 t4 = 6 * src[2] - 16 * src[6];
759 t1 = 16 * src[1] + 15 * src[3] + 9 * src[5] + 4 * src[7];
760 t2 = 15 * src[1] - 4 * src[3] - 16 * src[5] - 9 * src[7];
761 t3 = 9 * src[1] - 16 * src[3] + 4 * src[5] + 15 * src[7];
762 t4 = 4 * src[1] - 9 * src[3] + 15 * src[5] - 16 * src[7];
764 dst[0] = (t5 + t1 + 4) >> 3;
765 dst[1] = (t6 + t2 + 4) >> 3;
766 dst[2] = (t7 + t3 + 4) >> 3;
767 dst[3] = (t8 + t4 + 4) >> 3;
768 dst[4] = (t8 - t4 + 4) >> 3;
769 dst[5] = (t7 - t3 + 4) >> 3;
770 dst[6] = (t6 - t2 + 4) >> 3;
771 dst[7] = (t5 - t1 + 4) >> 3;
781 for(i = 0; i < M; i++){
782 t1 = 17 * (src[ 0] + src[16]);
783 t2 = 17 * (src[ 0] - src[16]);
789 dst[ 0] = (t1 + t3 + t6 + 64) >> 7;
790 dst[ 8] = (t2 - t4 + t5 + 64) >> 7;
791 dst[16] = (t2 + t4 - t5 + 64) >> 7;
792 dst[24] = (t1 - t3 - t6 + 64) >> 7;
798 for(i = 0; i < M; i++){
799 t1 = 12 * (src[ 0] + src[32]);
800 t2 = 12 * (src[ 0] - src[32]);
801 t3 = 16 * src[16] + 6 * src[48];
802 t4 = 6 * src[16] - 16 * src[48];
809 t1 = 16 * src[ 8] + 15 * src[24] + 9 * src[40] + 4 * src[56];
810 t2 = 15 * src[ 8] - 4 * src[24] - 16 * src[40] - 9 * src[56];
811 t3 = 9 * src[ 8] - 16 * src[24] + 4 * src[40] + 15 * src[56];
812 t4 = 4 * src[ 8] - 9 * src[24] + 15 * src[40] - 16 * src[56];
814 dst[ 0] = (t5 + t1 + 64) >> 7;
815 dst[ 8] = (t6 + t2 + 64) >> 7;
816 dst[16] = (t7 + t3 + 64) >> 7;
817 dst[24] = (t8 + t4 + 64) >> 7;
818 dst[32] = (t8 - t4 + 64 + 1) >> 7;
819 dst[40] = (t7 - t3 + 64 + 1) >> 7;
820 dst[48] = (t6 - t2 + 64 + 1) >> 7;
821 dst[56] = (t5 - t1 + 64 + 1) >> 7;
829 /** Apply overlap transform to vertical edge
831 * @todo move to DSPContext
833 static void vc1_v_overlap(uint8_t* src, int stride)
837 for(i = 0; i < 8; i++) {
843 src[-2*stride] = clip_uint8((7*a + d + 3) >> 3);
844 src[-stride] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
845 src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
846 src[stride] = clip_uint8((a + 7*d + 3) >> 3);
851 /** Apply overlap transform to horizontal edge
853 * @todo move to DSPContext
855 static void vc1_h_overlap(uint8_t* src, int stride)
859 for(i = 0; i < 8; i++) {
865 src[-2] = clip_uint8((7*a + d + 3) >> 3);
866 src[-1] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
867 src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
868 src[1] = clip_uint8((a + 7*d + 3) >> 3);
873 /** Put block onto picture
874 * @todo move to DSPContext
876 static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
880 DSPContext *dsp = &v->s.dsp;
882 ys = v->s.current_picture.linesize[0];
883 us = v->s.current_picture.linesize[1];
884 vs = v->s.current_picture.linesize[2];
887 dsp->put_pixels_clamped(block[0], Y, ys);
888 dsp->put_pixels_clamped(block[1], Y + 8, ys);
890 dsp->put_pixels_clamped(block[2], Y, ys);
891 dsp->put_pixels_clamped(block[3], Y + 8, ys);
893 dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
894 dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
897 /* clip motion vector as specified in 8.3.6.5 */
898 #define CLIP_RANGE(mv, src, lim, bs) \
899 if(mv < -bs) mv = -bs - src * bs; \
900 if(mv > lim) mv = lim - src * bs;
902 /** Do motion compensation over 1 macroblock
903 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
905 static void vc1_mc_1mv(VC1Context *v)
907 MpegEncContext *s = &v->s;
908 DSPContext *dsp = &v->s.dsp;
909 uint8_t *srcY, *srcU, *srcV;
910 int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
912 if(!v->s.last_picture.data[0])return;
916 uvmx = (mx + ((mx & 3) == 3)) >> 1;
917 uvmy = (my + ((my & 3) == 3)) >> 1;
918 srcY = s->last_picture.data[0];
919 srcU = s->last_picture.data[1];
920 srcV = s->last_picture.data[2];
922 src_x = s->mb_x * 16 + (mx >> 2);
923 src_y = s->mb_y * 16 + (my >> 2);
924 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
925 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
927 CLIP_RANGE( src_x, s->mb_x, s->mb_width * 16, 16);
928 CLIP_RANGE( src_y, s->mb_y, s->mb_height * 16, 16);
929 CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width * 8, 8);
930 CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height * 8, 8);
932 srcY += src_y * s->linesize + src_x;
933 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
934 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
936 if((v->mv_mode == MV_PMODE_INTENSITY_COMP)
937 || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
938 || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
939 uint8_t *uvbuf= s->edge_emu_buffer + 18 * s->linesize;
941 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
942 src_x, src_y, s->h_edge_pos, s->v_edge_pos);
943 srcY = s->edge_emu_buffer;
944 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
945 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
946 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
947 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
950 /* if we deal with intensity compensation we need to scale source blocks */
951 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
956 for(j = 0; j < 17; j++) {
957 for(i = 0; i < 17; i++) src[i] = v->luty[src[i]];
960 src = srcU; src2 = srcV;
961 for(j = 0; j < 9; j++) {
962 for(i = 0; i < 9; i++) {
963 src[i] = v->lutuv[src[i]];
964 src2[i] = v->lutuv[src2[i]];
966 src += s->uvlinesize;
967 src2 += s->uvlinesize;
973 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
974 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
977 if(!s->quarter_sample) { // hpel mc
980 dxy = ((my & 1) << 1) | (mx & 1);
983 dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
985 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
987 dxy = ((my & 3) << 2) | (mx & 3);
990 dsp->put_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
992 dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
994 /* Chroma MC always uses qpel blilinear */
995 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
997 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
998 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1000 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
1001 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1005 /** Do motion compensation for 4-MV macroblock - luminance block
1007 static void vc1_mc_4mv_luma(VC1Context *v, int n)
1009 MpegEncContext *s = &v->s;
1010 DSPContext *dsp = &v->s.dsp;
1012 int dxy, mx, my, src_x, src_y;
1015 if(!v->s.last_picture.data[0])return;
1016 mx = s->mv[0][n][0];
1017 my = s->mv[0][n][1];
1018 srcY = s->last_picture.data[0];
1020 off = s->linesize * 4 * (n&2) + (n&1) * 8;
1022 src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
1023 src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
1025 CLIP_RANGE(src_x, s->mb_x, s->mb_width * 16, 16);
1026 CLIP_RANGE(src_y, s->mb_y, s->mb_height * 16, 16);
1028 srcY += src_y * s->linesize + src_x;
1030 if((unsigned)src_x > s->h_edge_pos - (mx&3) - 16
1031 || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
1032 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
1033 src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1034 srcY = s->edge_emu_buffer;
1037 if(!s->quarter_sample) { // hpel mc
1040 dxy = ((my & 1) << 1) | (mx & 1);
1043 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1045 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1047 dxy = ((my & 3) << 2) | (mx & 3);
1050 dsp->put_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
1052 dsp->put_no_rnd_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
1056 static inline int median4(int a, int b, int c, int d)
1059 if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
1060 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
1062 if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
1063 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
1068 /** Do motion compensation for 4-MV macroblock - both chroma blocks
1070 static void vc1_mc_4mv_chroma(VC1Context *v)
1072 MpegEncContext *s = &v->s;
1073 DSPContext *dsp = &v->s.dsp;
1074 uint8_t *srcU, *srcV;
1075 int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1076 int i, idx, tx = 0, ty = 0;
1077 int mvx[4], mvy[4], intra[4];
1078 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1080 if(!v->s.last_picture.data[0])return;
1082 for(i = 0; i < 4; i++) {
1083 mvx[i] = s->mv[0][i][0];
1084 mvy[i] = s->mv[0][i][1];
1085 intra[i] = v->mb_type[0][s->block_index[i]];
1088 /* calculate chroma MV vector from four luma MVs */
1089 idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1090 if(!idx) { // all blocks are inter
1091 tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1092 ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1093 } else if(count[idx] == 1) { // 3 inter blocks
1096 tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1097 ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1100 tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1101 ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1104 tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1105 ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1108 tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1109 ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1112 } else if(count[idx] == 2) {
1114 for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1115 for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1116 tx = (mvx[t1] + mvx[t2]) / 2;
1117 ty = (mvy[t1] + mvy[t2]) / 2;
1119 return; //no need to do MC for inter blocks
1121 uvmx = (tx + ((tx&3) == 3)) >> 1;
1122 uvmy = (ty + ((ty&3) == 3)) >> 1;
1124 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1125 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1127 CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width * 8, 8);
1128 CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height * 8, 8);
1129 srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1130 srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1131 if((unsigned)uvsrc_x > (s->h_edge_pos >> 1) - ((uvmx >> 1)&1) - 8
1132 || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - ((uvmy >> 1)&1) - 8){
1133 ff_emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize, 8+1, 8+1,
1134 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1135 ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1136 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1137 srcU = s->edge_emu_buffer;
1138 srcV = s->edge_emu_buffer + 16;
1142 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1143 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1146 /* Chroma MC always uses qpel blilinear */
1147 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
1149 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
1150 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1152 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
1153 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1158 * Decode Simple/Main Profiles sequence header
1159 * @see Figure 7-8, p16-17
1160 * @param avctx Codec context
1161 * @param gb GetBit context initialized from Codec context extra_data
1164 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1166 VC1Context *v = avctx->priv_data;
1168 av_log(avctx, AV_LOG_INFO, "Header: %0X\n", show_bits(gb, 32));
1169 v->profile = get_bits(gb, 2);
1170 if (v->profile == 2)
1172 av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1176 if (v->profile == PROFILE_ADVANCED)
1178 v->level = get_bits(gb, 3);
1181 av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1183 v->chromaformat = get_bits(gb, 2);
1184 if (v->chromaformat != 1)
1186 av_log(avctx, AV_LOG_ERROR,
1187 "Only 4:2:0 chroma format supported\n");
1193 v->res_sm = get_bits(gb, 2); //reserved
1196 av_log(avctx, AV_LOG_ERROR,
1197 "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1203 v->frmrtq_postproc = get_bits(gb, 3); //common
1204 // (bitrate-32kbps)/64kbps
1205 v->bitrtq_postproc = get_bits(gb, 5); //common
1206 v->s.loop_filter = get_bits(gb, 1); //common
1207 if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1209 av_log(avctx, AV_LOG_ERROR,
1210 "LOOPFILTER shell not be enabled in simple profile\n");
1213 if (v->profile < PROFILE_ADVANCED)
1215 v->res_x8 = get_bits(gb, 1); //reserved
1218 av_log(avctx, AV_LOG_ERROR,
1219 "1 for reserved RES_X8 is forbidden\n");
1222 v->multires = get_bits(gb, 1);
1223 v->res_fasttx = get_bits(gb, 1);
1226 av_log(avctx, AV_LOG_ERROR,
1227 "0 for reserved RES_FASTTX is forbidden\n");
1232 v->fastuvmc = get_bits(gb, 1); //common
1233 if (!v->profile && !v->fastuvmc)
1235 av_log(avctx, AV_LOG_ERROR,
1236 "FASTUVMC unavailable in Simple Profile\n");
1239 v->extended_mv = get_bits(gb, 1); //common
1240 if (!v->profile && v->extended_mv)
1242 av_log(avctx, AV_LOG_ERROR,
1243 "Extended MVs unavailable in Simple Profile\n");
1246 v->dquant = get_bits(gb, 2); //common
1247 v->vstransform = get_bits(gb, 1); //common
1249 if (v->profile < PROFILE_ADVANCED)
1251 v->res_transtab = get_bits(gb, 1);
1252 if (v->res_transtab)
1254 av_log(avctx, AV_LOG_ERROR,
1255 "1 for reserved RES_TRANSTAB is forbidden\n");
1260 v->overlap = get_bits(gb, 1); //common
1262 if (v->profile < PROFILE_ADVANCED)
1264 v->s.resync_marker = get_bits(gb, 1);
1265 v->rangered = get_bits(gb, 1);
1266 if (v->rangered && v->profile == PROFILE_SIMPLE)
1268 av_log(avctx, AV_LOG_INFO,
1269 "RANGERED should be set to 0 in simple profile\n");
1273 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1274 v->quantizer_mode = get_bits(gb, 2); //common
1276 if (v->profile < PROFILE_ADVANCED)
1278 v->finterpflag = get_bits(gb, 1); //common
1279 v->res_rtm_flag = get_bits(gb, 1); //reserved
1280 if (!v->res_rtm_flag)
1282 av_log(avctx, AV_LOG_ERROR,
1283 "0 for reserved RES_RTM_FLAG is forbidden\n");
1286 av_log(avctx, AV_LOG_DEBUG,
1287 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1288 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1289 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1290 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1291 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1292 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1293 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1294 v->dquant, v->quantizer_mode, avctx->max_b_frames
1302 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1304 int pqindex, lowquant, status;
1306 if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1307 skip_bits(gb, 2); //framecnt unused
1309 if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1310 v->s.pict_type = get_bits(gb, 1);
1311 if (v->s.avctx->max_b_frames) {
1312 if (!v->s.pict_type) {
1313 if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1314 else v->s.pict_type = B_TYPE;
1315 } else v->s.pict_type = P_TYPE;
1316 } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1318 if(v->s.pict_type == I_TYPE)
1319 get_bits(gb, 7); // skip buffer fullness
1322 if(v->s.pict_type == I_TYPE)
1324 if(v->s.pict_type == P_TYPE)
1327 /* Quantizer stuff */
1328 pqindex = get_bits(gb, 5);
1329 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1330 v->pq = pquant_table[0][pqindex];
1332 v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1335 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1336 v->pquantizer = pqindex < 9;
1337 if (v->quantizer_mode == QUANT_NON_UNIFORM)
1339 v->pqindex = pqindex;
1340 if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1342 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1343 v->pquantizer = get_bits(gb, 1);
1345 if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1346 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1347 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1348 v->range_x = 1 << (v->k_x - 1);
1349 v->range_y = 1 << (v->k_y - 1);
1350 if (v->profile == PROFILE_ADVANCED)
1352 if (v->postprocflag) v->postproc = get_bits(gb, 1);
1355 if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1357 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1358 // (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1360 //TODO: complete parsing for P/B/BI frames
1361 switch(v->s.pict_type) {
1363 if (v->pq < 5) v->tt_index = 0;
1364 else if(v->pq < 13) v->tt_index = 1;
1365 else v->tt_index = 2;
1367 lowquant = (v->pq > 12) ? 0 : 1;
1368 v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1369 if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1371 int scale, shift, i;
1372 v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1373 v->lumscale = get_bits(gb, 6);
1374 v->lumshift = get_bits(gb, 6);
1375 /* fill lookup tables for intensity compensation */
1378 shift = (255 - v->lumshift * 2) << 6;
1379 if(v->lumshift > 31)
1382 scale = v->lumscale + 32;
1383 if(v->lumshift > 31)
1384 shift = (v->lumshift - 64) << 6;
1386 shift = v->lumshift << 6;
1388 for(i = 0; i < 256; i++) {
1389 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1390 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1393 if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1394 v->s.quarter_sample = 0;
1395 else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1396 if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1397 v->s.quarter_sample = 0;
1399 v->s.quarter_sample = 1;
1401 v->s.quarter_sample = 1;
1403 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1404 v->mv_mode2 == MV_PMODE_MIXED_MV)
1405 || v->mv_mode == MV_PMODE_MIXED_MV)
1407 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1408 if (status < 0) return -1;
1409 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1410 "Imode: %i, Invert: %i\n", status>>1, status&1);
1412 v->mv_type_is_raw = 0;
1413 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1415 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1416 if (status < 0) return -1;
1417 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1418 "Imode: %i, Invert: %i\n", status>>1, status&1);
1420 /* Hopefully this is correct for P frames */
1421 v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1422 v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1426 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1427 vop_dquant_decoding(v);
1430 v->ttfrm = 0; //FIXME Is that so ?
1433 v->ttmbf = get_bits(gb, 1);
1436 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1445 v->c_ac_table_index = decode012(gb);
1446 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1448 v->y_ac_table_index = decode012(gb);
1451 v->s.dc_table_index = get_bits(gb, 1);
1456 /***********************************************************************/
1458 * @defgroup block VC-1 Block-level functions
1459 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1460 * @todo TODO: Integrate to MpegEncContext facilities
1466 * @brief Get macroblock-level quantizer scale
1467 * @warning XXX: qdiff to the frame quant, not previous quant ?
1468 * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1470 #define GET_MQUANT() \
1474 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1478 mquant = (get_bits(gb, 1)) ? v->altpq : v->pq; \
1482 mqdiff = get_bits(gb, 3); \
1483 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1484 else mquant = get_bits(gb, 5); \
1487 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1488 edges = 1 << v->dqsbedge; \
1489 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1490 edges = (3 << v->dqsbedge) % 15; \
1491 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
1493 if((edges&1) && !s->mb_x) \
1494 mquant = v->altpq; \
1495 if((edges&2) && s->first_slice_line) \
1496 mquant = v->altpq; \
1497 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
1498 mquant = v->altpq; \
1499 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
1500 mquant = v->altpq; \
1504 * @def GET_MVDATA(_dmv_x, _dmv_y)
1505 * @brief Get MV differentials
1506 * @see MVDATA decoding from 8.3.5.2, p(1)20
1507 * @param _dmv_x Horizontal differential for decoded MV
1508 * @param _dmv_y Vertical differential for decoded MV
1509 * @todo TODO: Use MpegEncContext arrays to store them
1511 #define GET_MVDATA(_dmv_x, _dmv_y) \
1512 index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1513 VC1_MV_DIFF_VLC_BITS, 2); \
1516 mb_has_coeffs = 1; \
1519 else mb_has_coeffs = 0; \
1521 if (!index) { _dmv_x = _dmv_y = 0; } \
1522 else if (index == 35) \
1524 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1525 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1527 else if (index == 36) \
1536 if (!s->quarter_sample && index1 == 5) val = 1; \
1538 if(size_table[index1] - val > 0) \
1539 val = get_bits(gb, size_table[index1] - val); \
1541 sign = 0 - (val&1); \
1542 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1545 if (!s->quarter_sample && index1 == 5) val = 1; \
1547 if(size_table[index1] - val > 0) \
1548 val = get_bits(gb, size_table[index1] - val); \
1550 sign = 0 - (val&1); \
1551 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1554 /** Predict and set motion vector
1556 static inline void vc1_pred_mv(MpegEncContext *s, int n, int dmv_x, int dmv_y, int mv1, int r_x, int r_y, uint8_t* is_intra)
1558 int xy, wrap, off = 0;
1563 /* scale MV difference to be quad-pel */
1564 dmv_x <<= 1 - s->quarter_sample;
1565 dmv_y <<= 1 - s->quarter_sample;
1567 wrap = s->b8_stride;
1568 xy = s->block_index[n];
1571 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1572 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1573 if(mv1) { /* duplicate motion data for 1-MV block */
1574 s->current_picture.motion_val[0][xy + 1][0] = 0;
1575 s->current_picture.motion_val[0][xy + 1][1] = 0;
1576 s->current_picture.motion_val[0][xy + wrap][0] = 0;
1577 s->current_picture.motion_val[0][xy + wrap][1] = 0;
1578 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1579 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1584 C = s->current_picture.motion_val[0][xy - 1];
1585 A = s->current_picture.motion_val[0][xy - wrap];
1587 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1589 //in 4-MV mode different blocks have different B predictor position
1592 off = (s->mb_x > 0) ? -1 : 1;
1595 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1604 B = s->current_picture.motion_val[0][xy - wrap + off];
1606 if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
1607 if(s->mb_width == 1) {
1611 px = mid_pred(A[0], B[0], C[0]);
1612 py = mid_pred(A[1], B[1], C[1]);
1614 } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
1620 /* Pullback MV as specified in 8.3.5.3.4 */
1623 qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
1624 qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
1625 X = (s->mb_width << 6) - 4;
1626 Y = (s->mb_height << 6) - 4;
1628 if(qx + px < -60) px = -60 - qx;
1629 if(qy + py < -60) py = -60 - qy;
1631 if(qx + px < -28) px = -28 - qx;
1632 if(qy + py < -28) py = -28 - qy;
1634 if(qx + px > X) px = X - qx;
1635 if(qy + py > Y) py = Y - qy;
1637 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1638 if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
1639 if(is_intra[xy - wrap])
1640 sum = ABS(px) + ABS(py);
1642 sum = ABS(px - A[0]) + ABS(py - A[1]);
1644 if(get_bits1(&s->gb)) {
1652 if(is_intra[xy - 1])
1653 sum = ABS(px) + ABS(py);
1655 sum = ABS(px - C[0]) + ABS(py - C[1]);
1657 if(get_bits1(&s->gb)) {
1667 /* store MV using signed modulus of MV range defined in 4.11 */
1668 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1669 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1670 if(mv1) { /* duplicate motion data for 1-MV block */
1671 s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
1672 s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
1673 s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
1674 s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
1675 s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
1676 s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
1680 /** Get predicted DC value for I-frames only
1681 * prediction dir: left=0, top=1
1682 * @param s MpegEncContext
1683 * @param[in] n block index in the current MB
1684 * @param dc_val_ptr Pointer to DC predictor
1685 * @param dir_ptr Prediction direction for use in AC prediction
1687 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1688 int16_t **dc_val_ptr, int *dir_ptr)
1690 int a, b, c, wrap, pred, scale;
1692 static const uint16_t dcpred[32] = {
1693 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
1694 114, 102, 93, 85, 79, 73, 68, 64,
1695 60, 57, 54, 51, 49, 47, 45, 43,
1696 41, 39, 38, 37, 35, 34, 33
1699 /* find prediction - wmv3_dc_scale always used here in fact */
1700 if (n < 4) scale = s->y_dc_scale;
1701 else scale = s->c_dc_scale;
1703 wrap = s->block_wrap[n];
1704 dc_val= s->dc_val[0] + s->block_index[n];
1710 b = dc_val[ - 1 - wrap];
1711 a = dc_val[ - wrap];
1713 if (pq < 9 || !overlap)
1715 /* Set outer values */
1716 if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
1717 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1721 /* Set outer values */
1722 if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
1723 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1726 if (abs(a - b) <= abs(b - c)) {
1734 /* update predictor */
1735 *dc_val_ptr = &dc_val[0];
1740 /** Get predicted DC value
1741 * prediction dir: left=0, top=1
1742 * @param s MpegEncContext
1743 * @param[in] n block index in the current MB
1744 * @param dc_val_ptr Pointer to DC predictor
1745 * @param dir_ptr Prediction direction for use in AC prediction
1747 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1748 int a_avail, int c_avail,
1749 int16_t **dc_val_ptr, int *dir_ptr)
1751 int a, b, c, wrap, pred, scale;
1753 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1756 /* find prediction - wmv3_dc_scale always used here in fact */
1757 if (n < 4) scale = s->y_dc_scale;
1758 else scale = s->c_dc_scale;
1760 wrap = s->block_wrap[n];
1761 dc_val= s->dc_val[0] + s->block_index[n];
1767 b = dc_val[ - 1 - wrap];
1768 a = dc_val[ - wrap];
1770 if(a_avail && c_avail) {
1771 if(abs(a - b) <= abs(b - c)) {
1774 q2 = s->current_picture.qscale_table[mb_pos - 1];
1778 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
1780 } else if(a_avail) {
1783 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
1784 } else if(c_avail) {
1787 q2 = s->current_picture.qscale_table[mb_pos - 1];
1793 /* scale coeffs if needed */
1794 q1 = s->current_picture.qscale_table[mb_pos];
1798 pred = (pred * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1801 /* update predictor */
1802 *dc_val_ptr = &dc_val[0];
1808 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
1809 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1810 * @todo TODO: Integrate to MpegEncContext facilities
1814 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1816 int xy, wrap, pred, a, b, c;
1818 xy = s->block_index[n];
1819 wrap = s->b8_stride;
1824 a = s->coded_block[xy - 1 ];
1825 b = s->coded_block[xy - 1 - wrap];
1826 c = s->coded_block[xy - wrap];
1835 *coded_block_ptr = &s->coded_block[xy];
1841 * Decode one AC coefficient
1842 * @param v The VC1 context
1843 * @param last Last coefficient
1844 * @param skip How much zero coefficients to skip
1845 * @param value Decoded AC coefficient value
1848 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
1850 GetBitContext *gb = &v->s.gb;
1851 int index, escape, run = 0, level = 0, lst = 0;
1853 index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1854 if (index != vc1_ac_sizes[codingset] - 1) {
1855 run = vc1_index_decode_table[codingset][index][0];
1856 level = vc1_index_decode_table[codingset][index][1];
1857 lst = index >= vc1_last_decode_table[codingset];
1861 escape = decode210(gb);
1863 index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1864 run = vc1_index_decode_table[codingset][index][0];
1865 level = vc1_index_decode_table[codingset][index][1];
1866 lst = index >= vc1_last_decode_table[codingset];
1869 level += vc1_last_delta_level_table[codingset][run];
1871 level += vc1_delta_level_table[codingset][run];
1874 run += vc1_last_delta_run_table[codingset][level] + 1;
1876 run += vc1_delta_run_table[codingset][level] + 1;
1882 lst = get_bits(gb, 1);
1883 if(v->s.esc3_level_length == 0) {
1884 if(v->pq < 8 || v->dquantfrm) { // table 59
1885 v->s.esc3_level_length = get_bits(gb, 3);
1886 if(!v->s.esc3_level_length)
1887 v->s.esc3_level_length = get_bits(gb, 2) + 8;
1889 v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
1891 v->s.esc3_run_length = 3 + get_bits(gb, 2);
1893 run = get_bits(gb, v->s.esc3_run_length);
1894 sign = get_bits(gb, 1);
1895 level = get_bits(gb, v->s.esc3_level_length);
1906 /** Decode intra block in intra frames - should be faster than decode_intra_block
1907 * @param v VC1Context
1908 * @param block block to decode
1909 * @param coded are AC coeffs present or not
1910 * @param codingset set of VLC to decode data
1912 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
1914 GetBitContext *gb = &v->s.gb;
1915 MpegEncContext *s = &v->s;
1916 int dc_pred_dir = 0; /* Direction of the DC prediction used */
1919 int16_t *ac_val, *ac_val2;
1922 /* Get DC differential */
1924 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1926 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1929 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1934 if (dcdiff == 119 /* ESC index value */)
1936 /* TODO: Optimize */
1937 if (v->pq == 1) dcdiff = get_bits(gb, 10);
1938 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
1939 else dcdiff = get_bits(gb, 8);
1944 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1945 else if (v->pq == 2)
1946 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1948 if (get_bits(gb, 1))
1953 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
1956 /* Store the quantized DC coeff, used for prediction */
1958 block[0] = dcdiff * s->y_dc_scale;
1960 block[0] = dcdiff * s->c_dc_scale;
1973 int last = 0, skip, value;
1974 const int8_t *zz_table;
1978 scale = v->pq * 2 + v->halfpq;
1982 zz_table = vc1_horizontal_zz;
1984 zz_table = vc1_vertical_zz;
1986 zz_table = vc1_normal_zz;
1988 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1990 if(dc_pred_dir) //left
1993 ac_val -= 16 * s->block_wrap[n];
1996 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2000 block[zz_table[i++]] = value;
2003 /* apply AC prediction if needed */
2005 if(dc_pred_dir) { //left
2006 for(k = 1; k < 8; k++)
2007 block[k << 3] += ac_val[k];
2009 for(k = 1; k < 8; k++)
2010 block[k] += ac_val[k + 8];
2013 /* save AC coeffs for further prediction */
2014 for(k = 1; k < 8; k++) {
2015 ac_val2[k] = block[k << 3];
2016 ac_val2[k + 8] = block[k];
2019 /* scale AC coeffs */
2020 for(k = 1; k < 64; k++)
2024 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2027 if(s->ac_pred) i = 63;
2033 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2036 scale = v->pq * 2 + v->halfpq;
2037 memset(ac_val2, 0, 16 * 2);
2038 if(dc_pred_dir) {//left
2041 memcpy(ac_val2, ac_val, 8 * 2);
2043 ac_val -= 16 * s->block_wrap[n];
2045 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2048 /* apply AC prediction if needed */
2050 if(dc_pred_dir) { //left
2051 for(k = 1; k < 8; k++) {
2052 block[k << 3] = ac_val[k] * scale;
2054 block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2057 for(k = 1; k < 8; k++) {
2058 block[k] = ac_val[k + 8] * scale;
2060 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2066 s->block_last_index[n] = i;
2071 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2072 * @param v VC1Context
2073 * @param block block to decode
2074 * @param coded are AC coeffs present or not
2075 * @param mquant block quantizer
2076 * @param codingset set of VLC to decode data
2078 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
2080 GetBitContext *gb = &v->s.gb;
2081 MpegEncContext *s = &v->s;
2082 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2085 int16_t *ac_val, *ac_val2;
2087 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2088 int a_avail = v->a_avail, c_avail = v->c_avail;
2089 int use_pred = s->ac_pred;
2093 /* XXX: Guard against dumb values of mquant */
2094 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
2096 /* Set DC scale - y and c use the same */
2097 s->y_dc_scale = s->y_dc_scale_table[mquant];
2098 s->c_dc_scale = s->c_dc_scale_table[mquant];
2100 /* Get DC differential */
2102 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2104 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2107 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2112 if (dcdiff == 119 /* ESC index value */)
2114 /* TODO: Optimize */
2115 if (mquant == 1) dcdiff = get_bits(gb, 10);
2116 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2117 else dcdiff = get_bits(gb, 8);
2122 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2123 else if (mquant == 2)
2124 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2126 if (get_bits(gb, 1))
2131 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2134 /* Store the quantized DC coeff, used for prediction */
2137 block[0] = dcdiff * s->y_dc_scale;
2139 block[0] = dcdiff * s->c_dc_scale;
2148 /* check if AC is needed at all and adjust direction if needed */
2149 if(!a_avail) dc_pred_dir = 1;
2150 if(!c_avail) dc_pred_dir = 0;
2151 if(!a_avail && !c_avail) use_pred = 0;
2152 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2155 scale = mquant * 2 + v->halfpq;
2157 if(dc_pred_dir) //left
2160 ac_val -= 16 * s->block_wrap[n];
2162 q1 = s->current_picture.qscale_table[mb_pos];
2163 if(dc_pred_dir && c_avail) q2 = s->current_picture.qscale_table[mb_pos - 1];
2164 if(!dc_pred_dir && a_avail) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2165 if(n && n<4) q2 = q1;
2168 int last = 0, skip, value;
2169 const int8_t *zz_table;
2172 zz_table = vc1_simple_progressive_8x8_zz;
2175 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2179 block[zz_table[i++]] = value;
2182 /* apply AC prediction if needed */
2184 /* scale predictors if needed*/
2189 if(dc_pred_dir) { //left
2190 for(k = 1; k < 8; k++)
2191 block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2193 for(k = 1; k < 8; k++)
2194 block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2197 if(dc_pred_dir) { //left
2198 for(k = 1; k < 8; k++)
2199 block[k << 3] += ac_val[k];
2201 for(k = 1; k < 8; k++)
2202 block[k] += ac_val[k + 8];
2206 /* save AC coeffs for further prediction */
2207 for(k = 1; k < 8; k++) {
2208 ac_val2[k] = block[k << 3];
2209 ac_val2[k + 8] = block[k];
2212 /* scale AC coeffs */
2213 for(k = 1; k < 64; k++)
2217 block[k] += (block[k] < 0) ? -mquant : mquant;
2220 if(use_pred) i = 63;
2221 } else { // no AC coeffs
2224 memset(ac_val2, 0, 16 * 2);
2225 if(dc_pred_dir) {//left
2227 memcpy(ac_val2, ac_val, 8 * 2);
2231 for(k = 1; k < 8; k++)
2232 ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2237 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2241 for(k = 1; k < 8; k++)
2242 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2247 /* apply AC prediction if needed */
2249 if(dc_pred_dir) { //left
2250 for(k = 1; k < 8; k++) {
2251 block[k << 3] = ac_val2[k] * scale;
2253 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2256 for(k = 1; k < 8; k++) {
2257 block[k] = ac_val2[k + 8] * scale;
2259 block[k] += (block[k] < 0) ? -mquant : mquant;
2265 s->block_last_index[n] = i;
2272 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
2274 MpegEncContext *s = &v->s;
2275 GetBitContext *gb = &s->gb;
2278 int scale, off, idx, last, skip, value;
2279 int ttblk = ttmb & 7;
2282 ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
2284 if(ttblk == TT_4X4) {
2285 subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
2287 if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
2288 subblkpat = decode012(gb);
2289 if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
2290 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
2291 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
2293 scale = 2 * mquant + v->halfpq;
2295 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2296 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
2297 subblkpat = 2 - (ttblk == TT_8X4_TOP);
2300 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
2301 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
2309 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2313 idx = vc1_simple_progressive_8x8_zz[i++];
2314 block[idx] = value * scale;
2316 block[idx] += (block[idx] < 0) ? -mquant : mquant;
2318 vc1_inv_trans(block, 8, 8);
2321 for(j = 0; j < 4; j++) {
2322 last = subblkpat & (1 << (3 - j));
2324 off = (j & 1) * 4 + (j & 2) * 16;
2326 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2330 idx = vc1_simple_progressive_4x4_zz[i++];
2331 block[idx + off] = value * scale;
2333 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2335 if(!(subblkpat & (1 << (3 - j))))
2336 vc1_inv_trans(block + off, 4, 4);
2340 for(j = 0; j < 2; j++) {
2341 last = subblkpat & (1 << (1 - j));
2345 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2349 idx = vc1_simple_progressive_8x4_zz[i++];
2350 block[idx + off] = value * scale;
2352 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2354 if(!(subblkpat & (1 << (1 - j))))
2355 vc1_inv_trans(block + off, 8, 4);
2359 for(j = 0; j < 2; j++) {
2360 last = subblkpat & (1 << (1 - j));
2364 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2368 idx = vc1_simple_progressive_4x8_zz[i++];
2369 block[idx + off] = value * scale;
2371 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2373 if(!(subblkpat & (1 << (1 - j))))
2374 vc1_inv_trans(block + off, 4, 8);
2382 /** Decode one P-frame MB (in Simple/Main profile)
2383 * @todo TODO: Extend to AP
2384 * @fixme FIXME: DC value for inter blocks not set
2386 static int vc1_decode_p_mb(VC1Context *v)
2388 MpegEncContext *s = &v->s;
2389 GetBitContext *gb = &s->gb;
2391 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2392 int cbp; /* cbp decoding stuff */
2393 int mqdiff, mquant; /* MB quantization */
2394 int ttmb = v->ttfrm; /* MB Transform type */
2397 static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2398 offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2399 int mb_has_coeffs = 1; /* last_flag */
2400 int dmv_x, dmv_y; /* Differential MV components */
2401 int index, index1; /* LUT indices */
2402 int val, sign; /* temp values */
2403 int first_block = 1;
2405 int skipped, fourmv;
2407 mquant = v->pq; /* Loosy initialization */
2409 if (v->mv_type_is_raw)
2410 fourmv = get_bits1(gb);
2412 fourmv = v->mv_type_mb_plane[mb_pos];
2414 skipped = get_bits1(gb);
2416 skipped = v->s.mbskip_table[mb_pos];
2418 s->dsp.clear_blocks(s->block[0]);
2420 if (!fourmv) /* 1MV mode */
2424 GET_MVDATA(dmv_x, dmv_y);
2426 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
2427 vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
2429 /* FIXME Set DC val for inter block ? */
2430 if (s->mb_intra && !mb_has_coeffs)
2433 s->ac_pred = get_bits(gb, 1);
2436 else if (mb_has_coeffs)
2438 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2439 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2447 s->current_picture.qscale_table[mb_pos] = mquant;
2449 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2450 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2451 VC1_TTMB_VLC_BITS, 2);
2452 if(!s->mb_intra) vc1_mc_1mv(v);
2456 s->dc_val[0][s->block_index[i]] = 0;
2458 val = ((cbp >> (5 - i)) & 1);
2459 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2460 v->mb_type[0][s->block_index[i]] = s->mb_intra;
2462 /* check if prediction blocks A and C are available */
2463 v->a_avail = v->c_avail = 0;
2464 if(i == 2 || i == 3 || !s->first_slice_line)
2465 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2466 if(i == 1 || i == 3 || s->mb_x)
2467 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2469 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2470 vc1_inv_trans(s->block[i], 8, 8);
2471 for(j = 0; j < 64; j++) s->block[i][j] += 128;
2472 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2473 /* TODO: proper loop filtering */
2474 if(v->pq >= 9 && v->overlap) {
2476 vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2478 vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2481 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2482 if(!v->ttmbf && ttmb < 8) ttmb = -1;
2484 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2491 for(i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
2492 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
2493 s->current_picture.qscale_table[mb_pos] = 0;
2494 vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
2501 if (!skipped /* unskipped MB */)
2503 int intra_count = 0, coded_inter = 0;
2504 int is_intra[6], is_coded[6];
2506 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2509 val = ((cbp >> (5 - i)) & 1);
2510 s->dc_val[0][s->block_index[i]] = 0;
2517 GET_MVDATA(dmv_x, dmv_y);
2519 vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
2520 if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
2521 intra_count += s->mb_intra;
2522 is_intra[i] = s->mb_intra;
2523 is_coded[i] = mb_has_coeffs;
2526 is_intra[i] = (intra_count >= 3);
2529 if(i == 4) vc1_mc_4mv_chroma(v);
2530 v->mb_type[0][s->block_index[i]] = is_intra[i];
2531 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
2533 // if there are no coded blocks then don't do anything more
2534 if(!intra_count && !coded_inter) return;
2537 s->current_picture.qscale_table[mb_pos] = mquant;
2538 /* test if block is intra and has pred */
2543 if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
2544 || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
2549 if(intrapred)s->ac_pred = get_bits(gb, 1);
2550 else s->ac_pred = 0;
2552 if (!v->ttmbf && coded_inter)
2553 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 12);
2557 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2558 s->mb_intra = is_intra[i];
2560 /* check if prediction blocks A and C are available */
2561 v->a_avail = v->c_avail = 0;
2562 if(i == 2 || i == 3 || !s->first_slice_line)
2563 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2564 if(i == 1 || i == 3 || s->mb_x)
2565 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2567 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
2568 vc1_inv_trans(s->block[i], 8, 8);
2569 for(j = 0; j < 64; j++) s->block[i][j] += 128;
2570 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2571 /* TODO: proper loop filtering */
2572 if(v->pq >= 9 && v->overlap) {
2574 vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2576 vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2578 } else if(is_coded[i]) {
2579 status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2580 if(!v->ttmbf && ttmb < 8) ttmb = -1;
2582 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2590 for (i=0; i<6; i++) v->mb_type[0][s->block_index[i]] = 0;
2593 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
2594 vc1_mc_4mv_luma(v, i);
2596 vc1_mc_4mv_chroma(v);
2597 s->current_picture.qscale_table[mb_pos] = 0;
2602 /* Should never happen */
2606 /** Decode blocks of I-frame
2608 static void vc1_decode_i_blocks(VC1Context *v)
2611 MpegEncContext *s = &v->s;
2616 /* select codingmode used for VLC tables selection */
2617 switch(v->y_ac_table_index){
2619 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2622 v->codingset = CS_HIGH_MOT_INTRA;
2625 v->codingset = CS_MID_RATE_INTRA;
2629 switch(v->c_ac_table_index){
2631 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2634 v->codingset2 = CS_HIGH_MOT_INTER;
2637 v->codingset2 = CS_MID_RATE_INTER;
2641 /* Set DC scale - y and c use the same */
2642 s->y_dc_scale = s->y_dc_scale_table[v->pq];
2643 s->c_dc_scale = s->c_dc_scale_table[v->pq];
2646 s->mb_x = s->mb_y = 0;
2648 s->first_slice_line = 1;
2649 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2650 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2651 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2652 ff_init_block_index(s);
2653 ff_update_block_index(s);
2654 s->dsp.clear_blocks(s->block[0]);
2655 mb_pos = s->mb_x + s->mb_y * s->mb_width;
2656 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2657 s->current_picture.qscale_table[mb_pos] = v->pq;
2659 // do actual MB decoding and displaying
2660 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2661 v->s.ac_pred = get_bits(&v->s.gb, 1);
2663 for(k = 0; k < 6; k++) {
2664 val = ((cbp >> (5 - k)) & 1);
2667 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2671 cbp |= val << (5 - k);
2673 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
2675 vc1_inv_trans(s->block[k], 8, 8);
2676 if(v->pq >= 9 && v->overlap) {
2677 for(j = 0; j < 64; j++) s->block[k][j] += 128;
2681 vc1_put_block(v, s->block);
2682 if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
2683 if(!s->first_slice_line) {
2684 vc1_v_overlap(s->dest[0], s->linesize);
2685 vc1_v_overlap(s->dest[0] + 8, s->linesize);
2686 vc1_v_overlap(s->dest[1], s->uvlinesize);
2687 vc1_v_overlap(s->dest[2], s->uvlinesize);
2689 vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2690 vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2692 vc1_h_overlap(s->dest[0], s->linesize);
2693 vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2694 vc1_h_overlap(s->dest[1], s->uvlinesize);
2695 vc1_h_overlap(s->dest[2], s->uvlinesize);
2697 vc1_h_overlap(s->dest[0] + 8, s->linesize);
2698 vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2701 if(get_bits_count(&s->gb) > v->bits) {
2702 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
2706 ff_draw_horiz_band(s, s->mb_y * 16, 16);
2707 s->first_slice_line = 0;
2711 static void vc1_decode_p_blocks(VC1Context *v)
2713 MpegEncContext *s = &v->s;
2715 /* select codingmode used for VLC tables selection */
2716 switch(v->c_ac_table_index){
2718 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2721 v->codingset = CS_HIGH_MOT_INTRA;
2724 v->codingset = CS_MID_RATE_INTRA;
2728 switch(v->c_ac_table_index){
2730 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2733 v->codingset2 = CS_HIGH_MOT_INTER;
2736 v->codingset2 = CS_MID_RATE_INTER;
2740 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2741 s->first_slice_line = 1;
2742 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2743 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2744 ff_init_block_index(s);
2745 ff_update_block_index(s);
2746 s->dsp.clear_blocks(s->block[0]);
2749 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
2750 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);
2754 ff_draw_horiz_band(s, s->mb_y * 16, 16);
2755 s->first_slice_line = 0;
2759 static void vc1_decode_blocks(VC1Context *v)
2762 v->s.esc3_level_length = 0;
2764 switch(v->s.pict_type) {
2766 vc1_decode_i_blocks(v);
2769 vc1_decode_p_blocks(v);
2775 /** Initialize a VC1/WMV3 decoder
2776 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2777 * @todo TODO: Decypher remaining bits in extra_data
2779 static int vc1_decode_init(AVCodecContext *avctx)
2781 VC1Context *v = avctx->priv_data;
2782 MpegEncContext *s = &v->s;
2785 if (!avctx->extradata_size || !avctx->extradata) return -1;
2786 avctx->pix_fmt = PIX_FMT_YUV420P;
2788 avctx->flags |= CODEC_FLAG_EMU_EDGE;
2789 v->s.flags |= CODEC_FLAG_EMU_EDGE;
2791 if(ff_h263_decode_init(avctx) < 0)
2793 if (vc1_init_common(v) < 0) return -1;
2795 av_log(avctx, AV_LOG_INFO, "This decoder is not supposed to produce picture. Dont report this as a bug!\n");
2796 av_log(avctx, AV_LOG_INFO, "If you see a picture, don't believe your eyes.\n");
2798 avctx->coded_width = avctx->width;
2799 avctx->coded_height = avctx->height;
2800 if (avctx->codec_id == CODEC_ID_WMV3)
2804 // looks like WMV3 has a sequence header stored in the extradata
2805 // advanced sequence header may be before the first frame
2806 // the last byte of the extradata is a version number, 1 for the
2807 // samples we can decode
2809 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2811 if (decode_sequence_header(avctx, &gb) < 0)
2814 count = avctx->extradata_size*8 - get_bits_count(&gb);
2817 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2818 count, get_bits(&gb, count));
2822 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2825 avctx->has_b_frames= !!(avctx->max_b_frames);
2827 s->mb_width = (avctx->coded_width+15)>>4;
2828 s->mb_height = (avctx->coded_height+15)>>4;
2830 /* Allocate mb bitplanes */
2831 v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
2833 /* allocate block type info in that way so it could be used with s->block_index[] */
2834 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
2835 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
2836 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
2837 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
2839 /* Init coded blocks info */
2840 if (v->profile == PROFILE_ADVANCED)
2842 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2844 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2852 /** Decode a VC1/WMV3 frame
2853 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2854 * @warning Initial try at using MpegEncContext stuff
2856 static int vc1_decode_frame(AVCodecContext *avctx,
2857 void *data, int *data_size,
2858 uint8_t *buf, int buf_size)
2860 VC1Context *v = avctx->priv_data;
2861 MpegEncContext *s = &v->s;
2862 AVFrame *pict = data;
2864 /* no supplementary picture */
2865 if (buf_size == 0) {
2866 /* special case for last picture */
2867 if (s->low_delay==0 && s->next_picture_ptr) {
2868 *pict= *(AVFrame*)s->next_picture_ptr;
2869 s->next_picture_ptr= NULL;
2871 *data_size = sizeof(AVFrame);
2877 //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2878 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2879 int i= ff_find_unused_picture(s, 0);
2880 s->current_picture_ptr= &s->picture[i];
2883 avctx->has_b_frames= !s->low_delay;
2885 init_get_bits(&s->gb, buf, buf_size*8);
2886 // do parse frame header
2887 if(vc1_parse_frame_header(v, &s->gb) == -1)
2890 if(s->pict_type != I_TYPE && s->pict_type != P_TYPE)return -1;
2893 s->current_picture.pict_type= s->pict_type;
2894 s->current_picture.key_frame= s->pict_type == I_TYPE;
2896 /* skip B-frames if we don't have reference frames */
2897 if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return -1;//buf_size;
2898 /* skip b frames if we are in a hurry */
2899 if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
2900 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
2901 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
2902 || avctx->skip_frame >= AVDISCARD_ALL)
2904 /* skip everything if we are in a hurry>=5 */
2905 if(avctx->hurry_up>=5) return -1;//buf_size;
2907 if(s->next_p_frame_damaged){
2908 if(s->pict_type==B_TYPE)
2911 s->next_p_frame_damaged=0;
2914 if(MPV_frame_start(s, avctx) < 0)
2917 ff_er_frame_start(s);
2919 v->bits = buf_size * 8;
2920 vc1_decode_blocks(v);
2921 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
2922 // if(get_bits_count(&s->gb) > buf_size * 8)
2928 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2929 assert(s->current_picture.pict_type == s->pict_type);
2930 if (s->pict_type == B_TYPE || s->low_delay) {
2931 *pict= *(AVFrame*)s->current_picture_ptr;
2932 } else if (s->last_picture_ptr != NULL) {
2933 *pict= *(AVFrame*)s->last_picture_ptr;
2936 if(s->last_picture_ptr || s->low_delay){
2937 *data_size = sizeof(AVFrame);
2938 ff_print_debug_info(s, pict);
2941 /* Return the Picture timestamp as the frame number */
2942 /* we substract 1 because it is added on utils.c */
2943 avctx->frame_number = s->picture_number - 1;
2949 /** Close a VC1/WMV3 decoder
2950 * @warning Initial try at using MpegEncContext stuff
2952 static int vc1_decode_end(AVCodecContext *avctx)
2954 VC1Context *v = avctx->priv_data;
2956 av_freep(&v->hrd_rate);
2957 av_freep(&v->hrd_buffer);
2958 MPV_common_end(&v->s);
2959 av_freep(&v->mv_type_mb_plane);
2960 av_freep(&v->mb_type_base);
2965 AVCodec vc1_decoder = {
2978 AVCodec wmv3_decoder = {