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 /** Do motion compensation over 1 macroblock
898 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
900 static void vc1_mc_1mv(VC1Context *v)
902 MpegEncContext *s = &v->s;
903 DSPContext *dsp = &v->s.dsp;
904 uint8_t *srcY, *srcU, *srcV;
905 int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
907 if(!v->s.last_picture.data[0])return;
911 uvmx = (mx + ((mx & 3) == 3)) >> 1;
912 uvmy = (my + ((my & 3) == 3)) >> 1;
913 srcY = s->last_picture.data[0];
914 srcU = s->last_picture.data[1];
915 srcV = s->last_picture.data[2];
917 src_x = s->mb_x * 16 + (mx >> 2);
918 src_y = s->mb_y * 16 + (my >> 2);
919 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
920 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
922 src_x = clip( src_x, -16, s->mb_width * 16);
923 src_y = clip( src_y, -16, s->mb_height * 16);
924 uvsrc_x = clip(uvsrc_x, -8, s->mb_width * 8);
925 uvsrc_y = clip(uvsrc_y, -8, s->mb_height * 8);
927 srcY += src_y * s->linesize + src_x;
928 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
929 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
931 if((v->mv_mode == MV_PMODE_INTENSITY_COMP)
932 || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
933 || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
934 uint8_t *uvbuf= s->edge_emu_buffer + 18 * s->linesize;
936 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
937 src_x, src_y, s->h_edge_pos, s->v_edge_pos);
938 srcY = s->edge_emu_buffer;
939 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
940 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
941 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
942 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
945 /* if we deal with intensity compensation we need to scale source blocks */
946 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
951 for(j = 0; j < 17; j++) {
952 for(i = 0; i < 17; i++) src[i] = v->luty[src[i]];
955 src = srcU; src2 = srcV;
956 for(j = 0; j < 9; j++) {
957 for(i = 0; i < 9; i++) {
958 src[i] = v->lutuv[src[i]];
959 src2[i] = v->lutuv[src2[i]];
961 src += s->uvlinesize;
962 src2 += s->uvlinesize;
968 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
969 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
972 if(!s->quarter_sample) { // hpel mc
975 dxy = ((my & 1) << 1) | (mx & 1);
978 dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
980 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
982 dxy = ((my & 3) << 2) | (mx & 3);
985 dsp->put_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
987 dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
989 /* Chroma MC always uses qpel blilinear */
990 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
992 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
993 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
995 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
996 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1000 /** Do motion compensation for 4-MV macroblock - luminance block
1002 static void vc1_mc_4mv_luma(VC1Context *v, int n)
1004 MpegEncContext *s = &v->s;
1005 DSPContext *dsp = &v->s.dsp;
1007 int dxy, mx, my, src_x, src_y;
1010 if(!v->s.last_picture.data[0])return;
1011 mx = s->mv[0][n][0];
1012 my = s->mv[0][n][1];
1013 srcY = s->last_picture.data[0];
1015 off = s->linesize * 4 * (n&2) + (n&1) * 8;
1017 src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
1018 src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
1020 src_x = clip( src_x, -16, s->mb_width * 16);
1021 src_y = clip( src_y, -16, s->mb_height * 16);
1023 srcY += src_y * s->linesize + src_x;
1025 if((unsigned)src_x > s->h_edge_pos - (mx&3) - 16
1026 || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
1027 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
1028 src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1029 srcY = s->edge_emu_buffer;
1032 if(!s->quarter_sample) { // hpel mc
1035 dxy = ((my & 1) << 1) | (mx & 1);
1038 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1040 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1042 dxy = ((my & 3) << 2) | (mx & 3);
1045 dsp->put_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
1047 dsp->put_no_rnd_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
1051 static inline int median4(int a, int b, int c, int d)
1054 if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
1055 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
1057 if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
1058 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
1063 /** Do motion compensation for 4-MV macroblock - both chroma blocks
1065 static void vc1_mc_4mv_chroma(VC1Context *v)
1067 MpegEncContext *s = &v->s;
1068 DSPContext *dsp = &v->s.dsp;
1069 uint8_t *srcU, *srcV;
1070 int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1071 int i, idx, tx = 0, ty = 0;
1072 int mvx[4], mvy[4], intra[4];
1073 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1075 if(!v->s.last_picture.data[0])return;
1077 for(i = 0; i < 4; i++) {
1078 mvx[i] = s->mv[0][i][0];
1079 mvy[i] = s->mv[0][i][1];
1080 intra[i] = v->mb_type[0][s->block_index[i]];
1083 /* calculate chroma MV vector from four luma MVs */
1084 idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1085 if(!idx) { // all blocks are inter
1086 tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1087 ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1088 } else if(count[idx] == 1) { // 3 inter blocks
1091 tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1092 ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1095 tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1096 ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1099 tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1100 ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1103 tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1104 ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1107 } else if(count[idx] == 2) {
1109 for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1110 for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1111 tx = (mvx[t1] + mvx[t2]) / 2;
1112 ty = (mvy[t1] + mvy[t2]) / 2;
1114 return; //no need to do MC for inter blocks
1116 uvmx = (tx + ((tx&3) == 3)) >> 1;
1117 uvmy = (ty + ((ty&3) == 3)) >> 1;
1119 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1120 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1122 uvsrc_x = clip(uvsrc_x, -8, s->mb_width * 8);
1123 uvsrc_y = clip(uvsrc_y, -8, s->mb_height * 8);
1124 srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1125 srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1126 if((unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
1127 || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
1128 ff_emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize, 8+1, 8+1,
1129 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1130 ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1131 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1132 srcU = s->edge_emu_buffer;
1133 srcV = s->edge_emu_buffer + 16;
1137 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1138 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1141 /* Chroma MC always uses qpel blilinear */
1142 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
1144 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
1145 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1147 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
1148 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1153 * Decode Simple/Main Profiles sequence header
1154 * @see Figure 7-8, p16-17
1155 * @param avctx Codec context
1156 * @param gb GetBit context initialized from Codec context extra_data
1159 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1161 VC1Context *v = avctx->priv_data;
1163 av_log(avctx, AV_LOG_INFO, "Header: %0X\n", show_bits(gb, 32));
1164 v->profile = get_bits(gb, 2);
1165 if (v->profile == 2)
1167 av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1171 if (v->profile == PROFILE_ADVANCED)
1173 v->level = get_bits(gb, 3);
1176 av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1178 v->chromaformat = get_bits(gb, 2);
1179 if (v->chromaformat != 1)
1181 av_log(avctx, AV_LOG_ERROR,
1182 "Only 4:2:0 chroma format supported\n");
1188 v->res_sm = get_bits(gb, 2); //reserved
1191 av_log(avctx, AV_LOG_ERROR,
1192 "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1198 v->frmrtq_postproc = get_bits(gb, 3); //common
1199 // (bitrate-32kbps)/64kbps
1200 v->bitrtq_postproc = get_bits(gb, 5); //common
1201 v->s.loop_filter = get_bits(gb, 1); //common
1202 if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1204 av_log(avctx, AV_LOG_ERROR,
1205 "LOOPFILTER shell not be enabled in simple profile\n");
1208 if (v->profile < PROFILE_ADVANCED)
1210 v->res_x8 = get_bits(gb, 1); //reserved
1213 av_log(avctx, AV_LOG_ERROR,
1214 "1 for reserved RES_X8 is forbidden\n");
1217 v->multires = get_bits(gb, 1);
1218 v->res_fasttx = get_bits(gb, 1);
1221 av_log(avctx, AV_LOG_ERROR,
1222 "0 for reserved RES_FASTTX is forbidden\n");
1227 v->fastuvmc = get_bits(gb, 1); //common
1228 if (!v->profile && !v->fastuvmc)
1230 av_log(avctx, AV_LOG_ERROR,
1231 "FASTUVMC unavailable in Simple Profile\n");
1234 v->extended_mv = get_bits(gb, 1); //common
1235 if (!v->profile && v->extended_mv)
1237 av_log(avctx, AV_LOG_ERROR,
1238 "Extended MVs unavailable in Simple Profile\n");
1241 v->dquant = get_bits(gb, 2); //common
1242 v->vstransform = get_bits(gb, 1); //common
1244 if (v->profile < PROFILE_ADVANCED)
1246 v->res_transtab = get_bits(gb, 1);
1247 if (v->res_transtab)
1249 av_log(avctx, AV_LOG_ERROR,
1250 "1 for reserved RES_TRANSTAB is forbidden\n");
1255 v->overlap = get_bits(gb, 1); //common
1257 if (v->profile < PROFILE_ADVANCED)
1259 v->s.resync_marker = get_bits(gb, 1);
1260 v->rangered = get_bits(gb, 1);
1261 if (v->rangered && v->profile == PROFILE_SIMPLE)
1263 av_log(avctx, AV_LOG_INFO,
1264 "RANGERED should be set to 0 in simple profile\n");
1268 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1269 v->quantizer_mode = get_bits(gb, 2); //common
1271 if (v->profile < PROFILE_ADVANCED)
1273 v->finterpflag = get_bits(gb, 1); //common
1274 v->res_rtm_flag = get_bits(gb, 1); //reserved
1275 if (!v->res_rtm_flag)
1277 av_log(avctx, AV_LOG_ERROR,
1278 "0 for reserved RES_RTM_FLAG is forbidden\n");
1281 av_log(avctx, AV_LOG_DEBUG,
1282 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1283 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1284 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1285 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1286 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1287 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1288 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1289 v->dquant, v->quantizer_mode, avctx->max_b_frames
1297 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1299 int pqindex, lowquant, status;
1301 if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1302 skip_bits(gb, 2); //framecnt unused
1304 if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1305 v->s.pict_type = get_bits(gb, 1);
1306 if (v->s.avctx->max_b_frames) {
1307 if (!v->s.pict_type) {
1308 if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1309 else v->s.pict_type = B_TYPE;
1310 } else v->s.pict_type = P_TYPE;
1311 } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1313 if(v->s.pict_type == I_TYPE)
1314 get_bits(gb, 7); // skip buffer fullness
1317 if(v->s.pict_type == I_TYPE)
1319 if(v->s.pict_type == P_TYPE)
1322 /* Quantizer stuff */
1323 pqindex = get_bits(gb, 5);
1324 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1325 v->pq = pquant_table[0][pqindex];
1327 v->pq = pquant_table[1][pqindex];
1330 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1331 v->pquantizer = pqindex < 9;
1332 if (v->quantizer_mode == QUANT_NON_UNIFORM)
1334 v->pqindex = pqindex;
1335 if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1337 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1338 v->pquantizer = get_bits(gb, 1);
1340 if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1341 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1342 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1343 v->range_x = 1 << (v->k_x - 1);
1344 v->range_y = 1 << (v->k_y - 1);
1345 if (v->profile == PROFILE_ADVANCED)
1347 if (v->postprocflag) v->postproc = get_bits(gb, 1);
1350 if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1352 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1353 // (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1355 //TODO: complete parsing for P/B/BI frames
1356 switch(v->s.pict_type) {
1358 if (v->pq < 5) v->tt_index = 0;
1359 else if(v->pq < 13) v->tt_index = 1;
1360 else v->tt_index = 2;
1362 lowquant = (v->pq > 12) ? 0 : 1;
1363 v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1364 if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1366 int scale, shift, i;
1367 v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1368 v->lumscale = get_bits(gb, 6);
1369 v->lumshift = get_bits(gb, 6);
1370 /* fill lookup tables for intensity compensation */
1373 shift = (255 - v->lumshift * 2) << 6;
1374 if(v->lumshift > 31)
1377 scale = v->lumscale + 32;
1378 if(v->lumshift > 31)
1379 shift = (v->lumshift - 64) << 6;
1381 shift = v->lumshift << 6;
1383 for(i = 0; i < 256; i++) {
1384 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1385 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1388 if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1389 v->s.quarter_sample = 0;
1390 else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1391 if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1392 v->s.quarter_sample = 0;
1394 v->s.quarter_sample = 1;
1396 v->s.quarter_sample = 1;
1398 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1399 v->mv_mode2 == MV_PMODE_MIXED_MV)
1400 || v->mv_mode == MV_PMODE_MIXED_MV)
1402 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1403 if (status < 0) return -1;
1404 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1405 "Imode: %i, Invert: %i\n", status>>1, status&1);
1407 v->mv_type_is_raw = 0;
1408 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1410 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1411 if (status < 0) return -1;
1412 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1413 "Imode: %i, Invert: %i\n", status>>1, status&1);
1415 /* Hopefully this is correct for P frames */
1416 v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1417 v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1421 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1422 vop_dquant_decoding(v);
1425 v->ttfrm = 0; //FIXME Is that so ?
1428 v->ttmbf = get_bits(gb, 1);
1431 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1443 v->c_ac_table_index = decode012(gb);
1444 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1446 v->y_ac_table_index = decode012(gb);
1449 v->s.dc_table_index = get_bits(gb, 1);
1454 /***********************************************************************/
1456 * @defgroup block VC-1 Block-level functions
1457 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1458 * @todo TODO: Integrate to MpegEncContext facilities
1464 * @brief Get macroblock-level quantizer scale
1465 * @warning XXX: qdiff to the frame quant, not previous quant ?
1466 * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1468 #define GET_MQUANT() \
1472 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1476 mquant = (get_bits(gb, 1)) ? v->altpq : v->pq; \
1480 mqdiff = get_bits(gb, 3); \
1481 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1482 else mquant = get_bits(gb, 5); \
1485 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1486 edges = 1 << v->dqsbedge; \
1487 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1488 edges = (3 << v->dqsbedge) % 15; \
1489 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
1491 if((edges&1) && !s->mb_x) \
1492 mquant = v->altpq; \
1493 if((edges&2) && s->first_slice_line) \
1494 mquant = v->altpq; \
1495 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
1496 mquant = v->altpq; \
1497 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
1498 mquant = v->altpq; \
1502 * @def GET_MVDATA(_dmv_x, _dmv_y)
1503 * @brief Get MV differentials
1504 * @see MVDATA decoding from 8.3.5.2, p(1)20
1505 * @param _dmv_x Horizontal differential for decoded MV
1506 * @param _dmv_y Vertical differential for decoded MV
1507 * @todo TODO: Use MpegEncContext arrays to store them
1509 #define GET_MVDATA(_dmv_x, _dmv_y) \
1510 index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1511 VC1_MV_DIFF_VLC_BITS, 2); \
1514 mb_has_coeffs = 1; \
1517 else mb_has_coeffs = 0; \
1519 if (!index) { _dmv_x = _dmv_y = 0; } \
1520 else if (index == 35) \
1522 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1523 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1525 else if (index == 36) \
1534 if (!s->quarter_sample && index1 == 5) val = 1; \
1536 if(size_table[index1] - val > 0) \
1537 val = get_bits(gb, size_table[index1] - val); \
1539 sign = 0 - (val&1); \
1540 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1543 if (!s->quarter_sample && index1 == 5) val = 1; \
1545 if(size_table[index1] - val > 0) \
1546 val = get_bits(gb, size_table[index1] - val); \
1548 sign = 0 - (val&1); \
1549 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1552 /** Predict and set motion vector
1554 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)
1556 int xy, wrap, off = 0;
1561 /* scale MV difference to be quad-pel */
1562 dmv_x <<= 1 - s->quarter_sample;
1563 dmv_y <<= 1 - s->quarter_sample;
1565 wrap = s->b8_stride;
1566 xy = s->block_index[n];
1569 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1570 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1571 if(mv1) { /* duplicate motion data for 1-MV block */
1572 s->current_picture.motion_val[0][xy + 1][0] = 0;
1573 s->current_picture.motion_val[0][xy + 1][1] = 0;
1574 s->current_picture.motion_val[0][xy + wrap][0] = 0;
1575 s->current_picture.motion_val[0][xy + wrap][1] = 0;
1576 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1577 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1582 C = s->current_picture.motion_val[0][xy - 1];
1583 A = s->current_picture.motion_val[0][xy - wrap];
1585 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1587 //in 4-MV mode different blocks have different B predictor position
1590 off = (s->mb_x > 0) ? -1 : 1;
1593 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1602 B = s->current_picture.motion_val[0][xy - wrap + off];
1604 if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
1605 if(s->mb_width == 1) {
1609 px = mid_pred(A[0], B[0], C[0]);
1610 py = mid_pred(A[1], B[1], C[1]);
1612 } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
1618 /* Pullback MV as specified in 8.3.5.3.4 */
1621 qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
1622 qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
1623 X = (s->mb_width << 6) - 4;
1624 Y = (s->mb_height << 6) - 4;
1626 if(qx + px < -60) px = -60 - qx;
1627 if(qy + py < -60) py = -60 - qy;
1629 if(qx + px < -28) px = -28 - qx;
1630 if(qy + py < -28) py = -28 - qy;
1632 if(qx + px > X) px = X - qx;
1633 if(qy + py > Y) py = Y - qy;
1635 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1636 if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
1637 if(is_intra[xy - wrap])
1638 sum = ABS(px) + ABS(py);
1640 sum = ABS(px - A[0]) + ABS(py - A[1]);
1642 if(get_bits1(&s->gb)) {
1650 if(is_intra[xy - 1])
1651 sum = ABS(px) + ABS(py);
1653 sum = ABS(px - C[0]) + ABS(py - C[1]);
1655 if(get_bits1(&s->gb)) {
1665 /* store MV using signed modulus of MV range defined in 4.11 */
1666 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1667 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1668 if(mv1) { /* duplicate motion data for 1-MV block */
1669 s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
1670 s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
1671 s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
1672 s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
1673 s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
1674 s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
1678 /** Get predicted DC value for I-frames only
1679 * prediction dir: left=0, top=1
1680 * @param s MpegEncContext
1681 * @param[in] n block index in the current MB
1682 * @param dc_val_ptr Pointer to DC predictor
1683 * @param dir_ptr Prediction direction for use in AC prediction
1685 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1686 int16_t **dc_val_ptr, int *dir_ptr)
1688 int a, b, c, wrap, pred, scale;
1690 static const uint16_t dcpred[32] = {
1691 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
1692 114, 102, 93, 85, 79, 73, 68, 64,
1693 60, 57, 54, 51, 49, 47, 45, 43,
1694 41, 39, 38, 37, 35, 34, 33
1697 /* find prediction - wmv3_dc_scale always used here in fact */
1698 if (n < 4) scale = s->y_dc_scale;
1699 else scale = s->c_dc_scale;
1701 wrap = s->block_wrap[n];
1702 dc_val= s->dc_val[0] + s->block_index[n];
1708 b = dc_val[ - 1 - wrap];
1709 a = dc_val[ - wrap];
1711 if (pq < 9 || !overlap)
1713 /* Set outer values */
1714 if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
1715 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1719 /* Set outer values */
1720 if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
1721 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1724 if (abs(a - b) <= abs(b - c)) {
1732 /* update predictor */
1733 *dc_val_ptr = &dc_val[0];
1738 /** Get predicted DC value
1739 * prediction dir: left=0, top=1
1740 * @param s MpegEncContext
1741 * @param[in] n block index in the current MB
1742 * @param dc_val_ptr Pointer to DC predictor
1743 * @param dir_ptr Prediction direction for use in AC prediction
1745 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1746 int a_avail, int c_avail,
1747 int16_t **dc_val_ptr, int *dir_ptr)
1749 int a, b, c, wrap, pred, scale;
1751 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1754 /* find prediction - wmv3_dc_scale always used here in fact */
1755 if (n < 4) scale = s->y_dc_scale;
1756 else scale = s->c_dc_scale;
1758 wrap = s->block_wrap[n];
1759 dc_val= s->dc_val[0] + s->block_index[n];
1765 b = dc_val[ - 1 - wrap];
1766 a = dc_val[ - wrap];
1767 /* scale predictors if needed */
1768 q1 = s->current_picture.qscale_table[mb_pos];
1769 if(c_avail && (n!= 1 && n!=3)) {
1770 q2 = s->current_picture.qscale_table[mb_pos - 1];
1772 c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1774 if(a_avail && (n!= 2 && n!=3)) {
1775 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
1777 a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1779 if(a_avail && c_avail && (n!=3)) {
1782 if(n != 2) off -= s->mb_stride;
1783 q2 = s->current_picture.qscale_table[off];
1785 b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1788 if(a_avail && c_avail) {
1789 if(abs(a - b) <= abs(b - c)) {
1796 } else if(a_avail) {
1799 } else if(c_avail) {
1807 /* update predictor */
1808 *dc_val_ptr = &dc_val[0];
1814 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
1815 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1816 * @todo TODO: Integrate to MpegEncContext facilities
1820 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1822 int xy, wrap, pred, a, b, c;
1824 xy = s->block_index[n];
1825 wrap = s->b8_stride;
1830 a = s->coded_block[xy - 1 ];
1831 b = s->coded_block[xy - 1 - wrap];
1832 c = s->coded_block[xy - wrap];
1841 *coded_block_ptr = &s->coded_block[xy];
1847 * Decode one AC coefficient
1848 * @param v The VC1 context
1849 * @param last Last coefficient
1850 * @param skip How much zero coefficients to skip
1851 * @param value Decoded AC coefficient value
1854 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
1856 GetBitContext *gb = &v->s.gb;
1857 int index, escape, run = 0, level = 0, lst = 0;
1859 index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1860 if (index != vc1_ac_sizes[codingset] - 1) {
1861 run = vc1_index_decode_table[codingset][index][0];
1862 level = vc1_index_decode_table[codingset][index][1];
1863 lst = index >= vc1_last_decode_table[codingset];
1867 escape = decode210(gb);
1869 index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1870 run = vc1_index_decode_table[codingset][index][0];
1871 level = vc1_index_decode_table[codingset][index][1];
1872 lst = index >= vc1_last_decode_table[codingset];
1875 level += vc1_last_delta_level_table[codingset][run];
1877 level += vc1_delta_level_table[codingset][run];
1880 run += vc1_last_delta_run_table[codingset][level] + 1;
1882 run += vc1_delta_run_table[codingset][level] + 1;
1888 lst = get_bits(gb, 1);
1889 if(v->s.esc3_level_length == 0) {
1890 if(v->pq < 8 || v->dquantfrm) { // table 59
1891 v->s.esc3_level_length = get_bits(gb, 3);
1892 if(!v->s.esc3_level_length)
1893 v->s.esc3_level_length = get_bits(gb, 2) + 8;
1895 v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
1897 v->s.esc3_run_length = 3 + get_bits(gb, 2);
1899 run = get_bits(gb, v->s.esc3_run_length);
1900 sign = get_bits(gb, 1);
1901 level = get_bits(gb, v->s.esc3_level_length);
1912 /** Decode intra block in intra frames - should be faster than decode_intra_block
1913 * @param v VC1Context
1914 * @param block block to decode
1915 * @param coded are AC coeffs present or not
1916 * @param codingset set of VLC to decode data
1918 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
1920 GetBitContext *gb = &v->s.gb;
1921 MpegEncContext *s = &v->s;
1922 int dc_pred_dir = 0; /* Direction of the DC prediction used */
1925 int16_t *ac_val, *ac_val2;
1928 /* Get DC differential */
1930 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1932 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1935 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1940 if (dcdiff == 119 /* ESC index value */)
1942 /* TODO: Optimize */
1943 if (v->pq == 1) dcdiff = get_bits(gb, 10);
1944 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
1945 else dcdiff = get_bits(gb, 8);
1950 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1951 else if (v->pq == 2)
1952 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1954 if (get_bits(gb, 1))
1959 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
1962 /* Store the quantized DC coeff, used for prediction */
1964 block[0] = dcdiff * s->y_dc_scale;
1966 block[0] = dcdiff * s->c_dc_scale;
1979 int last = 0, skip, value;
1980 const int8_t *zz_table;
1984 scale = v->pq * 2 + v->halfpq;
1988 zz_table = vc1_horizontal_zz;
1990 zz_table = vc1_vertical_zz;
1992 zz_table = vc1_normal_zz;
1994 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1996 if(dc_pred_dir) //left
1999 ac_val -= 16 * s->block_wrap[n];
2002 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2006 block[zz_table[i++]] = value;
2009 /* apply AC prediction if needed */
2011 if(dc_pred_dir) { //left
2012 for(k = 1; k < 8; k++)
2013 block[k << 3] += ac_val[k];
2015 for(k = 1; k < 8; k++)
2016 block[k] += ac_val[k + 8];
2019 /* save AC coeffs for further prediction */
2020 for(k = 1; k < 8; k++) {
2021 ac_val2[k] = block[k << 3];
2022 ac_val2[k + 8] = block[k];
2025 /* scale AC coeffs */
2026 for(k = 1; k < 64; k++)
2030 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2033 if(s->ac_pred) i = 63;
2039 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2042 scale = v->pq * 2 + v->halfpq;
2043 memset(ac_val2, 0, 16 * 2);
2044 if(dc_pred_dir) {//left
2047 memcpy(ac_val2, ac_val, 8 * 2);
2049 ac_val -= 16 * s->block_wrap[n];
2051 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2054 /* apply AC prediction if needed */
2056 if(dc_pred_dir) { //left
2057 for(k = 1; k < 8; k++) {
2058 block[k << 3] = ac_val[k] * scale;
2059 if(!v->pquantizer && block[k << 3])
2060 block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2063 for(k = 1; k < 8; k++) {
2064 block[k] = ac_val[k + 8] * scale;
2065 if(!v->pquantizer && block[k])
2066 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2072 s->block_last_index[n] = i;
2077 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2078 * @param v VC1Context
2079 * @param block block to decode
2080 * @param coded are AC coeffs present or not
2081 * @param mquant block quantizer
2082 * @param codingset set of VLC to decode data
2084 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
2086 GetBitContext *gb = &v->s.gb;
2087 MpegEncContext *s = &v->s;
2088 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2091 int16_t *ac_val, *ac_val2;
2093 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2094 int a_avail = v->a_avail, c_avail = v->c_avail;
2095 int use_pred = s->ac_pred;
2099 /* XXX: Guard against dumb values of mquant */
2100 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
2102 /* Set DC scale - y and c use the same */
2103 s->y_dc_scale = s->y_dc_scale_table[mquant];
2104 s->c_dc_scale = s->c_dc_scale_table[mquant];
2106 /* Get DC differential */
2108 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2110 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2113 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2118 if (dcdiff == 119 /* ESC index value */)
2120 /* TODO: Optimize */
2121 if (mquant == 1) dcdiff = get_bits(gb, 10);
2122 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2123 else dcdiff = get_bits(gb, 8);
2128 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2129 else if (mquant == 2)
2130 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2132 if (get_bits(gb, 1))
2137 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2140 /* Store the quantized DC coeff, used for prediction */
2143 block[0] = dcdiff * s->y_dc_scale;
2145 block[0] = dcdiff * s->c_dc_scale;
2154 /* check if AC is needed at all and adjust direction if needed */
2155 if(!a_avail) dc_pred_dir = 1;
2156 if(!c_avail) dc_pred_dir = 0;
2157 if(!a_avail && !c_avail) use_pred = 0;
2158 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2161 scale = mquant * 2 + v->halfpq;
2163 if(dc_pred_dir) //left
2166 ac_val -= 16 * s->block_wrap[n];
2168 q1 = s->current_picture.qscale_table[mb_pos];
2169 if(dc_pred_dir && c_avail) q2 = s->current_picture.qscale_table[mb_pos - 1];
2170 if(!dc_pred_dir && a_avail) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2171 if(n && n<4) q2 = q1;
2174 int last = 0, skip, value;
2175 const int8_t *zz_table;
2178 zz_table = vc1_simple_progressive_8x8_zz;
2181 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2185 block[zz_table[i++]] = value;
2188 /* apply AC prediction if needed */
2190 /* scale predictors if needed*/
2195 if(dc_pred_dir) { //left
2196 for(k = 1; k < 8; k++)
2197 block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2199 for(k = 1; k < 8; k++)
2200 block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2203 if(dc_pred_dir) { //left
2204 for(k = 1; k < 8; k++)
2205 block[k << 3] += ac_val[k];
2207 for(k = 1; k < 8; k++)
2208 block[k] += ac_val[k + 8];
2212 /* save AC coeffs for further prediction */
2213 for(k = 1; k < 8; k++) {
2214 ac_val2[k] = block[k << 3];
2215 ac_val2[k + 8] = block[k];
2218 /* scale AC coeffs */
2219 for(k = 1; k < 64; k++)
2223 block[k] += (block[k] < 0) ? -mquant : mquant;
2226 if(use_pred) i = 63;
2227 } else { // no AC coeffs
2230 memset(ac_val2, 0, 16 * 2);
2231 if(dc_pred_dir) {//left
2233 memcpy(ac_val2, ac_val, 8 * 2);
2237 for(k = 1; k < 8; k++)
2238 ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2243 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2247 for(k = 1; k < 8; k++)
2248 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2253 /* apply AC prediction if needed */
2255 if(dc_pred_dir) { //left
2256 for(k = 1; k < 8; k++) {
2257 block[k << 3] = ac_val2[k] * scale;
2258 if(!v->pquantizer && block[k << 3])
2259 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2262 for(k = 1; k < 8; k++) {
2263 block[k] = ac_val2[k + 8] * scale;
2264 if(!v->pquantizer && block[k])
2265 block[k] += (block[k] < 0) ? -mquant : mquant;
2271 s->block_last_index[n] = i;
2278 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
2280 MpegEncContext *s = &v->s;
2281 GetBitContext *gb = &s->gb;
2284 int scale, off, idx, last, skip, value;
2285 int ttblk = ttmb & 7;
2288 ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
2290 if(ttblk == TT_4X4) {
2291 subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
2293 if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
2294 subblkpat = decode012(gb);
2295 if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
2296 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
2297 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
2299 scale = 2 * mquant + v->halfpq;
2301 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2302 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
2303 subblkpat = 2 - (ttblk == TT_8X4_TOP);
2306 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
2307 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
2315 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2319 idx = vc1_simple_progressive_8x8_zz[i++];
2320 block[idx] = value * scale;
2322 block[idx] += (block[idx] < 0) ? -mquant : mquant;
2324 vc1_inv_trans(block, 8, 8);
2327 for(j = 0; j < 4; j++) {
2328 last = subblkpat & (1 << (3 - j));
2330 off = (j & 1) * 4 + (j & 2) * 16;
2332 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2336 idx = vc1_simple_progressive_4x4_zz[i++];
2337 block[idx + off] = value * scale;
2339 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2341 if(!(subblkpat & (1 << (3 - j))))
2342 vc1_inv_trans(block + off, 4, 4);
2346 for(j = 0; j < 2; j++) {
2347 last = subblkpat & (1 << (1 - j));
2351 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2355 idx = vc1_simple_progressive_8x4_zz[i++];
2356 block[idx + off] = value * scale;
2358 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2360 if(!(subblkpat & (1 << (1 - j))))
2361 vc1_inv_trans(block + off, 8, 4);
2365 for(j = 0; j < 2; j++) {
2366 last = subblkpat & (1 << (1 - j));
2370 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2374 idx = vc1_simple_progressive_4x8_zz[i++];
2375 block[idx + off] = value * scale;
2377 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2379 if(!(subblkpat & (1 << (1 - j))))
2380 vc1_inv_trans(block + off, 4, 8);
2388 /** Decode one P-frame MB (in Simple/Main profile)
2389 * @todo TODO: Extend to AP
2390 * @fixme FIXME: DC value for inter blocks not set
2392 static int vc1_decode_p_mb(VC1Context *v)
2394 MpegEncContext *s = &v->s;
2395 GetBitContext *gb = &s->gb;
2397 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2398 int cbp; /* cbp decoding stuff */
2399 int mqdiff, mquant; /* MB quantization */
2400 int ttmb = v->ttfrm; /* MB Transform type */
2403 static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2404 offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2405 int mb_has_coeffs = 1; /* last_flag */
2406 int dmv_x, dmv_y; /* Differential MV components */
2407 int index, index1; /* LUT indices */
2408 int val, sign; /* temp values */
2409 int first_block = 1;
2411 int skipped, fourmv;
2413 mquant = v->pq; /* Loosy initialization */
2415 if (v->mv_type_is_raw)
2416 fourmv = get_bits1(gb);
2418 fourmv = v->mv_type_mb_plane[mb_pos];
2420 skipped = get_bits1(gb);
2422 skipped = v->s.mbskip_table[mb_pos];
2424 s->dsp.clear_blocks(s->block[0]);
2426 if (!fourmv) /* 1MV mode */
2430 GET_MVDATA(dmv_x, dmv_y);
2432 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
2433 vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
2435 /* FIXME Set DC val for inter block ? */
2436 if (s->mb_intra && !mb_has_coeffs)
2439 s->ac_pred = get_bits(gb, 1);
2442 else if (mb_has_coeffs)
2444 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2445 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2453 s->current_picture.qscale_table[mb_pos] = mquant;
2455 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2456 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2457 VC1_TTMB_VLC_BITS, 2);
2458 if(!s->mb_intra) vc1_mc_1mv(v);
2462 s->dc_val[0][s->block_index[i]] = 0;
2464 val = ((cbp >> (5 - i)) & 1);
2465 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2466 v->mb_type[0][s->block_index[i]] = s->mb_intra;
2468 /* check if prediction blocks A and C are available */
2469 v->a_avail = v->c_avail = 0;
2470 if(i == 2 || i == 3 || !s->first_slice_line)
2471 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2472 if(i == 1 || i == 3 || s->mb_x)
2473 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2475 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2476 vc1_inv_trans(s->block[i], 8, 8);
2477 for(j = 0; j < 64; j++) s->block[i][j] += 128;
2478 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2479 /* TODO: proper loop filtering */
2480 if(v->pq >= 9 && v->overlap) {
2482 vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2484 vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2487 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2488 if(!v->ttmbf && ttmb < 8) ttmb = -1;
2490 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2497 for(i = 0; i < 6; i++) {
2498 v->mb_type[0][s->block_index[i]] = 0;
2499 s->dc_val[0][s->block_index[i]] = 0;
2501 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
2502 s->current_picture.qscale_table[mb_pos] = 0;
2503 vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
2510 if (!skipped /* unskipped MB */)
2512 int intra_count = 0, coded_inter = 0;
2513 int is_intra[6], is_coded[6];
2515 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2518 val = ((cbp >> (5 - i)) & 1);
2519 s->dc_val[0][s->block_index[i]] = 0;
2526 GET_MVDATA(dmv_x, dmv_y);
2528 vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
2529 if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
2530 intra_count += s->mb_intra;
2531 is_intra[i] = s->mb_intra;
2532 is_coded[i] = mb_has_coeffs;
2535 is_intra[i] = (intra_count >= 3);
2538 if(i == 4) vc1_mc_4mv_chroma(v);
2539 v->mb_type[0][s->block_index[i]] = is_intra[i];
2540 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
2542 // if there are no coded blocks then don't do anything more
2543 if(!intra_count && !coded_inter) return;
2546 s->current_picture.qscale_table[mb_pos] = mquant;
2547 /* test if block is intra and has pred */
2552 if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
2553 || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
2558 if(intrapred)s->ac_pred = get_bits(gb, 1);
2559 else s->ac_pred = 0;
2561 if (!v->ttmbf && coded_inter)
2562 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 12);
2566 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2567 s->mb_intra = is_intra[i];
2569 /* check if prediction blocks A and C are available */
2570 v->a_avail = v->c_avail = 0;
2571 if(i == 2 || i == 3 || !s->first_slice_line)
2572 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2573 if(i == 1 || i == 3 || s->mb_x)
2574 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2576 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
2577 vc1_inv_trans(s->block[i], 8, 8);
2578 for(j = 0; j < 64; j++) s->block[i][j] += 128;
2579 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2580 /* TODO: proper loop filtering */
2581 if(v->pq >= 9 && v->overlap) {
2583 vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2585 vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2587 } else if(is_coded[i]) {
2588 status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2589 if(!v->ttmbf && ttmb < 8) ttmb = -1;
2591 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2599 for (i=0; i<6; i++) {
2600 v->mb_type[0][s->block_index[i]] = 0;
2601 s->dc_val[0][s->block_index[i]] = 0;
2605 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
2606 vc1_mc_4mv_luma(v, i);
2608 vc1_mc_4mv_chroma(v);
2609 s->current_picture.qscale_table[mb_pos] = 0;
2614 /* Should never happen */
2618 /** Decode blocks of I-frame
2620 static void vc1_decode_i_blocks(VC1Context *v)
2623 MpegEncContext *s = &v->s;
2628 /* select codingmode used for VLC tables selection */
2629 switch(v->y_ac_table_index){
2631 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2634 v->codingset = CS_HIGH_MOT_INTRA;
2637 v->codingset = CS_MID_RATE_INTRA;
2641 switch(v->c_ac_table_index){
2643 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2646 v->codingset2 = CS_HIGH_MOT_INTER;
2649 v->codingset2 = CS_MID_RATE_INTER;
2653 /* Set DC scale - y and c use the same */
2654 s->y_dc_scale = s->y_dc_scale_table[v->pq];
2655 s->c_dc_scale = s->c_dc_scale_table[v->pq];
2658 s->mb_x = s->mb_y = 0;
2660 s->first_slice_line = 1;
2661 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2662 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2663 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2664 ff_init_block_index(s);
2665 ff_update_block_index(s);
2666 s->dsp.clear_blocks(s->block[0]);
2667 mb_pos = s->mb_x + s->mb_y * s->mb_width;
2668 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2669 s->current_picture.qscale_table[mb_pos] = v->pq;
2671 // do actual MB decoding and displaying
2672 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2673 v->s.ac_pred = get_bits(&v->s.gb, 1);
2675 for(k = 0; k < 6; k++) {
2676 val = ((cbp >> (5 - k)) & 1);
2679 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2683 cbp |= val << (5 - k);
2685 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
2687 vc1_inv_trans(s->block[k], 8, 8);
2688 if(v->pq >= 9 && v->overlap) {
2689 for(j = 0; j < 64; j++) s->block[k][j] += 128;
2693 vc1_put_block(v, s->block);
2694 if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
2695 if(!s->first_slice_line) {
2696 vc1_v_overlap(s->dest[0], s->linesize);
2697 vc1_v_overlap(s->dest[0] + 8, s->linesize);
2698 vc1_v_overlap(s->dest[1], s->uvlinesize);
2699 vc1_v_overlap(s->dest[2], s->uvlinesize);
2701 vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2702 vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2704 vc1_h_overlap(s->dest[0], s->linesize);
2705 vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2706 vc1_h_overlap(s->dest[1], s->uvlinesize);
2707 vc1_h_overlap(s->dest[2], s->uvlinesize);
2709 vc1_h_overlap(s->dest[0] + 8, s->linesize);
2710 vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2713 if(get_bits_count(&s->gb) > v->bits) {
2714 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
2718 ff_draw_horiz_band(s, s->mb_y * 16, 16);
2719 s->first_slice_line = 0;
2723 static void vc1_decode_p_blocks(VC1Context *v)
2725 MpegEncContext *s = &v->s;
2727 /* select codingmode used for VLC tables selection */
2728 switch(v->c_ac_table_index){
2730 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2733 v->codingset = CS_HIGH_MOT_INTRA;
2736 v->codingset = CS_MID_RATE_INTRA;
2740 switch(v->c_ac_table_index){
2742 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2745 v->codingset2 = CS_HIGH_MOT_INTER;
2748 v->codingset2 = CS_MID_RATE_INTER;
2752 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2753 s->first_slice_line = 1;
2754 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2755 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2756 ff_init_block_index(s);
2757 ff_update_block_index(s);
2758 s->dsp.clear_blocks(s->block[0]);
2761 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
2762 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);
2766 ff_draw_horiz_band(s, s->mb_y * 16, 16);
2767 s->first_slice_line = 0;
2771 static void vc1_decode_blocks(VC1Context *v)
2774 v->s.esc3_level_length = 0;
2776 switch(v->s.pict_type) {
2778 vc1_decode_i_blocks(v);
2781 vc1_decode_p_blocks(v);
2787 /** Initialize a VC1/WMV3 decoder
2788 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2789 * @todo TODO: Decypher remaining bits in extra_data
2791 static int vc1_decode_init(AVCodecContext *avctx)
2793 VC1Context *v = avctx->priv_data;
2794 MpegEncContext *s = &v->s;
2797 if (!avctx->extradata_size || !avctx->extradata) return -1;
2798 avctx->pix_fmt = PIX_FMT_YUV420P;
2800 avctx->flags |= CODEC_FLAG_EMU_EDGE;
2801 v->s.flags |= CODEC_FLAG_EMU_EDGE;
2803 if(ff_h263_decode_init(avctx) < 0)
2805 if (vc1_init_common(v) < 0) return -1;
2807 avctx->coded_width = avctx->width;
2808 avctx->coded_height = avctx->height;
2809 if (avctx->codec_id == CODEC_ID_WMV3)
2813 // looks like WMV3 has a sequence header stored in the extradata
2814 // advanced sequence header may be before the first frame
2815 // the last byte of the extradata is a version number, 1 for the
2816 // samples we can decode
2818 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2820 if (decode_sequence_header(avctx, &gb) < 0)
2823 count = avctx->extradata_size*8 - get_bits_count(&gb);
2826 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2827 count, get_bits(&gb, count));
2831 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2834 avctx->has_b_frames= !!(avctx->max_b_frames);
2836 s->mb_width = (avctx->coded_width+15)>>4;
2837 s->mb_height = (avctx->coded_height+15)>>4;
2839 /* Allocate mb bitplanes */
2840 v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
2842 /* allocate block type info in that way so it could be used with s->block_index[] */
2843 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
2844 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
2845 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
2846 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
2848 /* Init coded blocks info */
2849 if (v->profile == PROFILE_ADVANCED)
2851 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2853 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2861 /** Decode a VC1/WMV3 frame
2862 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2863 * @warning Initial try at using MpegEncContext stuff
2865 static int vc1_decode_frame(AVCodecContext *avctx,
2866 void *data, int *data_size,
2867 uint8_t *buf, int buf_size)
2869 VC1Context *v = avctx->priv_data;
2870 MpegEncContext *s = &v->s;
2871 AVFrame *pict = data;
2873 /* no supplementary picture */
2874 if (buf_size == 0) {
2875 /* special case for last picture */
2876 if (s->low_delay==0 && s->next_picture_ptr) {
2877 *pict= *(AVFrame*)s->next_picture_ptr;
2878 s->next_picture_ptr= NULL;
2880 *data_size = sizeof(AVFrame);
2886 //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2887 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2888 int i= ff_find_unused_picture(s, 0);
2889 s->current_picture_ptr= &s->picture[i];
2892 avctx->has_b_frames= !s->low_delay;
2894 init_get_bits(&s->gb, buf, buf_size*8);
2895 // do parse frame header
2896 if(vc1_parse_frame_header(v, &s->gb) == -1)
2899 if(s->pict_type != I_TYPE && s->pict_type != P_TYPE)return -1;
2902 s->current_picture.pict_type= s->pict_type;
2903 s->current_picture.key_frame= s->pict_type == I_TYPE;
2905 /* skip B-frames if we don't have reference frames */
2906 if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return -1;//buf_size;
2907 /* skip b frames if we are in a hurry */
2908 if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
2909 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
2910 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
2911 || avctx->skip_frame >= AVDISCARD_ALL)
2913 /* skip everything if we are in a hurry>=5 */
2914 if(avctx->hurry_up>=5) return -1;//buf_size;
2916 if(s->next_p_frame_damaged){
2917 if(s->pict_type==B_TYPE)
2920 s->next_p_frame_damaged=0;
2923 if(MPV_frame_start(s, avctx) < 0)
2926 ff_er_frame_start(s);
2928 v->bits = buf_size * 8;
2929 vc1_decode_blocks(v);
2930 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
2931 // if(get_bits_count(&s->gb) > buf_size * 8)
2937 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2938 assert(s->current_picture.pict_type == s->pict_type);
2939 if (s->pict_type == B_TYPE || s->low_delay) {
2940 *pict= *(AVFrame*)s->current_picture_ptr;
2941 } else if (s->last_picture_ptr != NULL) {
2942 *pict= *(AVFrame*)s->last_picture_ptr;
2945 if(s->last_picture_ptr || s->low_delay){
2946 *data_size = sizeof(AVFrame);
2947 ff_print_debug_info(s, pict);
2950 /* Return the Picture timestamp as the frame number */
2951 /* we substract 1 because it is added on utils.c */
2952 avctx->frame_number = s->picture_number - 1;
2958 /** Close a VC1/WMV3 decoder
2959 * @warning Initial try at using MpegEncContext stuff
2961 static int vc1_decode_end(AVCodecContext *avctx)
2963 VC1Context *v = avctx->priv_data;
2965 av_freep(&v->hrd_rate);
2966 av_freep(&v->hrd_buffer);
2967 MPV_common_end(&v->s);
2968 av_freep(&v->mv_type_mb_plane);
2969 av_freep(&v->mb_type_base);
2974 AVCodec vc1_decoder = {
2987 AVCodec wmv3_decoder = {