2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2006-2007 Konstantin Shishkov
4 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * VC-1 and WMV3 decoder
32 #include "mpegvideo.h"
34 #include "vc1acdata.h"
39 extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];
40 extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];
41 extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];
42 #define MB_INTRA_VLC_BITS 9
43 extern VLC ff_msmp4_mb_i_vlc;
44 extern const uint16_t ff_msmp4_mb_i_table[64][2];
47 static const uint16_t table_mb_intra[64][2];
49 /** Markers used if VC-1 AP frame data */
52 VC1_CODE_RES0 = 0x00000100,
53 VC1_CODE_ENDOFSEQ = 0x0000010A,
62 /** Available Profiles */
67 PROFILE_COMPLEX, ///< TODO: WMV9 specific
72 /** Sequence quantizer mode */
75 QUANT_FRAME_IMPLICIT, ///< Implicitly specified at frame level
76 QUANT_FRAME_EXPLICIT, ///< Explicitly specified at frame level
77 QUANT_NON_UNIFORM, ///< Non-uniform quant used for all frames
78 QUANT_UNIFORM ///< Uniform quant used for all frames
82 /** Where quant can be changed */
86 DQPROFILE_DOUBLE_EDGES,
87 DQPROFILE_SINGLE_EDGE,
92 /** @name Where quant can be changed
103 /** Which pair of edges is quantized with ALTPQUANT */
106 DQDOUBLE_BEDGE_TOPLEFT,
107 DQDOUBLE_BEDGE_TOPRIGHT,
108 DQDOUBLE_BEDGE_BOTTOMRIGHT,
109 DQDOUBLE_BEDGE_BOTTOMLEFT
113 /** MV modes for P frames */
116 MV_PMODE_1MV_HPEL_BILIN,
120 MV_PMODE_INTENSITY_COMP
124 /** @name MV types for B frames */
129 BMV_TYPE_INTERPOLATED
133 /** @name Block types for P/B frames */
135 enum TransformTypes {
139 TT_8X4, //Both halves
142 TT_4X8, //Both halves
147 /** Table for conversion between TTBLK and TTMB */
148 static const int ttblk_to_tt[3][8] = {
149 { TT_8X4, TT_4X8, TT_8X8, TT_4X4, TT_8X4_TOP, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT },
150 { TT_8X8, TT_4X8_RIGHT, TT_4X8_LEFT, TT_4X4, TT_8X4, TT_4X8, TT_8X4_BOTTOM, TT_8X4_TOP },
151 { TT_8X8, TT_4X8, TT_4X4, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT, TT_8X4, TT_8X4_TOP }
154 static const int ttfrm_to_tt[4] = { TT_8X8, TT_8X4, TT_4X8, TT_4X4 };
156 /** MV P mode - the 5th element is only used for mode 1 */
157 static const uint8_t mv_pmode_table[2][5] = {
158 { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV },
159 { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN }
161 static const uint8_t mv_pmode_table2[2][4] = {
162 { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV },
163 { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN }
166 /** One more frame type */
169 static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
170 fps_dr[2] = { 1000, 1001 };
171 static const uint8_t pquant_table[3][32] = {
172 { /* Implicit quantizer */
173 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 7, 8, 9, 10, 11, 12,
174 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
176 { /* Explicit quantizer, pquantizer uniform */
177 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
178 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
180 { /* Explicit quantizer, pquantizer non-uniform */
181 0, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
182 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
186 /** @name VC-1 VLC tables and defines
187 * @todo TODO move this into the context
190 #define VC1_BFRACTION_VLC_BITS 7
191 static VLC vc1_bfraction_vlc;
192 #define VC1_IMODE_VLC_BITS 4
193 static VLC vc1_imode_vlc;
194 #define VC1_NORM2_VLC_BITS 3
195 static VLC vc1_norm2_vlc;
196 #define VC1_NORM6_VLC_BITS 9
197 static VLC vc1_norm6_vlc;
198 /* Could be optimized, one table only needs 8 bits */
199 #define VC1_TTMB_VLC_BITS 9 //12
200 static VLC vc1_ttmb_vlc[3];
201 #define VC1_MV_DIFF_VLC_BITS 9 //15
202 static VLC vc1_mv_diff_vlc[4];
203 #define VC1_CBPCY_P_VLC_BITS 9 //14
204 static VLC vc1_cbpcy_p_vlc[4];
205 #define VC1_4MV_BLOCK_PATTERN_VLC_BITS 6
206 static VLC vc1_4mv_block_pattern_vlc[4];
207 #define VC1_TTBLK_VLC_BITS 5
208 static VLC vc1_ttblk_vlc[3];
209 #define VC1_SUBBLKPAT_VLC_BITS 6
210 static VLC vc1_subblkpat_vlc[3];
212 static VLC vc1_ac_coeff_table[8];
216 CS_HIGH_MOT_INTRA = 0,
226 /** @name Overlap conditions for Advanced Profile */
237 * @fixme Change size wherever another size is more efficient
238 * Many members are only used for Advanced Profile
240 typedef struct VC1Context{
245 /** Simple/Main Profile sequence header */
247 int res_sm; ///< reserved, 2b
248 int res_x8; ///< reserved
249 int multires; ///< frame-level RESPIC syntax element present
250 int res_fasttx; ///< reserved, always 1
251 int res_transtab; ///< reserved, always 0
252 int rangered; ///< RANGEREDFRM (range reduction) syntax element present
254 int res_rtm_flag; ///< reserved, set to 1
255 int reserved; ///< reserved
258 /** Advanced Profile */
260 int level; ///< 3bits, for Advanced/Simple Profile, provided by TS layer
261 int chromaformat; ///< 2bits, 2=4:2:0, only defined
262 int postprocflag; ///< Per-frame processing suggestion flag present
263 int broadcast; ///< TFF/RFF present
264 int interlace; ///< Progressive/interlaced (RPTFTM syntax element)
265 int tfcntrflag; ///< TFCNTR present
266 int panscanflag; ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
267 int extended_dmv; ///< Additional extended dmv range at P/B frame-level
268 int color_prim; ///< 8bits, chroma coordinates of the color primaries
269 int transfer_char; ///< 8bits, Opto-electronic transfer characteristics
270 int matrix_coef; ///< 8bits, Color primaries->YCbCr transform matrix
271 int hrd_param_flag; ///< Presence of Hypothetical Reference
272 ///< Decoder parameters
273 int psf; ///< Progressive Segmented Frame
276 /** Sequence header data for all Profiles
277 * TODO: choose between ints, uint8_ts and monobit flags
280 int profile; ///< 2bits, Profile
281 int frmrtq_postproc; ///< 3bits,
282 int bitrtq_postproc; ///< 5bits, quantized framerate-based postprocessing strength
283 int fastuvmc; ///< Rounding of qpel vector to hpel ? (not in Simple)
284 int extended_mv; ///< Ext MV in P/B (not in Simple)
285 int dquant; ///< How qscale varies with MBs, 2bits (not in Simple)
286 int vstransform; ///< variable-size [48]x[48] transform type + info
287 int overlap; ///< overlapped transforms in use
288 int quantizer_mode; ///< 2bits, quantizer mode used for sequence, see QUANT_*
289 int finterpflag; ///< INTERPFRM present
292 /** Frame decoding info for all profiles */
294 uint8_t mv_mode; ///< MV coding monde
295 uint8_t mv_mode2; ///< Secondary MV coding mode (B frames)
296 int k_x; ///< Number of bits for MVs (depends on MV range)
297 int k_y; ///< Number of bits for MVs (depends on MV range)
298 int range_x, range_y; ///< MV range
299 uint8_t pq, altpq; ///< Current/alternate frame quantizer scale
300 /** pquant parameters */
307 /** AC coding set indexes
308 * @see 8.1.1.10, p(1)10
311 int c_ac_table_index; ///< Chroma index from ACFRM element
312 int y_ac_table_index; ///< Luma index from AC2FRM element
314 int ttfrm; ///< Transform type info present at frame level
315 uint8_t ttmbf; ///< Transform type flag
316 uint8_t ttblk4x4; ///< Value of ttblk which indicates a 4x4 transform
317 int codingset; ///< index of current table set from 11.8 to use for luma block decoding
318 int codingset2; ///< index of current table set from 11.8 to use for chroma block decoding
319 int pqindex; ///< raw pqindex used in coding set selection
320 int a_avail, c_avail;
321 uint8_t *mb_type_base, *mb_type[3];
324 /** Luma compensation parameters */
329 int16_t bfraction; ///< Relative position % anchors=> how to scale MVs
330 uint8_t halfpq; ///< Uniform quant over image and qp+.5
331 uint8_t respic; ///< Frame-level flag for resized images
332 int buffer_fullness; ///< HRD info
334 * -# 0 -> [-64n 63.f] x [-32, 31.f]
335 * -# 1 -> [-128, 127.f] x [-64, 63.f]
336 * -# 2 -> [-512, 511.f] x [-128, 127.f]
337 * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
340 uint8_t pquantizer; ///< Uniform (over sequence) quantizer in use
341 VLC *cbpcy_vlc; ///< CBPCY VLC table
342 int tt_index; ///< Index for Transform Type tables
343 uint8_t* mv_type_mb_plane; ///< bitplane for mv_type == (4MV)
344 uint8_t* direct_mb_plane; ///< bitplane for "direct" MBs
345 int mv_type_is_raw; ///< mv type mb plane is not coded
346 int dmb_is_raw; ///< direct mb plane is raw
347 int skip_is_raw; ///< skip mb plane is not coded
348 uint8_t luty[256], lutuv[256]; // lookup tables used for intensity compensation
349 int use_ic; ///< use intensity compensation in B-frames
350 int rnd; ///< rounding control
352 /** Frame decoding info for S/M profiles only */
354 uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
358 /** Frame decoding info for Advanced profile */
360 uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
361 uint8_t numpanscanwin;
363 uint8_t rptfrm, tff, rff;
366 uint16_t bottomrightx;
367 uint16_t bottomrighty;
370 int hrd_num_leaky_buckets;
371 uint8_t bit_rate_exponent;
372 uint8_t buffer_size_exponent;
373 uint8_t* acpred_plane; ///< AC prediction flags bitplane
375 uint8_t* over_flags_plane; ///< Overflags bitplane
378 uint16_t *hrd_rate, *hrd_buffer;
379 uint8_t *hrd_fullness;
380 uint8_t range_mapy_flag;
381 uint8_t range_mapuv_flag;
391 * Get unary code of limited length
392 * @fixme FIXME Slow and ugly
393 * @param gb GetBitContext
394 * @param[in] stop The bitstop value (unary code of 1's or 0's)
395 * @param[in] len Maximum length
396 * @return Unary length/index
398 static int get_prefix(GetBitContext *gb, int stop, int len)
403 for(i = 0; i < len && get_bits1(gb) != stop; i++);
405 /* int i = 0, tmp = !stop;
407 while (i != len && tmp != stop)
409 tmp = get_bits(gb, 1);
412 if (i == len && tmp != stop) return len+1;
419 UPDATE_CACHE(re, gb);
420 buf=GET_CACHE(re, gb); //Still not sure
421 if (stop) buf = ~buf;
423 log= av_log2(-buf); //FIXME: -?
425 LAST_SKIP_BITS(re, gb, log+1);
426 CLOSE_READER(re, gb);
430 LAST_SKIP_BITS(re, gb, limit);
431 CLOSE_READER(re, gb);
436 static inline int decode210(GetBitContext *gb){
442 return 2 - get_bits1(gb);
446 * Init VC-1 specific tables and VC1Context members
447 * @param v The VC1Context to initialize
450 static int vc1_init_common(VC1Context *v)
455 v->hrd_rate = v->hrd_buffer = NULL;
461 init_vlc(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
462 vc1_bfraction_bits, 1, 1,
463 vc1_bfraction_codes, 1, 1, 1);
464 init_vlc(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
465 vc1_norm2_bits, 1, 1,
466 vc1_norm2_codes, 1, 1, 1);
467 init_vlc(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
468 vc1_norm6_bits, 1, 1,
469 vc1_norm6_codes, 2, 2, 1);
470 init_vlc(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
471 vc1_imode_bits, 1, 1,
472 vc1_imode_codes, 1, 1, 1);
475 init_vlc(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
476 vc1_ttmb_bits[i], 1, 1,
477 vc1_ttmb_codes[i], 2, 2, 1);
478 init_vlc(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
479 vc1_ttblk_bits[i], 1, 1,
480 vc1_ttblk_codes[i], 1, 1, 1);
481 init_vlc(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
482 vc1_subblkpat_bits[i], 1, 1,
483 vc1_subblkpat_codes[i], 1, 1, 1);
487 init_vlc(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
488 vc1_4mv_block_pattern_bits[i], 1, 1,
489 vc1_4mv_block_pattern_codes[i], 1, 1, 1);
490 init_vlc(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
491 vc1_cbpcy_p_bits[i], 1, 1,
492 vc1_cbpcy_p_codes[i], 2, 2, 1);
493 init_vlc(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
494 vc1_mv_diff_bits[i], 1, 1,
495 vc1_mv_diff_codes[i], 2, 2, 1);
498 init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
499 &vc1_ac_tables[i][0][1], 8, 4,
500 &vc1_ac_tables[i][0][0], 8, 4, 1);
501 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
502 &ff_msmp4_mb_i_table[0][1], 4, 2,
503 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
508 v->mvrange = 0; /* 7.1.1.18, p80 */
513 /***********************************************************************/
515 * @defgroup bitplane VC9 Bitplane decoding
520 /** @addtogroup bitplane
533 /** @} */ //imode defines
535 /** Decode rows by checking if they are skipped
536 * @param plane Buffer to store decoded bits
537 * @param[in] width Width of this buffer
538 * @param[in] height Height of this buffer
539 * @param[in] stride of this buffer
541 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
544 for (y=0; y<height; y++){
545 if (!get_bits(gb, 1)) //rowskip
546 memset(plane, 0, width);
548 for (x=0; x<width; x++)
549 plane[x] = get_bits(gb, 1);
554 /** Decode columns by checking if they are skipped
555 * @param plane Buffer to store decoded bits
556 * @param[in] width Width of this buffer
557 * @param[in] height Height of this buffer
558 * @param[in] stride of this buffer
559 * @fixme FIXME: Optimize
561 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
564 for (x=0; x<width; x++){
565 if (!get_bits(gb, 1)) //colskip
566 for (y=0; y<height; y++)
569 for (y=0; y<height; y++)
570 plane[y*stride] = get_bits(gb, 1);
575 /** Decode a bitplane's bits
576 * @param bp Bitplane where to store the decode bits
577 * @param v VC-1 context for bit reading and logging
579 * @fixme FIXME: Optimize
581 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
583 GetBitContext *gb = &v->s.gb;
585 int imode, x, y, code, offset;
586 uint8_t invert, *planep = data;
587 int width, height, stride;
589 width = v->s.mb_width;
590 height = v->s.mb_height;
591 stride = v->s.mb_stride;
592 invert = get_bits(gb, 1);
593 imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
599 //Data is actually read in the MB layer (same for all tests == "raw")
600 *raw_flag = 1; //invert ignored
604 if ((height * width) & 1)
606 *planep++ = get_bits(gb, 1);
610 // decode bitplane as one long line
611 for (y = offset; y < height * width; y += 2) {
612 code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
613 *planep++ = code & 1;
615 if(offset == width) {
617 planep += stride - width;
619 *planep++ = code >> 1;
621 if(offset == width) {
623 planep += stride - width;
629 if(!(height % 3) && (width % 3)) { // use 2x3 decoding
630 for(y = 0; y < height; y+= 3) {
631 for(x = width & 1; x < width; x += 2) {
632 code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
634 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
637 planep[x + 0] = (code >> 0) & 1;
638 planep[x + 1] = (code >> 1) & 1;
639 planep[x + 0 + stride] = (code >> 2) & 1;
640 planep[x + 1 + stride] = (code >> 3) & 1;
641 planep[x + 0 + stride * 2] = (code >> 4) & 1;
642 planep[x + 1 + stride * 2] = (code >> 5) & 1;
644 planep += stride * 3;
646 if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
648 planep += (height & 1) * stride;
649 for(y = height & 1; y < height; y += 2) {
650 for(x = width % 3; x < width; x += 3) {
651 code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
653 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
656 planep[x + 0] = (code >> 0) & 1;
657 planep[x + 1] = (code >> 1) & 1;
658 planep[x + 2] = (code >> 2) & 1;
659 planep[x + 0 + stride] = (code >> 3) & 1;
660 planep[x + 1 + stride] = (code >> 4) & 1;
661 planep[x + 2 + stride] = (code >> 5) & 1;
663 planep += stride * 2;
666 if(x) decode_colskip(data , x, height , stride, &v->s.gb);
667 if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
671 decode_rowskip(data, width, height, stride, &v->s.gb);
674 decode_colskip(data, width, height, stride, &v->s.gb);
679 /* Applying diff operator */
680 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
684 for (x=1; x<width; x++)
685 planep[x] ^= planep[x-1];
686 for (y=1; y<height; y++)
689 planep[0] ^= planep[-stride];
690 for (x=1; x<width; x++)
692 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
693 else planep[x] ^= planep[x-1];
700 for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
702 return (imode<<1) + invert;
705 /** @} */ //Bitplane group
707 /***********************************************************************/
708 /** VOP Dquant decoding
709 * @param v VC-1 Context
711 static int vop_dquant_decoding(VC1Context *v)
713 GetBitContext *gb = &v->s.gb;
719 pqdiff = get_bits(gb, 3);
720 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
721 else v->altpq = v->pq + pqdiff + 1;
725 v->dquantfrm = get_bits(gb, 1);
728 v->dqprofile = get_bits(gb, 2);
729 switch (v->dqprofile)
731 case DQPROFILE_SINGLE_EDGE:
732 case DQPROFILE_DOUBLE_EDGES:
733 v->dqsbedge = get_bits(gb, 2);
735 case DQPROFILE_ALL_MBS:
736 v->dqbilevel = get_bits(gb, 1);
737 default: break; //Forbidden ?
739 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
741 pqdiff = get_bits(gb, 3);
742 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
743 else v->altpq = v->pq + pqdiff + 1;
750 /** Put block onto picture
752 static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
756 DSPContext *dsp = &v->s.dsp;
760 for(k = 0; k < 6; k++)
761 for(j = 0; j < 8; j++)
762 for(i = 0; i < 8; i++)
763 block[k][i + j*8] = ((block[k][i + j*8] - 128) << 1) + 128;
766 ys = v->s.current_picture.linesize[0];
767 us = v->s.current_picture.linesize[1];
768 vs = v->s.current_picture.linesize[2];
771 dsp->put_pixels_clamped(block[0], Y, ys);
772 dsp->put_pixels_clamped(block[1], Y + 8, ys);
774 dsp->put_pixels_clamped(block[2], Y, ys);
775 dsp->put_pixels_clamped(block[3], Y + 8, ys);
777 if(!(v->s.flags & CODEC_FLAG_GRAY)) {
778 dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
779 dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
783 /** Do motion compensation over 1 macroblock
784 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
786 static void vc1_mc_1mv(VC1Context *v, int dir)
788 MpegEncContext *s = &v->s;
789 DSPContext *dsp = &v->s.dsp;
790 uint8_t *srcY, *srcU, *srcV;
791 int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
793 if(!v->s.last_picture.data[0])return;
795 mx = s->mv[dir][0][0];
796 my = s->mv[dir][0][1];
798 // store motion vectors for further use in B frames
799 if(s->pict_type == P_TYPE) {
800 s->current_picture.motion_val[1][s->block_index[0]][0] = mx;
801 s->current_picture.motion_val[1][s->block_index[0]][1] = my;
803 uvmx = (mx + ((mx & 3) == 3)) >> 1;
804 uvmy = (my + ((my & 3) == 3)) >> 1;
806 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
807 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
810 srcY = s->last_picture.data[0];
811 srcU = s->last_picture.data[1];
812 srcV = s->last_picture.data[2];
814 srcY = s->next_picture.data[0];
815 srcU = s->next_picture.data[1];
816 srcV = s->next_picture.data[2];
819 src_x = s->mb_x * 16 + (mx >> 2);
820 src_y = s->mb_y * 16 + (my >> 2);
821 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
822 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
824 if(v->profile != PROFILE_ADVANCED){
825 src_x = av_clip( src_x, -16, s->mb_width * 16);
826 src_y = av_clip( src_y, -16, s->mb_height * 16);
827 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
828 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
830 src_x = av_clip( src_x, -17, s->avctx->coded_width);
831 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
832 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
833 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
836 srcY += src_y * s->linesize + src_x;
837 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
838 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
840 /* for grayscale we should not try to read from unknown area */
841 if(s->flags & CODEC_FLAG_GRAY) {
842 srcU = s->edge_emu_buffer + 18 * s->linesize;
843 srcV = s->edge_emu_buffer + 18 * s->linesize;
846 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
847 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
848 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
849 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
851 srcY -= s->mspel * (1 + s->linesize);
852 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
853 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
854 srcY = s->edge_emu_buffer;
855 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
856 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
857 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
858 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
861 /* if we deal with range reduction we need to scale source blocks */
867 for(j = 0; j < 17 + s->mspel*2; j++) {
868 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
871 src = srcU; src2 = srcV;
872 for(j = 0; j < 9; j++) {
873 for(i = 0; i < 9; i++) {
874 src[i] = ((src[i] - 128) >> 1) + 128;
875 src2[i] = ((src2[i] - 128) >> 1) + 128;
877 src += s->uvlinesize;
878 src2 += s->uvlinesize;
881 /* if we deal with intensity compensation we need to scale source blocks */
882 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
887 for(j = 0; j < 17 + s->mspel*2; j++) {
888 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
891 src = srcU; src2 = srcV;
892 for(j = 0; j < 9; j++) {
893 for(i = 0; i < 9; i++) {
894 src[i] = v->lutuv[src[i]];
895 src2[i] = v->lutuv[src2[i]];
897 src += s->uvlinesize;
898 src2 += s->uvlinesize;
901 srcY += s->mspel * (1 + s->linesize);
905 dxy = ((my & 3) << 2) | (mx & 3);
906 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
907 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
908 srcY += s->linesize * 8;
909 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
910 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
911 } else { // hpel mc - always used for luma
912 dxy = (my & 2) | ((mx & 2) >> 1);
915 dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
917 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
920 if(s->flags & CODEC_FLAG_GRAY) return;
921 /* Chroma MC always uses qpel bilinear */
922 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
926 dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
927 dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
929 dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
930 dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
934 /** Do motion compensation for 4-MV macroblock - luminance block
936 static void vc1_mc_4mv_luma(VC1Context *v, int n)
938 MpegEncContext *s = &v->s;
939 DSPContext *dsp = &v->s.dsp;
941 int dxy, mx, my, src_x, src_y;
944 if(!v->s.last_picture.data[0])return;
947 srcY = s->last_picture.data[0];
949 off = s->linesize * 4 * (n&2) + (n&1) * 8;
951 src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
952 src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
954 if(v->profile != PROFILE_ADVANCED){
955 src_x = av_clip( src_x, -16, s->mb_width * 16);
956 src_y = av_clip( src_y, -16, s->mb_height * 16);
958 src_x = av_clip( src_x, -17, s->avctx->coded_width);
959 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
962 srcY += src_y * s->linesize + src_x;
964 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
965 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
966 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
967 srcY -= s->mspel * (1 + s->linesize);
968 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
969 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
970 srcY = s->edge_emu_buffer;
971 /* if we deal with range reduction we need to scale source blocks */
977 for(j = 0; j < 9 + s->mspel*2; j++) {
978 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
982 /* if we deal with intensity compensation we need to scale source blocks */
983 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
988 for(j = 0; j < 9 + s->mspel*2; j++) {
989 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
993 srcY += s->mspel * (1 + s->linesize);
997 dxy = ((my & 3) << 2) | (mx & 3);
998 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
999 } else { // hpel mc - always used for luma
1000 dxy = (my & 2) | ((mx & 2) >> 1);
1002 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1004 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1008 static inline int median4(int a, int b, int c, int d)
1011 if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
1012 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
1014 if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
1015 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
1020 /** Do motion compensation for 4-MV macroblock - both chroma blocks
1022 static void vc1_mc_4mv_chroma(VC1Context *v)
1024 MpegEncContext *s = &v->s;
1025 DSPContext *dsp = &v->s.dsp;
1026 uint8_t *srcU, *srcV;
1027 int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1028 int i, idx, tx = 0, ty = 0;
1029 int mvx[4], mvy[4], intra[4];
1030 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1032 if(!v->s.last_picture.data[0])return;
1033 if(s->flags & CODEC_FLAG_GRAY) return;
1035 for(i = 0; i < 4; i++) {
1036 mvx[i] = s->mv[0][i][0];
1037 mvy[i] = s->mv[0][i][1];
1038 intra[i] = v->mb_type[0][s->block_index[i]];
1041 /* calculate chroma MV vector from four luma MVs */
1042 idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1043 if(!idx) { // all blocks are inter
1044 tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1045 ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1046 } else if(count[idx] == 1) { // 3 inter blocks
1049 tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1050 ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1053 tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1054 ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1057 tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1058 ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1061 tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1062 ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1065 } else if(count[idx] == 2) {
1067 for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1068 for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1069 tx = (mvx[t1] + mvx[t2]) / 2;
1070 ty = (mvy[t1] + mvy[t2]) / 2;
1072 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
1073 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
1074 return; //no need to do MC for inter blocks
1077 s->current_picture.motion_val[1][s->block_index[0]][0] = tx;
1078 s->current_picture.motion_val[1][s->block_index[0]][1] = ty;
1079 uvmx = (tx + ((tx&3) == 3)) >> 1;
1080 uvmy = (ty + ((ty&3) == 3)) >> 1;
1082 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1083 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1086 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1087 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1089 if(v->profile != PROFILE_ADVANCED){
1090 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
1091 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
1093 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
1094 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
1097 srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1098 srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1099 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1100 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
1101 || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
1102 ff_emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize, 8+1, 8+1,
1103 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1104 ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1105 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1106 srcU = s->edge_emu_buffer;
1107 srcV = s->edge_emu_buffer + 16;
1109 /* if we deal with range reduction we need to scale source blocks */
1110 if(v->rangeredfrm) {
1112 uint8_t *src, *src2;
1114 src = srcU; src2 = srcV;
1115 for(j = 0; j < 9; j++) {
1116 for(i = 0; i < 9; i++) {
1117 src[i] = ((src[i] - 128) >> 1) + 128;
1118 src2[i] = ((src2[i] - 128) >> 1) + 128;
1120 src += s->uvlinesize;
1121 src2 += s->uvlinesize;
1124 /* if we deal with intensity compensation we need to scale source blocks */
1125 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1127 uint8_t *src, *src2;
1129 src = srcU; src2 = srcV;
1130 for(j = 0; j < 9; j++) {
1131 for(i = 0; i < 9; i++) {
1132 src[i] = v->lutuv[src[i]];
1133 src2[i] = v->lutuv[src2[i]];
1135 src += s->uvlinesize;
1136 src2 += s->uvlinesize;
1141 /* Chroma MC always uses qpel bilinear */
1142 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
1146 dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1147 dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1149 dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1150 dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1154 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
1157 * Decode Simple/Main Profiles sequence header
1158 * @see Figure 7-8, p16-17
1159 * @param avctx Codec context
1160 * @param gb GetBit context initialized from Codec context extra_data
1163 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1165 VC1Context *v = avctx->priv_data;
1167 av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
1168 v->profile = get_bits(gb, 2);
1169 if (v->profile == PROFILE_COMPLEX)
1171 av_log(avctx, AV_LOG_ERROR, "WMV3 Complex Profile is not fully supported\n");
1174 if (v->profile == PROFILE_ADVANCED)
1176 return decode_sequence_header_adv(v, gb);
1180 v->res_sm = get_bits(gb, 2); //reserved
1183 av_log(avctx, AV_LOG_ERROR,
1184 "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1190 v->frmrtq_postproc = get_bits(gb, 3); //common
1191 // (bitrate-32kbps)/64kbps
1192 v->bitrtq_postproc = get_bits(gb, 5); //common
1193 v->s.loop_filter = get_bits(gb, 1); //common
1194 if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1196 av_log(avctx, AV_LOG_ERROR,
1197 "LOOPFILTER shell not be enabled in simple profile\n");
1200 v->res_x8 = get_bits(gb, 1); //reserved
1203 av_log(avctx, AV_LOG_ERROR,
1204 "1 for reserved RES_X8 is forbidden\n");
1207 v->multires = get_bits(gb, 1);
1208 v->res_fasttx = get_bits(gb, 1);
1211 av_log(avctx, AV_LOG_ERROR,
1212 "0 for reserved RES_FASTTX is forbidden\n");
1216 v->fastuvmc = get_bits(gb, 1); //common
1217 if (!v->profile && !v->fastuvmc)
1219 av_log(avctx, AV_LOG_ERROR,
1220 "FASTUVMC unavailable in Simple Profile\n");
1223 v->extended_mv = get_bits(gb, 1); //common
1224 if (!v->profile && v->extended_mv)
1226 av_log(avctx, AV_LOG_ERROR,
1227 "Extended MVs unavailable in Simple Profile\n");
1230 v->dquant = get_bits(gb, 2); //common
1231 v->vstransform = get_bits(gb, 1); //common
1233 v->res_transtab = get_bits(gb, 1);
1234 if (v->res_transtab)
1236 av_log(avctx, AV_LOG_ERROR,
1237 "1 for reserved RES_TRANSTAB is forbidden\n");
1241 v->overlap = get_bits(gb, 1); //common
1243 v->s.resync_marker = get_bits(gb, 1);
1244 v->rangered = get_bits(gb, 1);
1245 if (v->rangered && v->profile == PROFILE_SIMPLE)
1247 av_log(avctx, AV_LOG_INFO,
1248 "RANGERED should be set to 0 in simple profile\n");
1251 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1252 v->quantizer_mode = get_bits(gb, 2); //common
1254 v->finterpflag = get_bits(gb, 1); //common
1255 v->res_rtm_flag = get_bits(gb, 1); //reserved
1256 if (!v->res_rtm_flag)
1258 // av_log(avctx, AV_LOG_ERROR,
1259 // "0 for reserved RES_RTM_FLAG is forbidden\n");
1260 av_log(avctx, AV_LOG_ERROR,
1261 "Old WMV3 version detected, only I-frames will be decoded\n");
1264 //TODO: figure out what they mean (always 0x402F)
1265 if(!v->res_fasttx) skip_bits(gb, 16);
1266 av_log(avctx, AV_LOG_DEBUG,
1267 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1268 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1269 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1270 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1271 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1272 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1273 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1274 v->dquant, v->quantizer_mode, avctx->max_b_frames
1279 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
1281 v->res_rtm_flag = 1;
1282 v->level = get_bits(gb, 3);
1285 av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1287 v->chromaformat = get_bits(gb, 2);
1288 if (v->chromaformat != 1)
1290 av_log(v->s.avctx, AV_LOG_ERROR,
1291 "Only 4:2:0 chroma format supported\n");
1296 v->frmrtq_postproc = get_bits(gb, 3); //common
1297 // (bitrate-32kbps)/64kbps
1298 v->bitrtq_postproc = get_bits(gb, 5); //common
1299 v->postprocflag = get_bits(gb, 1); //common
1301 v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
1302 v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
1303 v->s.avctx->width = v->s.avctx->coded_width;
1304 v->s.avctx->height = v->s.avctx->coded_height;
1305 v->broadcast = get_bits1(gb);
1306 v->interlace = get_bits1(gb);
1307 v->tfcntrflag = get_bits1(gb);
1308 v->finterpflag = get_bits1(gb);
1309 get_bits1(gb); // reserved
1311 v->s.h_edge_pos = v->s.avctx->coded_width;
1312 v->s.v_edge_pos = v->s.avctx->coded_height;
1314 av_log(v->s.avctx, AV_LOG_DEBUG,
1315 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1316 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
1317 "TFCTRflag=%i, FINTERPflag=%i\n",
1318 v->level, v->frmrtq_postproc, v->bitrtq_postproc,
1319 v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
1320 v->tfcntrflag, v->finterpflag
1323 v->psf = get_bits1(gb);
1324 if(v->psf) { //PsF, 6.1.13
1325 av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
1328 v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
1329 if(get_bits1(gb)) { //Display Info - decoding is not affected by it
1331 av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
1332 v->s.avctx->width = v->s.width = w = get_bits(gb, 14) + 1;
1333 v->s.avctx->height = v->s.height = h = get_bits(gb, 14) + 1;
1334 av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
1336 ar = get_bits(gb, 4);
1338 v->s.avctx->sample_aspect_ratio = vc1_pixel_aspect[ar];
1340 w = get_bits(gb, 8);
1341 h = get_bits(gb, 8);
1342 v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
1345 if(get_bits1(gb)){ //framerate stuff
1347 v->s.avctx->time_base.num = 32;
1348 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;
1351 nr = get_bits(gb, 8);
1352 dr = get_bits(gb, 4);
1353 if(nr && nr < 8 && dr && dr < 3){
1354 v->s.avctx->time_base.num = fps_dr[dr - 1];
1355 v->s.avctx->time_base.den = fps_nr[nr - 1] * 1000;
1361 v->color_prim = get_bits(gb, 8);
1362 v->transfer_char = get_bits(gb, 8);
1363 v->matrix_coef = get_bits(gb, 8);
1367 v->hrd_param_flag = get_bits1(gb);
1368 if(v->hrd_param_flag) {
1370 v->hrd_num_leaky_buckets = get_bits(gb, 5);
1371 get_bits(gb, 4); //bitrate exponent
1372 get_bits(gb, 4); //buffer size exponent
1373 for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1374 get_bits(gb, 16); //hrd_rate[n]
1375 get_bits(gb, 16); //hrd_buffer[n]
1381 static int decode_entry_point(AVCodecContext *avctx, GetBitContext *gb)
1383 VC1Context *v = avctx->priv_data;
1384 int i, blink, clentry, refdist;
1386 av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
1387 blink = get_bits1(gb); // broken link
1388 clentry = get_bits1(gb); // closed entry
1389 v->panscanflag = get_bits1(gb);
1390 refdist = get_bits1(gb); // refdist flag
1391 v->s.loop_filter = get_bits1(gb);
1392 v->fastuvmc = get_bits1(gb);
1393 v->extended_mv = get_bits1(gb);
1394 v->dquant = get_bits(gb, 2);
1395 v->vstransform = get_bits1(gb);
1396 v->overlap = get_bits1(gb);
1397 v->quantizer_mode = get_bits(gb, 2);
1399 if(v->hrd_param_flag){
1400 for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1401 get_bits(gb, 8); //hrd_full[n]
1406 avctx->coded_width = (get_bits(gb, 12)+1)<<1;
1407 avctx->coded_height = (get_bits(gb, 12)+1)<<1;
1410 v->extended_dmv = get_bits1(gb);
1412 av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
1413 skip_bits(gb, 3); // Y range, ignored for now
1416 av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
1417 skip_bits(gb, 3); // UV range, ignored for now
1420 av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
1421 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1422 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1423 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1424 blink, clentry, v->panscanflag, refdist, v->s.loop_filter,
1425 v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
1430 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1432 int pqindex, lowquant, status;
1434 if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1435 skip_bits(gb, 2); //framecnt unused
1437 if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1438 v->s.pict_type = get_bits(gb, 1);
1439 if (v->s.avctx->max_b_frames) {
1440 if (!v->s.pict_type) {
1441 if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1442 else v->s.pict_type = B_TYPE;
1443 } else v->s.pict_type = P_TYPE;
1444 } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1447 if(v->s.pict_type == B_TYPE) {
1448 v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1449 v->bfraction = vc1_bfraction_lut[v->bfraction];
1450 if(v->bfraction == 0) {
1451 v->s.pict_type = BI_TYPE;
1454 if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1455 get_bits(gb, 7); // skip buffer fullness
1458 if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1460 if(v->s.pict_type == P_TYPE)
1463 /* Quantizer stuff */
1464 pqindex = get_bits(gb, 5);
1465 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1466 v->pq = pquant_table[0][pqindex];
1468 v->pq = pquant_table[1][pqindex];
1471 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1472 v->pquantizer = pqindex < 9;
1473 if (v->quantizer_mode == QUANT_NON_UNIFORM)
1475 v->pqindex = pqindex;
1476 if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1478 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1479 v->pquantizer = get_bits(gb, 1);
1481 if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1482 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1483 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1484 v->range_x = 1 << (v->k_x - 1);
1485 v->range_y = 1 << (v->k_y - 1);
1486 if (v->profile == PROFILE_ADVANCED)
1488 if (v->postprocflag) v->postproc = get_bits(gb, 1);
1491 if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1493 if(v->res_x8 && (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)){
1494 if(get_bits1(gb))return -1;
1496 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1497 // (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1499 if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
1501 switch(v->s.pict_type) {
1503 if (v->pq < 5) v->tt_index = 0;
1504 else if(v->pq < 13) v->tt_index = 1;
1505 else v->tt_index = 2;
1507 lowquant = (v->pq > 12) ? 0 : 1;
1508 v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1509 if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1511 int scale, shift, i;
1512 v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1513 v->lumscale = get_bits(gb, 6);
1514 v->lumshift = get_bits(gb, 6);
1516 /* fill lookup tables for intensity compensation */
1519 shift = (255 - v->lumshift * 2) << 6;
1520 if(v->lumshift > 31)
1523 scale = v->lumscale + 32;
1524 if(v->lumshift > 31)
1525 shift = (v->lumshift - 64) << 6;
1527 shift = v->lumshift << 6;
1529 for(i = 0; i < 256; i++) {
1530 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
1531 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1534 if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1535 v->s.quarter_sample = 0;
1536 else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1537 if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1538 v->s.quarter_sample = 0;
1540 v->s.quarter_sample = 1;
1542 v->s.quarter_sample = 1;
1543 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1545 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1546 v->mv_mode2 == MV_PMODE_MIXED_MV)
1547 || v->mv_mode == MV_PMODE_MIXED_MV)
1549 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1550 if (status < 0) return -1;
1551 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1552 "Imode: %i, Invert: %i\n", status>>1, status&1);
1554 v->mv_type_is_raw = 0;
1555 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1557 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1558 if (status < 0) return -1;
1559 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1560 "Imode: %i, Invert: %i\n", status>>1, status&1);
1562 /* Hopefully this is correct for P frames */
1563 v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1564 v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1568 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1569 vop_dquant_decoding(v);
1572 v->ttfrm = 0; //FIXME Is that so ?
1575 v->ttmbf = get_bits(gb, 1);
1578 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1586 if (v->pq < 5) v->tt_index = 0;
1587 else if(v->pq < 13) v->tt_index = 1;
1588 else v->tt_index = 2;
1590 lowquant = (v->pq > 12) ? 0 : 1;
1591 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1592 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1593 v->s.mspel = v->s.quarter_sample;
1595 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1596 if (status < 0) return -1;
1597 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1598 "Imode: %i, Invert: %i\n", status>>1, status&1);
1599 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1600 if (status < 0) return -1;
1601 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1602 "Imode: %i, Invert: %i\n", status>>1, status&1);
1604 v->s.mv_table_index = get_bits(gb, 2);
1605 v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1609 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1610 vop_dquant_decoding(v);
1616 v->ttmbf = get_bits(gb, 1);
1619 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1629 v->c_ac_table_index = decode012(gb);
1630 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1632 v->y_ac_table_index = decode012(gb);
1635 v->s.dc_table_index = get_bits(gb, 1);
1637 if(v->s.pict_type == BI_TYPE) {
1638 v->s.pict_type = B_TYPE;
1644 static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
1646 int pqindex, lowquant;
1649 v->p_frame_skipped = 0;
1652 v->fcm = decode012(gb);
1653 if(v->fcm) return -1; // interlaced frames/fields are not implemented
1655 switch(get_prefix(gb, 0, 4)) {
1657 v->s.pict_type = P_TYPE;
1660 v->s.pict_type = B_TYPE;
1663 v->s.pict_type = I_TYPE;
1666 v->s.pict_type = BI_TYPE;
1669 v->s.pict_type = P_TYPE; // skipped pic
1670 v->p_frame_skipped = 1;
1676 if(!v->interlace || v->psf) {
1677 v->rptfrm = get_bits(gb, 2);
1679 v->tff = get_bits1(gb);
1680 v->rptfrm = get_bits1(gb);
1683 if(v->panscanflag) {
1686 v->rnd = get_bits1(gb);
1688 v->uvsamp = get_bits1(gb);
1689 if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1690 if(v->s.pict_type == B_TYPE) {
1691 v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1692 v->bfraction = vc1_bfraction_lut[v->bfraction];
1693 if(v->bfraction == 0) {
1694 v->s.pict_type = BI_TYPE; /* XXX: should not happen here */
1697 pqindex = get_bits(gb, 5);
1698 v->pqindex = pqindex;
1699 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1700 v->pq = pquant_table[0][pqindex];
1702 v->pq = pquant_table[1][pqindex];
1705 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1706 v->pquantizer = pqindex < 9;
1707 if (v->quantizer_mode == QUANT_NON_UNIFORM)
1709 v->pqindex = pqindex;
1710 if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1712 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1713 v->pquantizer = get_bits(gb, 1);
1715 if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
1717 switch(v->s.pict_type) {
1720 status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1721 if (status < 0) return -1;
1722 av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1723 "Imode: %i, Invert: %i\n", status>>1, status&1);
1724 v->condover = CONDOVER_NONE;
1725 if(v->overlap && v->pq <= 8) {
1726 v->condover = decode012(gb);
1727 if(v->condover == CONDOVER_SELECT) {
1728 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1729 if (status < 0) return -1;
1730 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1731 "Imode: %i, Invert: %i\n", status>>1, status&1);
1737 v->postproc = get_bits1(gb);
1738 if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1739 else v->mvrange = 0;
1740 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1741 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1742 v->range_x = 1 << (v->k_x - 1);
1743 v->range_y = 1 << (v->k_y - 1);
1745 if (v->pq < 5) v->tt_index = 0;
1746 else if(v->pq < 13) v->tt_index = 1;
1747 else v->tt_index = 2;
1749 lowquant = (v->pq > 12) ? 0 : 1;
1750 v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1751 if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1753 int scale, shift, i;
1754 v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1755 v->lumscale = get_bits(gb, 6);
1756 v->lumshift = get_bits(gb, 6);
1757 /* fill lookup tables for intensity compensation */
1760 shift = (255 - v->lumshift * 2) << 6;
1761 if(v->lumshift > 31)
1764 scale = v->lumscale + 32;
1765 if(v->lumshift > 31)
1766 shift = (v->lumshift - 64) << 6;
1768 shift = v->lumshift << 6;
1770 for(i = 0; i < 256; i++) {
1771 v->luty[i] = av_clip_uint8((scale * i + shift + 32) >> 6);
1772 v->lutuv[i] = av_clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1776 if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1777 v->s.quarter_sample = 0;
1778 else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1779 if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1780 v->s.quarter_sample = 0;
1782 v->s.quarter_sample = 1;
1784 v->s.quarter_sample = 1;
1785 v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1787 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1788 v->mv_mode2 == MV_PMODE_MIXED_MV)
1789 || v->mv_mode == MV_PMODE_MIXED_MV)
1791 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1792 if (status < 0) return -1;
1793 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1794 "Imode: %i, Invert: %i\n", status>>1, status&1);
1796 v->mv_type_is_raw = 0;
1797 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1799 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1800 if (status < 0) return -1;
1801 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1802 "Imode: %i, Invert: %i\n", status>>1, status&1);
1804 /* Hopefully this is correct for P frames */
1805 v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1806 v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1809 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1810 vop_dquant_decoding(v);
1813 v->ttfrm = 0; //FIXME Is that so ?
1816 v->ttmbf = get_bits(gb, 1);
1819 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1828 v->postproc = get_bits1(gb);
1829 if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1830 else v->mvrange = 0;
1831 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1832 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1833 v->range_x = 1 << (v->k_x - 1);
1834 v->range_y = 1 << (v->k_y - 1);
1836 if (v->pq < 5) v->tt_index = 0;
1837 else if(v->pq < 13) v->tt_index = 1;
1838 else v->tt_index = 2;
1840 lowquant = (v->pq > 12) ? 0 : 1;
1841 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1842 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1843 v->s.mspel = v->s.quarter_sample;
1845 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1846 if (status < 0) return -1;
1847 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1848 "Imode: %i, Invert: %i\n", status>>1, status&1);
1849 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1850 if (status < 0) return -1;
1851 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1852 "Imode: %i, Invert: %i\n", status>>1, status&1);
1854 v->s.mv_table_index = get_bits(gb, 2);
1855 v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1859 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1860 vop_dquant_decoding(v);
1866 v->ttmbf = get_bits(gb, 1);
1869 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1879 v->c_ac_table_index = decode012(gb);
1880 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1882 v->y_ac_table_index = decode012(gb);
1885 v->s.dc_table_index = get_bits(gb, 1);
1886 if ((v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE) && v->dquant) {
1887 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1888 vop_dquant_decoding(v);
1892 if(v->s.pict_type == BI_TYPE) {
1893 v->s.pict_type = B_TYPE;
1899 /***********************************************************************/
1901 * @defgroup block VC-1 Block-level functions
1902 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1908 * @brief Get macroblock-level quantizer scale
1910 #define GET_MQUANT() \
1914 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1918 mquant = (get_bits(gb, 1)) ? v->altpq : v->pq; \
1922 mqdiff = get_bits(gb, 3); \
1923 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1924 else mquant = get_bits(gb, 5); \
1927 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1928 edges = 1 << v->dqsbedge; \
1929 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1930 edges = (3 << v->dqsbedge) % 15; \
1931 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
1933 if((edges&1) && !s->mb_x) \
1934 mquant = v->altpq; \
1935 if((edges&2) && s->first_slice_line) \
1936 mquant = v->altpq; \
1937 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
1938 mquant = v->altpq; \
1939 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
1940 mquant = v->altpq; \
1944 * @def GET_MVDATA(_dmv_x, _dmv_y)
1945 * @brief Get MV differentials
1946 * @see MVDATA decoding from 8.3.5.2, p(1)20
1947 * @param _dmv_x Horizontal differential for decoded MV
1948 * @param _dmv_y Vertical differential for decoded MV
1950 #define GET_MVDATA(_dmv_x, _dmv_y) \
1951 index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1952 VC1_MV_DIFF_VLC_BITS, 2); \
1955 mb_has_coeffs = 1; \
1958 else mb_has_coeffs = 0; \
1960 if (!index) { _dmv_x = _dmv_y = 0; } \
1961 else if (index == 35) \
1963 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1964 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1966 else if (index == 36) \
1975 if (!s->quarter_sample && index1 == 5) val = 1; \
1977 if(size_table[index1] - val > 0) \
1978 val = get_bits(gb, size_table[index1] - val); \
1980 sign = 0 - (val&1); \
1981 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1984 if (!s->quarter_sample && index1 == 5) val = 1; \
1986 if(size_table[index1] - val > 0) \
1987 val = get_bits(gb, size_table[index1] - val); \
1989 sign = 0 - (val&1); \
1990 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1993 /** Predict and set motion vector
1995 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)
1997 int xy, wrap, off = 0;
2002 /* scale MV difference to be quad-pel */
2003 dmv_x <<= 1 - s->quarter_sample;
2004 dmv_y <<= 1 - s->quarter_sample;
2006 wrap = s->b8_stride;
2007 xy = s->block_index[n];
2010 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
2011 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
2012 s->current_picture.motion_val[1][xy][0] = 0;
2013 s->current_picture.motion_val[1][xy][1] = 0;
2014 if(mv1) { /* duplicate motion data for 1-MV block */
2015 s->current_picture.motion_val[0][xy + 1][0] = 0;
2016 s->current_picture.motion_val[0][xy + 1][1] = 0;
2017 s->current_picture.motion_val[0][xy + wrap][0] = 0;
2018 s->current_picture.motion_val[0][xy + wrap][1] = 0;
2019 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
2020 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
2021 s->current_picture.motion_val[1][xy + 1][0] = 0;
2022 s->current_picture.motion_val[1][xy + 1][1] = 0;
2023 s->current_picture.motion_val[1][xy + wrap][0] = 0;
2024 s->current_picture.motion_val[1][xy + wrap][1] = 0;
2025 s->current_picture.motion_val[1][xy + wrap + 1][0] = 0;
2026 s->current_picture.motion_val[1][xy + wrap + 1][1] = 0;
2031 C = s->current_picture.motion_val[0][xy - 1];
2032 A = s->current_picture.motion_val[0][xy - wrap];
2034 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
2036 //in 4-MV mode different blocks have different B predictor position
2039 off = (s->mb_x > 0) ? -1 : 1;
2042 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
2051 B = s->current_picture.motion_val[0][xy - wrap + off];
2053 if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
2054 if(s->mb_width == 1) {
2058 px = mid_pred(A[0], B[0], C[0]);
2059 py = mid_pred(A[1], B[1], C[1]);
2061 } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
2067 /* Pullback MV as specified in 8.3.5.3.4 */
2070 qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
2071 qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
2072 X = (s->mb_width << 6) - 4;
2073 Y = (s->mb_height << 6) - 4;
2075 if(qx + px < -60) px = -60 - qx;
2076 if(qy + py < -60) py = -60 - qy;
2078 if(qx + px < -28) px = -28 - qx;
2079 if(qy + py < -28) py = -28 - qy;
2081 if(qx + px > X) px = X - qx;
2082 if(qy + py > Y) py = Y - qy;
2084 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2085 if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
2086 if(is_intra[xy - wrap])
2087 sum = FFABS(px) + FFABS(py);
2089 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2091 if(get_bits1(&s->gb)) {
2099 if(is_intra[xy - 1])
2100 sum = FFABS(px) + FFABS(py);
2102 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2104 if(get_bits1(&s->gb)) {
2114 /* store MV using signed modulus of MV range defined in 4.11 */
2115 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
2116 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
2117 if(mv1) { /* duplicate motion data for 1-MV block */
2118 s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
2119 s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
2120 s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
2121 s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
2122 s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
2123 s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
2127 /** Motion compensation for direct or interpolated blocks in B-frames
2129 static void vc1_interp_mc(VC1Context *v)
2131 MpegEncContext *s = &v->s;
2132 DSPContext *dsp = &v->s.dsp;
2133 uint8_t *srcY, *srcU, *srcV;
2134 int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
2136 if(!v->s.next_picture.data[0])return;
2138 mx = s->mv[1][0][0];
2139 my = s->mv[1][0][1];
2140 uvmx = (mx + ((mx & 3) == 3)) >> 1;
2141 uvmy = (my + ((my & 3) == 3)) >> 1;
2143 uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
2144 uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
2146 srcY = s->next_picture.data[0];
2147 srcU = s->next_picture.data[1];
2148 srcV = s->next_picture.data[2];
2150 src_x = s->mb_x * 16 + (mx >> 2);
2151 src_y = s->mb_y * 16 + (my >> 2);
2152 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
2153 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
2155 if(v->profile != PROFILE_ADVANCED){
2156 src_x = av_clip( src_x, -16, s->mb_width * 16);
2157 src_y = av_clip( src_y, -16, s->mb_height * 16);
2158 uvsrc_x = av_clip(uvsrc_x, -8, s->mb_width * 8);
2159 uvsrc_y = av_clip(uvsrc_y, -8, s->mb_height * 8);
2161 src_x = av_clip( src_x, -17, s->avctx->coded_width);
2162 src_y = av_clip( src_y, -18, s->avctx->coded_height + 1);
2163 uvsrc_x = av_clip(uvsrc_x, -8, s->avctx->coded_width >> 1);
2164 uvsrc_y = av_clip(uvsrc_y, -8, s->avctx->coded_height >> 1);
2167 srcY += src_y * s->linesize + src_x;
2168 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
2169 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
2171 /* for grayscale we should not try to read from unknown area */
2172 if(s->flags & CODEC_FLAG_GRAY) {
2173 srcU = s->edge_emu_buffer + 18 * s->linesize;
2174 srcV = s->edge_emu_buffer + 18 * s->linesize;
2178 || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
2179 || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
2180 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
2182 srcY -= s->mspel * (1 + s->linesize);
2183 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
2184 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
2185 srcY = s->edge_emu_buffer;
2186 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
2187 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2188 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
2189 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2192 /* if we deal with range reduction we need to scale source blocks */
2193 if(v->rangeredfrm) {
2195 uint8_t *src, *src2;
2198 for(j = 0; j < 17 + s->mspel*2; j++) {
2199 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
2202 src = srcU; src2 = srcV;
2203 for(j = 0; j < 9; j++) {
2204 for(i = 0; i < 9; i++) {
2205 src[i] = ((src[i] - 128) >> 1) + 128;
2206 src2[i] = ((src2[i] - 128) >> 1) + 128;
2208 src += s->uvlinesize;
2209 src2 += s->uvlinesize;
2212 srcY += s->mspel * (1 + s->linesize);
2217 dxy = ((my & 1) << 1) | (mx & 1);
2219 dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
2221 if(s->flags & CODEC_FLAG_GRAY) return;
2222 /* Chroma MC always uses qpel blilinear */
2223 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
2226 dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
2227 dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
2230 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2234 #if B_FRACTION_DEN==256
2238 return 2 * ((value * n + 255) >> 9);
2239 return (value * n + 128) >> 8;
2242 n -= B_FRACTION_DEN;
2244 return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2245 return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2249 /** Reconstruct motion vector for B-frame and do motion compensation
2251 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
2254 v->mv_mode2 = v->mv_mode;
2255 v->mv_mode = MV_PMODE_INTENSITY_COMP;
2260 if(v->use_ic) v->mv_mode = v->mv_mode2;
2263 if(mode == BMV_TYPE_INTERPOLATED) {
2266 if(v->use_ic) v->mv_mode = v->mv_mode2;
2270 if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
2271 vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2272 if(v->use_ic) v->mv_mode = v->mv_mode2;
2275 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
2277 MpegEncContext *s = &v->s;
2278 int xy, wrap, off = 0;
2283 const uint8_t *is_intra = v->mb_type[0];
2287 /* scale MV difference to be quad-pel */
2288 dmv_x[0] <<= 1 - s->quarter_sample;
2289 dmv_y[0] <<= 1 - s->quarter_sample;
2290 dmv_x[1] <<= 1 - s->quarter_sample;
2291 dmv_y[1] <<= 1 - s->quarter_sample;
2293 wrap = s->b8_stride;
2294 xy = s->block_index[0];
2297 s->current_picture.motion_val[0][xy][0] =
2298 s->current_picture.motion_val[0][xy][1] =
2299 s->current_picture.motion_val[1][xy][0] =
2300 s->current_picture.motion_val[1][xy][1] = 0;
2303 s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2304 s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2305 s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2306 s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2308 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2309 s->mv[0][0][0] = av_clip(s->mv[0][0][0], -60 - (s->mb_x << 6), (s->mb_width << 6) - 4 - (s->mb_x << 6));
2310 s->mv[0][0][1] = av_clip(s->mv[0][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
2311 s->mv[1][0][0] = av_clip(s->mv[1][0][0], -60 - (s->mb_x << 6), (s->mb_width << 6) - 4 - (s->mb_x << 6));
2312 s->mv[1][0][1] = av_clip(s->mv[1][0][1], -60 - (s->mb_y << 6), (s->mb_height << 6) - 4 - (s->mb_y << 6));
2314 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2315 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2316 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2317 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2321 if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2322 C = s->current_picture.motion_val[0][xy - 2];
2323 A = s->current_picture.motion_val[0][xy - wrap*2];
2324 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2325 B = s->current_picture.motion_val[0][xy - wrap*2 + off];
2327 if(!s->mb_x) C[0] = C[1] = 0;
2328 if(!s->first_slice_line) { // predictor A is not out of bounds
2329 if(s->mb_width == 1) {
2333 px = mid_pred(A[0], B[0], C[0]);
2334 py = mid_pred(A[1], B[1], C[1]);
2336 } else if(s->mb_x) { // predictor C is not out of bounds
2342 /* Pullback MV as specified in 8.3.5.3.4 */
2345 if(v->profile < PROFILE_ADVANCED) {
2346 qx = (s->mb_x << 5);
2347 qy = (s->mb_y << 5);
2348 X = (s->mb_width << 5) - 4;
2349 Y = (s->mb_height << 5) - 4;
2350 if(qx + px < -28) px = -28 - qx;
2351 if(qy + py < -28) py = -28 - qy;
2352 if(qx + px > X) px = X - qx;
2353 if(qy + py > Y) py = Y - qy;
2355 qx = (s->mb_x << 6);
2356 qy = (s->mb_y << 6);
2357 X = (s->mb_width << 6) - 4;
2358 Y = (s->mb_height << 6) - 4;
2359 if(qx + px < -60) px = -60 - qx;
2360 if(qy + py < -60) py = -60 - qy;
2361 if(qx + px > X) px = X - qx;
2362 if(qy + py > Y) py = Y - qy;
2365 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2366 if(0 && !s->first_slice_line && s->mb_x) {
2367 if(is_intra[xy - wrap])
2368 sum = FFABS(px) + FFABS(py);
2370 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2372 if(get_bits1(&s->gb)) {
2380 if(is_intra[xy - 2])
2381 sum = FFABS(px) + FFABS(py);
2383 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2385 if(get_bits1(&s->gb)) {
2395 /* store MV using signed modulus of MV range defined in 4.11 */
2396 s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2397 s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2399 if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2400 C = s->current_picture.motion_val[1][xy - 2];
2401 A = s->current_picture.motion_val[1][xy - wrap*2];
2402 off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2403 B = s->current_picture.motion_val[1][xy - wrap*2 + off];
2405 if(!s->mb_x) C[0] = C[1] = 0;
2406 if(!s->first_slice_line) { // predictor A is not out of bounds
2407 if(s->mb_width == 1) {
2411 px = mid_pred(A[0], B[0], C[0]);
2412 py = mid_pred(A[1], B[1], C[1]);
2414 } else if(s->mb_x) { // predictor C is not out of bounds
2420 /* Pullback MV as specified in 8.3.5.3.4 */
2423 if(v->profile < PROFILE_ADVANCED) {
2424 qx = (s->mb_x << 5);
2425 qy = (s->mb_y << 5);
2426 X = (s->mb_width << 5) - 4;
2427 Y = (s->mb_height << 5) - 4;
2428 if(qx + px < -28) px = -28 - qx;
2429 if(qy + py < -28) py = -28 - qy;
2430 if(qx + px > X) px = X - qx;
2431 if(qy + py > Y) py = Y - qy;
2433 qx = (s->mb_x << 6);
2434 qy = (s->mb_y << 6);
2435 X = (s->mb_width << 6) - 4;
2436 Y = (s->mb_height << 6) - 4;
2437 if(qx + px < -60) px = -60 - qx;
2438 if(qy + py < -60) py = -60 - qy;
2439 if(qx + px > X) px = X - qx;
2440 if(qy + py > Y) py = Y - qy;
2443 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2444 if(0 && !s->first_slice_line && s->mb_x) {
2445 if(is_intra[xy - wrap])
2446 sum = FFABS(px) + FFABS(py);
2448 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2450 if(get_bits1(&s->gb)) {
2458 if(is_intra[xy - 2])
2459 sum = FFABS(px) + FFABS(py);
2461 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2463 if(get_bits1(&s->gb)) {
2473 /* store MV using signed modulus of MV range defined in 4.11 */
2475 s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2476 s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2478 s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2479 s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2480 s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2481 s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2484 /** Get predicted DC value for I-frames only
2485 * prediction dir: left=0, top=1
2486 * @param s MpegEncContext
2487 * @param[in] n block index in the current MB
2488 * @param dc_val_ptr Pointer to DC predictor
2489 * @param dir_ptr Prediction direction for use in AC prediction
2491 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2492 int16_t **dc_val_ptr, int *dir_ptr)
2494 int a, b, c, wrap, pred, scale;
2496 static const uint16_t dcpred[32] = {
2497 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2498 114, 102, 93, 85, 79, 73, 68, 64,
2499 60, 57, 54, 51, 49, 47, 45, 43,
2500 41, 39, 38, 37, 35, 34, 33
2503 /* find prediction - wmv3_dc_scale always used here in fact */
2504 if (n < 4) scale = s->y_dc_scale;
2505 else scale = s->c_dc_scale;
2507 wrap = s->block_wrap[n];
2508 dc_val= s->dc_val[0] + s->block_index[n];
2514 b = dc_val[ - 1 - wrap];
2515 a = dc_val[ - wrap];
2517 if (pq < 9 || !overlap)
2519 /* Set outer values */
2520 if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
2521 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
2525 /* Set outer values */
2526 if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
2527 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
2530 if (abs(a - b) <= abs(b - c)) {
2538 /* update predictor */
2539 *dc_val_ptr = &dc_val[0];
2544 /** Get predicted DC value
2545 * prediction dir: left=0, top=1
2546 * @param s MpegEncContext
2547 * @param[in] n block index in the current MB
2548 * @param dc_val_ptr Pointer to DC predictor
2549 * @param dir_ptr Prediction direction for use in AC prediction
2551 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2552 int a_avail, int c_avail,
2553 int16_t **dc_val_ptr, int *dir_ptr)
2555 int a, b, c, wrap, pred, scale;
2557 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2560 /* find prediction - wmv3_dc_scale always used here in fact */
2561 if (n < 4) scale = s->y_dc_scale;
2562 else scale = s->c_dc_scale;
2564 wrap = s->block_wrap[n];
2565 dc_val= s->dc_val[0] + s->block_index[n];
2571 b = dc_val[ - 1 - wrap];
2572 a = dc_val[ - wrap];
2573 /* scale predictors if needed */
2574 q1 = s->current_picture.qscale_table[mb_pos];
2575 if(c_avail && (n!= 1 && n!=3)) {
2576 q2 = s->current_picture.qscale_table[mb_pos - 1];
2578 c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2580 if(a_avail && (n!= 2 && n!=3)) {
2581 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2583 a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2585 if(a_avail && c_avail && (n!=3)) {
2588 if(n != 2) off -= s->mb_stride;
2589 q2 = s->current_picture.qscale_table[off];
2591 b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2594 if(a_avail && c_avail) {
2595 if(abs(a - b) <= abs(b - c)) {
2602 } else if(a_avail) {
2605 } else if(c_avail) {
2613 /* update predictor */
2614 *dc_val_ptr = &dc_val[0];
2620 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2621 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2625 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
2627 int xy, wrap, pred, a, b, c;
2629 xy = s->block_index[n];
2630 wrap = s->b8_stride;
2635 a = s->coded_block[xy - 1 ];
2636 b = s->coded_block[xy - 1 - wrap];
2637 c = s->coded_block[xy - wrap];
2646 *coded_block_ptr = &s->coded_block[xy];
2652 * Decode one AC coefficient
2653 * @param v The VC1 context
2654 * @param last Last coefficient
2655 * @param skip How much zero coefficients to skip
2656 * @param value Decoded AC coefficient value
2659 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
2661 GetBitContext *gb = &v->s.gb;
2662 int index, escape, run = 0, level = 0, lst = 0;
2664 index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2665 if (index != vc1_ac_sizes[codingset] - 1) {
2666 run = vc1_index_decode_table[codingset][index][0];
2667 level = vc1_index_decode_table[codingset][index][1];
2668 lst = index >= vc1_last_decode_table[codingset];
2672 escape = decode210(gb);
2674 index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2675 run = vc1_index_decode_table[codingset][index][0];
2676 level = vc1_index_decode_table[codingset][index][1];
2677 lst = index >= vc1_last_decode_table[codingset];
2680 level += vc1_last_delta_level_table[codingset][run];
2682 level += vc1_delta_level_table[codingset][run];
2685 run += vc1_last_delta_run_table[codingset][level] + 1;
2687 run += vc1_delta_run_table[codingset][level] + 1;
2693 lst = get_bits(gb, 1);
2694 if(v->s.esc3_level_length == 0) {
2695 if(v->pq < 8 || v->dquantfrm) { // table 59
2696 v->s.esc3_level_length = get_bits(gb, 3);
2697 if(!v->s.esc3_level_length)
2698 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2700 v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
2702 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2704 run = get_bits(gb, v->s.esc3_run_length);
2705 sign = get_bits(gb, 1);
2706 level = get_bits(gb, v->s.esc3_level_length);
2717 /** Decode intra block in intra frames - should be faster than decode_intra_block
2718 * @param v VC1Context
2719 * @param block block to decode
2720 * @param coded are AC coeffs present or not
2721 * @param codingset set of VLC to decode data
2723 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
2725 GetBitContext *gb = &v->s.gb;
2726 MpegEncContext *s = &v->s;
2727 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2730 int16_t *ac_val, *ac_val2;
2733 /* Get DC differential */
2735 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2737 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2740 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2745 if (dcdiff == 119 /* ESC index value */)
2747 /* TODO: Optimize */
2748 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2749 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2750 else dcdiff = get_bits(gb, 8);
2755 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2756 else if (v->pq == 2)
2757 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2759 if (get_bits(gb, 1))
2764 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2767 /* Store the quantized DC coeff, used for prediction */
2769 block[0] = dcdiff * s->y_dc_scale;
2771 block[0] = dcdiff * s->c_dc_scale;
2784 int last = 0, skip, value;
2785 const int8_t *zz_table;
2789 scale = v->pq * 2 + v->halfpq;
2793 zz_table = vc1_horizontal_zz;
2795 zz_table = vc1_vertical_zz;
2797 zz_table = vc1_normal_zz;
2799 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2801 if(dc_pred_dir) //left
2804 ac_val -= 16 * s->block_wrap[n];
2807 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2811 block[zz_table[i++]] = value;
2814 /* apply AC prediction if needed */
2816 if(dc_pred_dir) { //left
2817 for(k = 1; k < 8; k++)
2818 block[k << 3] += ac_val[k];
2820 for(k = 1; k < 8; k++)
2821 block[k] += ac_val[k + 8];
2824 /* save AC coeffs for further prediction */
2825 for(k = 1; k < 8; k++) {
2826 ac_val2[k] = block[k << 3];
2827 ac_val2[k + 8] = block[k];
2830 /* scale AC coeffs */
2831 for(k = 1; k < 64; k++)
2835 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2838 if(s->ac_pred) i = 63;
2844 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2847 scale = v->pq * 2 + v->halfpq;
2848 memset(ac_val2, 0, 16 * 2);
2849 if(dc_pred_dir) {//left
2852 memcpy(ac_val2, ac_val, 8 * 2);
2854 ac_val -= 16 * s->block_wrap[n];
2856 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2859 /* apply AC prediction if needed */
2861 if(dc_pred_dir) { //left
2862 for(k = 1; k < 8; k++) {
2863 block[k << 3] = ac_val[k] * scale;
2864 if(!v->pquantizer && block[k << 3])
2865 block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2868 for(k = 1; k < 8; k++) {
2869 block[k] = ac_val[k + 8] * scale;
2870 if(!v->pquantizer && block[k])
2871 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2877 s->block_last_index[n] = i;
2882 /** Decode intra block in intra frames - should be faster than decode_intra_block
2883 * @param v VC1Context
2884 * @param block block to decode
2885 * @param coded are AC coeffs present or not
2886 * @param codingset set of VLC to decode data
2888 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
2890 GetBitContext *gb = &v->s.gb;
2891 MpegEncContext *s = &v->s;
2892 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2895 int16_t *ac_val, *ac_val2;
2897 int a_avail = v->a_avail, c_avail = v->c_avail;
2898 int use_pred = s->ac_pred;
2901 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2903 /* Get DC differential */
2905 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2907 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2910 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2915 if (dcdiff == 119 /* ESC index value */)
2917 /* TODO: Optimize */
2918 if (mquant == 1) dcdiff = get_bits(gb, 10);
2919 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2920 else dcdiff = get_bits(gb, 8);
2925 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2926 else if (mquant == 2)
2927 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2929 if (get_bits(gb, 1))
2934 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2937 /* Store the quantized DC coeff, used for prediction */
2939 block[0] = dcdiff * s->y_dc_scale;
2941 block[0] = dcdiff * s->c_dc_scale;
2950 /* check if AC is needed at all and adjust direction if needed */
2951 if(!a_avail) dc_pred_dir = 1;
2952 if(!c_avail) dc_pred_dir = 0;
2953 if(!a_avail && !c_avail) use_pred = 0;
2954 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2957 scale = mquant * 2 + v->halfpq;
2959 if(dc_pred_dir) //left
2962 ac_val -= 16 * s->block_wrap[n];
2964 q1 = s->current_picture.qscale_table[mb_pos];
2965 if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
2966 if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2967 if(dc_pred_dir && n==1) q2 = q1;
2968 if(!dc_pred_dir && n==2) q2 = q1;
2972 int last = 0, skip, value;
2973 const int8_t *zz_table;
2978 zz_table = vc1_horizontal_zz;
2980 zz_table = vc1_vertical_zz;
2982 zz_table = vc1_normal_zz;
2985 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2989 block[zz_table[i++]] = value;
2992 /* apply AC prediction if needed */
2994 /* scale predictors if needed*/
2996 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2997 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2999 if(dc_pred_dir) { //left
3000 for(k = 1; k < 8; k++)
3001 block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3003 for(k = 1; k < 8; k++)
3004 block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3007 if(dc_pred_dir) { //left
3008 for(k = 1; k < 8; k++)
3009 block[k << 3] += ac_val[k];
3011 for(k = 1; k < 8; k++)
3012 block[k] += ac_val[k + 8];
3016 /* save AC coeffs for further prediction */
3017 for(k = 1; k < 8; k++) {
3018 ac_val2[k] = block[k << 3];
3019 ac_val2[k + 8] = block[k];
3022 /* scale AC coeffs */
3023 for(k = 1; k < 64; k++)
3027 block[k] += (block[k] < 0) ? -mquant : mquant;
3030 if(use_pred) i = 63;
3031 } else { // no AC coeffs
3034 memset(ac_val2, 0, 16 * 2);
3035 if(dc_pred_dir) {//left
3037 memcpy(ac_val2, ac_val, 8 * 2);
3039 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3040 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3041 for(k = 1; k < 8; k++)
3042 ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3047 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3049 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3050 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3051 for(k = 1; k < 8; k++)
3052 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3057 /* apply AC prediction if needed */
3059 if(dc_pred_dir) { //left
3060 for(k = 1; k < 8; k++) {
3061 block[k << 3] = ac_val2[k] * scale;
3062 if(!v->pquantizer && block[k << 3])
3063 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3066 for(k = 1; k < 8; k++) {
3067 block[k] = ac_val2[k + 8] * scale;
3068 if(!v->pquantizer && block[k])
3069 block[k] += (block[k] < 0) ? -mquant : mquant;
3075 s->block_last_index[n] = i;
3080 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
3081 * @param v VC1Context
3082 * @param block block to decode
3083 * @param coded are AC coeffs present or not
3084 * @param mquant block quantizer
3085 * @param codingset set of VLC to decode data
3087 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
3089 GetBitContext *gb = &v->s.gb;
3090 MpegEncContext *s = &v->s;
3091 int dc_pred_dir = 0; /* Direction of the DC prediction used */
3094 int16_t *ac_val, *ac_val2;
3096 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3097 int a_avail = v->a_avail, c_avail = v->c_avail;
3098 int use_pred = s->ac_pred;
3102 /* XXX: Guard against dumb values of mquant */
3103 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
3105 /* Set DC scale - y and c use the same */
3106 s->y_dc_scale = s->y_dc_scale_table[mquant];
3107 s->c_dc_scale = s->c_dc_scale_table[mquant];
3109 /* Get DC differential */
3111 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3113 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3116 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3121 if (dcdiff == 119 /* ESC index value */)
3123 /* TODO: Optimize */
3124 if (mquant == 1) dcdiff = get_bits(gb, 10);
3125 else if (mquant == 2) dcdiff = get_bits(gb, 9);
3126 else dcdiff = get_bits(gb, 8);
3131 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
3132 else if (mquant == 2)
3133 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
3135 if (get_bits(gb, 1))
3140 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3143 /* Store the quantized DC coeff, used for prediction */
3146 block[0] = dcdiff * s->y_dc_scale;
3148 block[0] = dcdiff * s->c_dc_scale;
3157 /* check if AC is needed at all and adjust direction if needed */
3158 if(!a_avail) dc_pred_dir = 1;
3159 if(!c_avail) dc_pred_dir = 0;
3160 if(!a_avail && !c_avail) use_pred = 0;
3161 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3164 scale = mquant * 2 + v->halfpq;
3166 if(dc_pred_dir) //left
3169 ac_val -= 16 * s->block_wrap[n];
3171 q1 = s->current_picture.qscale_table[mb_pos];
3172 if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
3173 if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3174 if(dc_pred_dir && n==1) q2 = q1;
3175 if(!dc_pred_dir && n==2) q2 = q1;
3179 int last = 0, skip, value;
3180 const int8_t *zz_table;
3183 zz_table = vc1_simple_progressive_8x8_zz;
3186 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3190 block[zz_table[i++]] = value;
3193 /* apply AC prediction if needed */
3195 /* scale predictors if needed*/
3197 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3198 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3200 if(dc_pred_dir) { //left
3201 for(k = 1; k < 8; k++)
3202 block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3204 for(k = 1; k < 8; k++)
3205 block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3208 if(dc_pred_dir) { //left
3209 for(k = 1; k < 8; k++)
3210 block[k << 3] += ac_val[k];
3212 for(k = 1; k < 8; k++)
3213 block[k] += ac_val[k + 8];
3217 /* save AC coeffs for further prediction */
3218 for(k = 1; k < 8; k++) {
3219 ac_val2[k] = block[k << 3];
3220 ac_val2[k + 8] = block[k];
3223 /* scale AC coeffs */
3224 for(k = 1; k < 64; k++)
3228 block[k] += (block[k] < 0) ? -mquant : mquant;
3231 if(use_pred) i = 63;
3232 } else { // no AC coeffs
3235 memset(ac_val2, 0, 16 * 2);
3236 if(dc_pred_dir) {//left
3238 memcpy(ac_val2, ac_val, 8 * 2);
3240 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3241 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3242 for(k = 1; k < 8; k++)
3243 ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3248 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3250 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3251 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3252 for(k = 1; k < 8; k++)
3253 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3258 /* apply AC prediction if needed */
3260 if(dc_pred_dir) { //left
3261 for(k = 1; k < 8; k++) {
3262 block[k << 3] = ac_val2[k] * scale;
3263 if(!v->pquantizer && block[k << 3])
3264 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3267 for(k = 1; k < 8; k++) {
3268 block[k] = ac_val2[k + 8] * scale;
3269 if(!v->pquantizer && block[k])
3270 block[k] += (block[k] < 0) ? -mquant : mquant;
3276 s->block_last_index[n] = i;
3283 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
3285 MpegEncContext *s = &v->s;
3286 GetBitContext *gb = &s->gb;
3289 int scale, off, idx, last, skip, value;
3290 int ttblk = ttmb & 7;
3293 ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
3295 if(ttblk == TT_4X4) {
3296 subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3298 if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
3299 subblkpat = decode012(gb);
3300 if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
3301 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
3302 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
3304 scale = 2 * mquant + v->halfpq;
3306 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3307 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3308 subblkpat = 2 - (ttblk == TT_8X4_TOP);
3311 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3312 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3320 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3324 idx = vc1_simple_progressive_8x8_zz[i++];
3325 block[idx] = value * scale;
3327 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3329 s->dsp.vc1_inv_trans_8x8(block);
3332 for(j = 0; j < 4; j++) {
3333 last = subblkpat & (1 << (3 - j));
3335 off = (j & 1) * 4 + (j & 2) * 16;
3337 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3341 idx = vc1_simple_progressive_4x4_zz[i++];
3342 block[idx + off] = value * scale;
3344 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3346 if(!(subblkpat & (1 << (3 - j))))
3347 s->dsp.vc1_inv_trans_4x4(block, j);
3351 for(j = 0; j < 2; j++) {
3352 last = subblkpat & (1 << (1 - j));
3356 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3360 if(v->profile < PROFILE_ADVANCED)
3361 idx = vc1_simple_progressive_8x4_zz[i++];
3363 idx = vc1_adv_progressive_8x4_zz[i++];
3364 block[idx + off] = value * scale;
3366 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3368 if(!(subblkpat & (1 << (1 - j))))
3369 s->dsp.vc1_inv_trans_8x4(block, j);
3373 for(j = 0; j < 2; j++) {
3374 last = subblkpat & (1 << (1 - j));
3378 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3382 if(v->profile < PROFILE_ADVANCED)
3383 idx = vc1_simple_progressive_4x8_zz[i++];
3385 idx = vc1_adv_progressive_4x8_zz[i++];
3386 block[idx + off] = value * scale;
3388 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3390 if(!(subblkpat & (1 << (1 - j))))
3391 s->dsp.vc1_inv_trans_4x8(block, j);
3399 /** Decode one P-frame MB (in Simple/Main profile)
3401 static int vc1_decode_p_mb(VC1Context *v)
3403 MpegEncContext *s = &v->s;
3404 GetBitContext *gb = &s->gb;
3406 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3407 int cbp; /* cbp decoding stuff */
3408 int mqdiff, mquant; /* MB quantization */
3409 int ttmb = v->ttfrm; /* MB Transform type */
3412 static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3413 offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3414 int mb_has_coeffs = 1; /* last_flag */
3415 int dmv_x, dmv_y; /* Differential MV components */
3416 int index, index1; /* LUT indices */
3417 int val, sign; /* temp values */
3418 int first_block = 1;
3420 int skipped, fourmv;
3422 mquant = v->pq; /* Loosy initialization */
3424 if (v->mv_type_is_raw)
3425 fourmv = get_bits1(gb);
3427 fourmv = v->mv_type_mb_plane[mb_pos];
3429 skipped = get_bits1(gb);
3431 skipped = v->s.mbskip_table[mb_pos];
3433 s->dsp.clear_blocks(s->block[0]);
3435 if (!fourmv) /* 1MV mode */
3439 GET_MVDATA(dmv_x, dmv_y);
3442 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3443 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3445 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3446 vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3448 /* FIXME Set DC val for inter block ? */
3449 if (s->mb_intra && !mb_has_coeffs)
3452 s->ac_pred = get_bits(gb, 1);
3455 else if (mb_has_coeffs)
3457 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
3458 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3466 s->current_picture.qscale_table[mb_pos] = mquant;
3468 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3469 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
3470 VC1_TTMB_VLC_BITS, 2);
3471 if(!s->mb_intra) vc1_mc_1mv(v, 0);
3475 s->dc_val[0][s->block_index[i]] = 0;
3477 val = ((cbp >> (5 - i)) & 1);
3478 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3479 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3481 /* check if prediction blocks A and C are available */
3482 v->a_avail = v->c_avail = 0;
3483 if(i == 2 || i == 3 || !s->first_slice_line)
3484 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3485 if(i == 1 || i == 3 || s->mb_x)
3486 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3488 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3489 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3490 s->dsp.vc1_inv_trans_8x8(s->block[i]);
3491 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3492 for(j = 0; j < 64; j++) s->block[i][j] += 128;
3493 if(!v->res_fasttx && v->res_x8) for(j = 0; j < 64; j++) s->block[i][j] += 16;
3494 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3495 if(v->pq >= 9 && v->overlap) {
3497 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3499 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3502 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3503 if(!v->ttmbf && ttmb < 8) ttmb = -1;
3505 if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3506 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3513 for(i = 0; i < 6; i++) {
3514 v->mb_type[0][s->block_index[i]] = 0;
3515 s->dc_val[0][s->block_index[i]] = 0;
3517 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3518 s->current_picture.qscale_table[mb_pos] = 0;
3519 vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3526 if (!skipped /* unskipped MB */)
3528 int intra_count = 0, coded_inter = 0;
3529 int is_intra[6], is_coded[6];
3531 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3534 val = ((cbp >> (5 - i)) & 1);
3535 s->dc_val[0][s->block_index[i]] = 0;
3542 GET_MVDATA(dmv_x, dmv_y);
3544 vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3545 if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
3546 intra_count += s->mb_intra;
3547 is_intra[i] = s->mb_intra;
3548 is_coded[i] = mb_has_coeffs;
3551 is_intra[i] = (intra_count >= 3);
3554 if(i == 4) vc1_mc_4mv_chroma(v);
3555 v->mb_type[0][s->block_index[i]] = is_intra[i];
3556 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
3558 // if there are no coded blocks then don't do anything more
3559 if(!intra_count && !coded_inter) return 0;
3562 s->current_picture.qscale_table[mb_pos] = mquant;
3563 /* test if block is intra and has pred */
3568 if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3569 || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
3574 if(intrapred)s->ac_pred = get_bits(gb, 1);
3575 else s->ac_pred = 0;
3577 if (!v->ttmbf && coded_inter)
3578 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3582 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3583 s->mb_intra = is_intra[i];
3585 /* check if prediction blocks A and C are available */
3586 v->a_avail = v->c_avail = 0;
3587 if(i == 2 || i == 3 || !s->first_slice_line)
3588 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3589 if(i == 1 || i == 3 || s->mb_x)
3590 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3592 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
3593 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3594 s->dsp.vc1_inv_trans_8x8(s->block[i]);
3595 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3596 for(j = 0; j < 64; j++) s->block[i][j] += 128;
3597 if(!v->res_fasttx && v->res_x8) for(j = 0; j < 64; j++) s->block[i][j] += 16;
3598 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3599 if(v->pq >= 9 && v->overlap) {
3601 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3603 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3605 } else if(is_coded[i]) {
3606 status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3607 if(!v->ttmbf && ttmb < 8) ttmb = -1;
3609 if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3610 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3618 s->current_picture.qscale_table[mb_pos] = 0;
3619 for (i=0; i<6; i++) {
3620 v->mb_type[0][s->block_index[i]] = 0;
3621 s->dc_val[0][s->block_index[i]] = 0;
3625 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
3626 vc1_mc_4mv_luma(v, i);
3628 vc1_mc_4mv_chroma(v);
3629 s->current_picture.qscale_table[mb_pos] = 0;
3634 /* Should never happen */
3638 /** Decode one B-frame MB (in Main profile)
3640 static void vc1_decode_b_mb(VC1Context *v)
3642 MpegEncContext *s = &v->s;
3643 GetBitContext *gb = &s->gb;
3645 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3646 int cbp = 0; /* cbp decoding stuff */
3647 int mqdiff, mquant; /* MB quantization */
3648 int ttmb = v->ttfrm; /* MB Transform type */
3650 static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3651 offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3652 int mb_has_coeffs = 0; /* last_flag */
3653 int index, index1; /* LUT indices */
3654 int val, sign; /* temp values */
3655 int first_block = 1;
3657 int skipped, direct;
3658 int dmv_x[2], dmv_y[2];
3659 int bmvtype = BMV_TYPE_BACKWARD;
3661 mquant = v->pq; /* Loosy initialization */
3665 direct = get_bits1(gb);
3667 direct = v->direct_mb_plane[mb_pos];
3669 skipped = get_bits1(gb);
3671 skipped = v->s.mbskip_table[mb_pos];
3673 s->dsp.clear_blocks(s->block[0]);
3674 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
3675 for(i = 0; i < 6; i++) {
3676 v->mb_type[0][s->block_index[i]] = 0;
3677 s->dc_val[0][s->block_index[i]] = 0;
3679 s->current_picture.qscale_table[mb_pos] = 0;
3683 GET_MVDATA(dmv_x[0], dmv_y[0]);
3684 dmv_x[1] = dmv_x[0];
3685 dmv_y[1] = dmv_y[0];
3687 if(skipped || !s->mb_intra) {
3688 bmvtype = decode012(gb);
3691 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
3694 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
3697 bmvtype = BMV_TYPE_INTERPOLATED;
3698 dmv_x[0] = dmv_y[0] = 0;
3702 for(i = 0; i < 6; i++)
3703 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3706 if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
3707 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3708 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3712 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3716 s->current_picture.qscale_table[mb_pos] = mquant;
3718 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3719 dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
3720 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3721 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3723 if(!mb_has_coeffs && !s->mb_intra) {
3724 /* no coded blocks - effectively skipped */
3725 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3726 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3729 if(s->mb_intra && !mb_has_coeffs) {
3731 s->current_picture.qscale_table[mb_pos] = mquant;
3732 s->ac_pred = get_bits1(gb);
3734 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3736 if(bmvtype == BMV_TYPE_INTERPOLATED) {
3737 GET_MVDATA(dmv_x[0], dmv_y[0]);
3738 if(!mb_has_coeffs) {
3739 /* interpolated skipped block */
3740 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3741 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3745 vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3747 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3750 s->ac_pred = get_bits1(gb);
3751 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3753 s->current_picture.qscale_table[mb_pos] = mquant;
3754 if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3755 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3761 s->dc_val[0][s->block_index[i]] = 0;
3763 val = ((cbp >> (5 - i)) & 1);
3764 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3765 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3767 /* check if prediction blocks A and C are available */
3768 v->a_avail = v->c_avail = 0;
3769 if(i == 2 || i == 3 || !s->first_slice_line)
3770 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3771 if(i == 1 || i == 3 || s->mb_x)
3772 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3774 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3775 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3776 s->dsp.vc1_inv_trans_8x8(s->block[i]);
3777 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3778 for(j = 0; j < 64; j++) s->block[i][j] += 128;
3779 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3781 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3782 if(!v->ttmbf && ttmb < 8) ttmb = -1;
3784 if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3785 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3790 /** Decode blocks of I-frame
3792 static void vc1_decode_i_blocks(VC1Context *v)
3795 MpegEncContext *s = &v->s;
3800 /* select codingmode used for VLC tables selection */
3801 switch(v->y_ac_table_index){
3803 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3806 v->codingset = CS_HIGH_MOT_INTRA;
3809 v->codingset = CS_MID_RATE_INTRA;
3813 switch(v->c_ac_table_index){
3815 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3818 v->codingset2 = CS_HIGH_MOT_INTER;
3821 v->codingset2 = CS_MID_RATE_INTER;
3825 /* Set DC scale - y and c use the same */
3826 s->y_dc_scale = s->y_dc_scale_table[v->pq];
3827 s->c_dc_scale = s->c_dc_scale_table[v->pq];
3830 s->mb_x = s->mb_y = 0;
3832 s->first_slice_line = 1;
3833 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3834 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3835 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3836 ff_init_block_index(s);
3837 ff_update_block_index(s);
3838 s->dsp.clear_blocks(s->block[0]);
3839 mb_pos = s->mb_x + s->mb_y * s->mb_width;
3840 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3841 s->current_picture.qscale_table[mb_pos] = v->pq;
3842 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3843 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3845 // do actual MB decoding and displaying
3846 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3847 v->s.ac_pred = get_bits(&v->s.gb, 1);
3849 for(k = 0; k < 6; k++) {
3850 val = ((cbp >> (5 - k)) & 1);
3853 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3857 cbp |= val << (5 - k);
3859 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
3861 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3862 if(!v->res_fasttx && !v->res_x8) for(j = 0; j < 64; j++) s->block[k][j] -= 16;
3863 if(v->pq >= 9 && v->overlap) {
3864 for(j = 0; j < 64; j++) s->block[k][j] += 128;
3868 vc1_put_block(v, s->block);
3869 if(v->pq >= 9 && v->overlap) {
3871 s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3872 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3873 if(!(s->flags & CODEC_FLAG_GRAY)) {
3874 s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3875 s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3878 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3879 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3880 if(!s->first_slice_line) {
3881 s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3882 s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3883 if(!(s->flags & CODEC_FLAG_GRAY)) {
3884 s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3885 s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3888 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3889 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3892 if(get_bits_count(&s->gb) > v->bits) {
3893 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3897 ff_draw_horiz_band(s, s->mb_y * 16, 16);
3898 s->first_slice_line = 0;
3902 /** Decode blocks of I-frame for advanced profile
3904 static void vc1_decode_i_blocks_adv(VC1Context *v)
3907 MpegEncContext *s = &v->s;
3914 GetBitContext *gb = &s->gb;
3916 /* select codingmode used for VLC tables selection */
3917 switch(v->y_ac_table_index){
3919 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3922 v->codingset = CS_HIGH_MOT_INTRA;
3925 v->codingset = CS_MID_RATE_INTRA;
3929 switch(v->c_ac_table_index){
3931 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3934 v->codingset2 = CS_HIGH_MOT_INTER;
3937 v->codingset2 = CS_MID_RATE_INTER;
3942 s->mb_x = s->mb_y = 0;
3944 s->first_slice_line = 1;
3945 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3946 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3947 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3948 ff_init_block_index(s);
3949 ff_update_block_index(s);
3950 s->dsp.clear_blocks(s->block[0]);
3951 mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3952 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3953 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3954 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3956 // do actual MB decoding and displaying
3957 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3958 if(v->acpred_is_raw)
3959 v->s.ac_pred = get_bits(&v->s.gb, 1);
3961 v->s.ac_pred = v->acpred_plane[mb_pos];
3963 if(v->condover == CONDOVER_SELECT) {
3964 if(v->overflg_is_raw)
3965 overlap = get_bits(&v->s.gb, 1);
3967 overlap = v->over_flags_plane[mb_pos];
3969 overlap = (v->condover == CONDOVER_ALL);
3973 s->current_picture.qscale_table[mb_pos] = mquant;
3974 /* Set DC scale - y and c use the same */
3975 s->y_dc_scale = s->y_dc_scale_table[mquant];
3976 s->c_dc_scale = s->c_dc_scale_table[mquant];
3978 for(k = 0; k < 6; k++) {
3979 val = ((cbp >> (5 - k)) & 1);
3982 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3986 cbp |= val << (5 - k);
3988 v->a_avail = !s->first_slice_line || (k==2 || k==3);
3989 v->c_avail = !!s->mb_x || (k==1 || k==3);
3991 vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
3993 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3994 for(j = 0; j < 64; j++) s->block[k][j] += 128;
3997 vc1_put_block(v, s->block);
4000 s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
4001 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4002 if(!(s->flags & CODEC_FLAG_GRAY)) {
4003 s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
4004 s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
4007 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
4008 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4009 if(!s->first_slice_line) {
4010 s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
4011 s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
4012 if(!(s->flags & CODEC_FLAG_GRAY)) {
4013 s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
4014 s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
4017 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
4018 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
4021 if(get_bits_count(&s->gb) > v->bits) {
4022 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
4026 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4027 s->first_slice_line = 0;
4031 static void vc1_decode_p_blocks(VC1Context *v)
4033 MpegEncContext *s = &v->s;
4035 /* select codingmode used for VLC tables selection */
4036 switch(v->c_ac_table_index){
4038 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4041 v->codingset = CS_HIGH_MOT_INTRA;
4044 v->codingset = CS_MID_RATE_INTRA;
4048 switch(v->c_ac_table_index){
4050 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4053 v->codingset2 = CS_HIGH_MOT_INTER;
4056 v->codingset2 = CS_MID_RATE_INTER;
4060 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4061 s->first_slice_line = 1;
4062 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4063 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
4064 ff_init_block_index(s);
4065 ff_update_block_index(s);
4066 s->dsp.clear_blocks(s->block[0]);
4069 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4070 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);
4074 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4075 s->first_slice_line = 0;
4079 static void vc1_decode_b_blocks(VC1Context *v)
4081 MpegEncContext *s = &v->s;
4083 /* select codingmode used for VLC tables selection */
4084 switch(v->c_ac_table_index){
4086 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4089 v->codingset = CS_HIGH_MOT_INTRA;
4092 v->codingset = CS_MID_RATE_INTRA;
4096 switch(v->c_ac_table_index){
4098 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4101 v->codingset2 = CS_HIGH_MOT_INTER;
4104 v->codingset2 = CS_MID_RATE_INTER;
4108 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4109 s->first_slice_line = 1;
4110 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4111 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
4112 ff_init_block_index(s);
4113 ff_update_block_index(s);
4114 s->dsp.clear_blocks(s->block[0]);
4117 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4118 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);
4122 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4123 s->first_slice_line = 0;
4127 static void vc1_decode_skip_blocks(VC1Context *v)
4129 MpegEncContext *s = &v->s;
4131 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4132 s->first_slice_line = 1;
4133 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4135 ff_init_block_index(s);
4136 ff_update_block_index(s);
4137 memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4138 memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4139 memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4140 ff_draw_horiz_band(s, s->mb_y * 16, 16);
4141 s->first_slice_line = 0;
4143 s->pict_type = P_TYPE;
4146 static void vc1_decode_blocks(VC1Context *v)
4149 v->s.esc3_level_length = 0;
4151 switch(v->s.pict_type) {
4153 if(v->profile == PROFILE_ADVANCED)
4154 vc1_decode_i_blocks_adv(v);
4156 vc1_decode_i_blocks(v);
4159 if(v->p_frame_skipped)
4160 vc1_decode_skip_blocks(v);
4162 vc1_decode_p_blocks(v);
4166 if(v->profile == PROFILE_ADVANCED)
4167 vc1_decode_i_blocks_adv(v);
4169 vc1_decode_i_blocks(v);
4171 vc1_decode_b_blocks(v);
4176 #define IS_MARKER(x) (((x) & ~0xFF) == VC1_CODE_RES0)
4178 /** Find VC-1 marker in buffer
4179 * @return position where next marker starts or end of buffer if no marker found
4181 static av_always_inline uint8_t* find_next_marker(uint8_t *src, uint8_t *end)
4183 uint32_t mrk = 0xFFFFFFFF;
4185 if(end-src < 4) return end;
4187 mrk = (mrk << 8) | *src++;
4194 static av_always_inline int vc1_unescape_buffer(uint8_t *src, int size, uint8_t *dst)
4199 for(dsize = 0; dsize < size; dsize++) *dst++ = *src++;
4202 for(i = 0; i < size; i++, src++) {
4203 if(src[0] == 3 && i >= 2 && !src[-1] && !src[-2] && i < size-1 && src[1] < 4) {
4204 dst[dsize++] = src[1];
4208 dst[dsize++] = *src;
4213 /** Initialize a VC1/WMV3 decoder
4214 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4215 * @todo TODO: Decypher remaining bits in extra_data
4217 static int vc1_decode_init(AVCodecContext *avctx)
4219 VC1Context *v = avctx->priv_data;
4220 MpegEncContext *s = &v->s;
4223 if (!avctx->extradata_size || !avctx->extradata) return -1;
4224 if (!(avctx->flags & CODEC_FLAG_GRAY))
4225 avctx->pix_fmt = PIX_FMT_YUV420P;
4227 avctx->pix_fmt = PIX_FMT_GRAY8;
4229 avctx->flags |= CODEC_FLAG_EMU_EDGE;
4230 v->s.flags |= CODEC_FLAG_EMU_EDGE;
4232 if(ff_h263_decode_init(avctx) < 0)
4234 if (vc1_init_common(v) < 0) return -1;
4236 avctx->coded_width = avctx->width;
4237 avctx->coded_height = avctx->height;
4238 if (avctx->codec_id == CODEC_ID_WMV3)
4242 // looks like WMV3 has a sequence header stored in the extradata
4243 // advanced sequence header may be before the first frame
4244 // the last byte of the extradata is a version number, 1 for the
4245 // samples we can decode
4247 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
4249 if (decode_sequence_header(avctx, &gb) < 0)
4252 count = avctx->extradata_size*8 - get_bits_count(&gb);
4255 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
4256 count, get_bits(&gb, count));
4260 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
4262 } else { // VC1/WVC1
4263 uint8_t *start = avctx->extradata, *end = avctx->extradata + avctx->extradata_size;
4264 uint8_t *next; int size, buf2_size;
4265 uint8_t *buf2 = NULL;
4266 int seq_inited = 0, ep_inited = 0;
4268 if(avctx->extradata_size < 16) {
4269 av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
4273 buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
4274 if(start[0]) start++; // in WVC1 extradata first byte is its size
4276 for(; next < end; start = next){
4277 next = find_next_marker(start + 4, end);
4278 size = next - start - 4;
4279 if(size <= 0) continue;
4280 buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
4281 init_get_bits(&gb, buf2, buf2_size * 8);
4282 switch(AV_RB32(start)){
4283 case VC1_CODE_SEQHDR:
4284 if(decode_sequence_header(avctx, &gb) < 0){
4290 case VC1_CODE_ENTRYPOINT:
4291 if(decode_entry_point(avctx, &gb) < 0){
4300 if(!seq_inited || !ep_inited){
4301 av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
4305 avctx->has_b_frames= !!(avctx->max_b_frames);
4306 s->low_delay = !avctx->has_b_frames;
4308 s->mb_width = (avctx->coded_width+15)>>4;
4309 s->mb_height = (avctx->coded_height+15)>>4;
4311 /* Allocate mb bitplanes */
4312 v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
4313 v->direct_mb_plane = av_malloc(s->mb_stride * s->mb_height);
4314 v->acpred_plane = av_malloc(s->mb_stride * s->mb_height);
4315 v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height);
4317 /* allocate block type info in that way so it could be used with s->block_index[] */
4318 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
4319 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
4320 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
4321 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
4323 /* Init coded blocks info */
4324 if (v->profile == PROFILE_ADVANCED)
4326 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
4328 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
4336 /** Decode a VC1/WMV3 frame
4337 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4339 static int vc1_decode_frame(AVCodecContext *avctx,
4340 void *data, int *data_size,
4341 uint8_t *buf, int buf_size)
4343 VC1Context *v = avctx->priv_data;
4344 MpegEncContext *s = &v->s;
4345 AVFrame *pict = data;
4346 uint8_t *buf2 = NULL;
4348 /* no supplementary picture */
4349 if (buf_size == 0) {
4350 /* special case for last picture */
4351 if (s->low_delay==0 && s->next_picture_ptr) {
4352 *pict= *(AVFrame*)s->next_picture_ptr;
4353 s->next_picture_ptr= NULL;
4355 *data_size = sizeof(AVFrame);
4361 //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
4362 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
4363 int i= ff_find_unused_picture(s, 0);
4364 s->current_picture_ptr= &s->picture[i];
4367 //for advanced profile we may need to parse and unescape data
4368 if (avctx->codec_id == CODEC_ID_VC1) {
4370 buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
4372 if(IS_MARKER(AV_RB32(buf))){ /* frame starts with marker and needs to be parsed */
4373 uint8_t *start, *end, *next;
4377 for(start = buf, end = buf + buf_size; next < end; start = next){
4378 next = find_next_marker(start + 4, end);
4379 size = next - start - 4;
4380 if(size <= 0) continue;
4381 switch(AV_RB32(start)){
4382 case VC1_CODE_FRAME:
4383 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
4385 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
4386 buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
4387 init_get_bits(&s->gb, buf2, buf_size2*8);
4388 decode_entry_point(avctx, &s->gb);
4390 case VC1_CODE_SLICE:
4391 av_log(avctx, AV_LOG_ERROR, "Sliced decoding is not implemented (yet)\n");
4396 }else if(v->interlace && ((buf[0] & 0xC0) == 0xC0)){ /* WVC1 interlaced stores both fields divided by marker */
4399 divider = find_next_marker(buf, buf + buf_size);
4400 if((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD){
4401 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
4405 buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
4407 av_free(buf2);return -1;
4409 buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
4411 init_get_bits(&s->gb, buf2, buf_size2*8);
4413 init_get_bits(&s->gb, buf, buf_size*8);
4414 // do parse frame header
4415 if(v->profile < PROFILE_ADVANCED) {
4416 if(vc1_parse_frame_header(v, &s->gb) == -1) {
4421 if(vc1_parse_frame_header_adv(v, &s->gb) == -1) {
4427 if(s->pict_type != I_TYPE && !v->res_rtm_flag){
4433 s->current_picture.pict_type= s->pict_type;
4434 s->current_picture.key_frame= s->pict_type == I_TYPE;
4436 /* skip B-frames if we don't have reference frames */
4437 if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)){
4439 return -1;//buf_size;
4441 /* skip b frames if we are in a hurry */
4442 if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
4443 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
4444 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
4445 || avctx->skip_frame >= AVDISCARD_ALL) {
4449 /* skip everything if we are in a hurry>=5 */
4450 if(avctx->hurry_up>=5) {
4452 return -1;//buf_size;
4455 if(s->next_p_frame_damaged){
4456 if(s->pict_type==B_TYPE)
4459 s->next_p_frame_damaged=0;
4462 if(MPV_frame_start(s, avctx) < 0) {
4467 ff_er_frame_start(s);
4469 v->bits = buf_size * 8;
4470 vc1_decode_blocks(v);
4471 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
4472 // if(get_bits_count(&s->gb) > buf_size * 8)
4478 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
4479 assert(s->current_picture.pict_type == s->pict_type);
4480 if (s->pict_type == B_TYPE || s->low_delay) {
4481 *pict= *(AVFrame*)s->current_picture_ptr;
4482 } else if (s->last_picture_ptr != NULL) {
4483 *pict= *(AVFrame*)s->last_picture_ptr;
4486 if(s->last_picture_ptr || s->low_delay){
4487 *data_size = sizeof(AVFrame);
4488 ff_print_debug_info(s, pict);
4491 /* Return the Picture timestamp as the frame number */
4492 /* we substract 1 because it is added on utils.c */
4493 avctx->frame_number = s->picture_number - 1;
4500 /** Close a VC1/WMV3 decoder
4501 * @warning Initial try at using MpegEncContext stuff
4503 static int vc1_decode_end(AVCodecContext *avctx)
4505 VC1Context *v = avctx->priv_data;
4507 av_freep(&v->hrd_rate);
4508 av_freep(&v->hrd_buffer);
4509 MPV_common_end(&v->s);
4510 av_freep(&v->mv_type_mb_plane);
4511 av_freep(&v->direct_mb_plane);
4512 av_freep(&v->acpred_plane);
4513 av_freep(&v->over_flags_plane);
4514 av_freep(&v->mb_type_base);
4519 AVCodec vc1_decoder = {
4532 AVCodec wmv3_decoder = {
4545 #ifdef CONFIG_VC1_PARSER
4547 * finds the end of the current frame in the bitstream.
4548 * @return the position of the first byte of the next frame, or -1
4550 static int vc1_find_frame_end(ParseContext *pc, const uint8_t *buf,
4555 pic_found= pc->frame_start_found;
4560 for(i=0; i<buf_size; i++){
4561 state= (state<<8) | buf[i];
4562 if(state == VC1_CODE_FRAME || state == VC1_CODE_FIELD){
4571 /* EOF considered as end of frame */
4574 for(; i<buf_size; i++){
4575 state= (state<<8) | buf[i];
4576 if(IS_MARKER(state) && state != VC1_CODE_FIELD && state != VC1_CODE_SLICE){
4577 pc->frame_start_found=0;
4583 pc->frame_start_found= pic_found;
4585 return END_NOT_FOUND;
4588 static int vc1_parse(AVCodecParserContext *s,
4589 AVCodecContext *avctx,
4590 uint8_t **poutbuf, int *poutbuf_size,
4591 const uint8_t *buf, int buf_size)
4593 ParseContext *pc = s->priv_data;
4596 if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
4599 next= vc1_find_frame_end(pc, buf, buf_size);
4601 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
4607 *poutbuf = (uint8_t *)buf;
4608 *poutbuf_size = buf_size;
4612 static int vc1_split(AVCodecContext *avctx,
4613 const uint8_t *buf, int buf_size)
4618 for(i=0; i<buf_size; i++){
4619 state= (state<<8) | buf[i];
4620 if(IS_MARKER(state) && state != VC1_CODE_SEQHDR && state != VC1_CODE_ENTRYPOINT)
4626 AVCodecParser vc1_parser = {
4628 sizeof(ParseContext1),
4634 #endif /* CONFIG_VC1_PARSER */