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
24 * @file libavcodec/vc1.c
25 * VC-1 and WMV3 decoder
31 #include "mpegvideo.h"
34 #include "vc1acdata.h"
35 #include "msmpeg4data.h"
37 #include "simple_idct.h"
39 #include "vdpau_internal.h"
44 #define MB_INTRA_VLC_BITS 9
47 static const uint16_t table_mb_intra
[64][2];
51 * Init VC-1 specific tables and VC1Context members
52 * @param v The VC1Context to initialize
55 static int vc1_init_common(VC1Context
*v
)
60 v
->hrd_rate
= v
->hrd_buffer
= NULL
;
66 init_vlc(&ff_vc1_bfraction_vlc
, VC1_BFRACTION_VLC_BITS
, 23,
67 ff_vc1_bfraction_bits
, 1, 1,
68 ff_vc1_bfraction_codes
, 1, 1, INIT_VLC_USE_STATIC
);
69 init_vlc(&ff_vc1_norm2_vlc
, VC1_NORM2_VLC_BITS
, 4,
70 ff_vc1_norm2_bits
, 1, 1,
71 ff_vc1_norm2_codes
, 1, 1, INIT_VLC_USE_STATIC
);
72 init_vlc(&ff_vc1_norm6_vlc
, VC1_NORM6_VLC_BITS
, 64,
73 ff_vc1_norm6_bits
, 1, 1,
74 ff_vc1_norm6_codes
, 2, 2, INIT_VLC_USE_STATIC
);
75 init_vlc(&ff_vc1_imode_vlc
, VC1_IMODE_VLC_BITS
, 7,
76 ff_vc1_imode_bits
, 1, 1,
77 ff_vc1_imode_codes
, 1, 1, INIT_VLC_USE_STATIC
);
80 init_vlc(&ff_vc1_ttmb_vlc
[i
], VC1_TTMB_VLC_BITS
, 16,
81 ff_vc1_ttmb_bits
[i
], 1, 1,
82 ff_vc1_ttmb_codes
[i
], 2, 2, INIT_VLC_USE_STATIC
);
83 init_vlc(&ff_vc1_ttblk_vlc
[i
], VC1_TTBLK_VLC_BITS
, 8,
84 ff_vc1_ttblk_bits
[i
], 1, 1,
85 ff_vc1_ttblk_codes
[i
], 1, 1, INIT_VLC_USE_STATIC
);
86 init_vlc(&ff_vc1_subblkpat_vlc
[i
], VC1_SUBBLKPAT_VLC_BITS
, 15,
87 ff_vc1_subblkpat_bits
[i
], 1, 1,
88 ff_vc1_subblkpat_codes
[i
], 1, 1, INIT_VLC_USE_STATIC
);
92 init_vlc(&ff_vc1_4mv_block_pattern_vlc
[i
], VC1_4MV_BLOCK_PATTERN_VLC_BITS
, 16,
93 ff_vc1_4mv_block_pattern_bits
[i
], 1, 1,
94 ff_vc1_4mv_block_pattern_codes
[i
], 1, 1, INIT_VLC_USE_STATIC
);
95 init_vlc(&ff_vc1_cbpcy_p_vlc
[i
], VC1_CBPCY_P_VLC_BITS
, 64,
96 ff_vc1_cbpcy_p_bits
[i
], 1, 1,
97 ff_vc1_cbpcy_p_codes
[i
], 2, 2, INIT_VLC_USE_STATIC
);
98 init_vlc(&ff_vc1_mv_diff_vlc
[i
], VC1_MV_DIFF_VLC_BITS
, 73,
99 ff_vc1_mv_diff_bits
[i
], 1, 1,
100 ff_vc1_mv_diff_codes
[i
], 2, 2, INIT_VLC_USE_STATIC
);
103 init_vlc(&ff_vc1_ac_coeff_table
[i
], AC_VLC_BITS
, vc1_ac_sizes
[i
],
104 &vc1_ac_tables
[i
][0][1], 8, 4,
105 &vc1_ac_tables
[i
][0][0], 8, 4, INIT_VLC_USE_STATIC
);
106 init_vlc(&ff_msmp4_mb_i_vlc
, MB_INTRA_VLC_BITS
, 64,
107 &ff_msmp4_mb_i_table
[0][1], 4, 2,
108 &ff_msmp4_mb_i_table
[0][0], 4, 2, INIT_VLC_USE_STATIC
);
113 v
->mvrange
= 0; /* 7.1.1.18, p80 */
118 /***********************************************************************/
120 * @defgroup vc1bitplane VC-1 Bitplane decoding
138 /** @} */ //imode defines
140 /** Decode rows by checking if they are skipped
141 * @param plane Buffer to store decoded bits
142 * @param[in] width Width of this buffer
143 * @param[in] height Height of this buffer
144 * @param[in] stride of this buffer
146 static void decode_rowskip(uint8_t* plane
, int width
, int height
, int stride
, GetBitContext
*gb
){
149 for (y
=0; y
<height
; y
++){
150 if (!get_bits1(gb
)) //rowskip
151 memset(plane
, 0, width
);
153 for (x
=0; x
<width
; x
++)
154 plane
[x
] = get_bits1(gb
);
159 /** Decode columns by checking if they are skipped
160 * @param plane Buffer to store decoded bits
161 * @param[in] width Width of this buffer
162 * @param[in] height Height of this buffer
163 * @param[in] stride of this buffer
164 * @todo FIXME: Optimize
166 static void decode_colskip(uint8_t* plane
, int width
, int height
, int stride
, GetBitContext
*gb
){
169 for (x
=0; x
<width
; x
++){
170 if (!get_bits1(gb
)) //colskip
171 for (y
=0; y
<height
; y
++)
174 for (y
=0; y
<height
; y
++)
175 plane
[y
*stride
] = get_bits1(gb
);
180 /** Decode a bitplane's bits
181 * @param data bitplane where to store the decode bits
182 * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
183 * @param v VC-1 context for bit reading and logging
185 * @todo FIXME: Optimize
187 static int bitplane_decoding(uint8_t* data
, int *raw_flag
, VC1Context
*v
)
189 GetBitContext
*gb
= &v
->s
.gb
;
191 int imode
, x
, y
, code
, offset
;
192 uint8_t invert
, *planep
= data
;
193 int width
, height
, stride
;
195 width
= v
->s
.mb_width
;
196 height
= v
->s
.mb_height
;
197 stride
= v
->s
.mb_stride
;
198 invert
= get_bits1(gb
);
199 imode
= get_vlc2(gb
, ff_vc1_imode_vlc
.table
, VC1_IMODE_VLC_BITS
, 1);
205 //Data is actually read in the MB layer (same for all tests == "raw")
206 *raw_flag
= 1; //invert ignored
210 if ((height
* width
) & 1)
212 *planep
++ = get_bits1(gb
);
216 // decode bitplane as one long line
217 for (y
= offset
; y
< height
* width
; y
+= 2) {
218 code
= get_vlc2(gb
, ff_vc1_norm2_vlc
.table
, VC1_NORM2_VLC_BITS
, 1);
219 *planep
++ = code
& 1;
221 if(offset
== width
) {
223 planep
+= stride
- width
;
225 *planep
++ = code
>> 1;
227 if(offset
== width
) {
229 planep
+= stride
- width
;
235 if(!(height
% 3) && (width
% 3)) { // use 2x3 decoding
236 for(y
= 0; y
< height
; y
+= 3) {
237 for(x
= width
& 1; x
< width
; x
+= 2) {
238 code
= get_vlc2(gb
, ff_vc1_norm6_vlc
.table
, VC1_NORM6_VLC_BITS
, 2);
240 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "invalid NORM-6 VLC\n");
243 planep
[x
+ 0] = (code
>> 0) & 1;
244 planep
[x
+ 1] = (code
>> 1) & 1;
245 planep
[x
+ 0 + stride
] = (code
>> 2) & 1;
246 planep
[x
+ 1 + stride
] = (code
>> 3) & 1;
247 planep
[x
+ 0 + stride
* 2] = (code
>> 4) & 1;
248 planep
[x
+ 1 + stride
* 2] = (code
>> 5) & 1;
250 planep
+= stride
* 3;
252 if(width
& 1) decode_colskip(data
, 1, height
, stride
, &v
->s
.gb
);
254 planep
+= (height
& 1) * stride
;
255 for(y
= height
& 1; y
< height
; y
+= 2) {
256 for(x
= width
% 3; x
< width
; x
+= 3) {
257 code
= get_vlc2(gb
, ff_vc1_norm6_vlc
.table
, VC1_NORM6_VLC_BITS
, 2);
259 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "invalid NORM-6 VLC\n");
262 planep
[x
+ 0] = (code
>> 0) & 1;
263 planep
[x
+ 1] = (code
>> 1) & 1;
264 planep
[x
+ 2] = (code
>> 2) & 1;
265 planep
[x
+ 0 + stride
] = (code
>> 3) & 1;
266 planep
[x
+ 1 + stride
] = (code
>> 4) & 1;
267 planep
[x
+ 2 + stride
] = (code
>> 5) & 1;
269 planep
+= stride
* 2;
272 if(x
) decode_colskip(data
, x
, height
, stride
, &v
->s
.gb
);
273 if(height
& 1) decode_rowskip(data
+x
, width
- x
, 1, stride
, &v
->s
.gb
);
277 decode_rowskip(data
, width
, height
, stride
, &v
->s
.gb
);
280 decode_colskip(data
, width
, height
, stride
, &v
->s
.gb
);
285 /* Applying diff operator */
286 if (imode
== IMODE_DIFF2
|| imode
== IMODE_DIFF6
)
290 for (x
=1; x
<width
; x
++)
291 planep
[x
] ^= planep
[x
-1];
292 for (y
=1; y
<height
; y
++)
295 planep
[0] ^= planep
[-stride
];
296 for (x
=1; x
<width
; x
++)
298 if (planep
[x
-1] != planep
[x
-stride
]) planep
[x
] ^= invert
;
299 else planep
[x
] ^= planep
[x
-1];
306 for (x
=0; x
<stride
*height
; x
++) planep
[x
] = !planep
[x
]; //FIXME stride
308 return (imode
<<1) + invert
;
311 /** @} */ //Bitplane group
313 static void vc1_loop_filter_iblk(MpegEncContext
*s
, int pq
)
316 if(!s
->first_slice_line
)
317 s
->dsp
.vc1_v_loop_filter16(s
->dest
[0], s
->linesize
, pq
);
318 s
->dsp
.vc1_v_loop_filter16(s
->dest
[0] + 8*s
->linesize
, s
->linesize
, pq
);
319 for(i
= !s
->mb_x
*8; i
< 16; i
+= 8)
320 s
->dsp
.vc1_h_loop_filter16(s
->dest
[0] + i
, s
->linesize
, pq
);
321 for(j
= 0; j
< 2; j
++){
322 if(!s
->first_slice_line
)
323 s
->dsp
.vc1_v_loop_filter8(s
->dest
[j
+1], s
->uvlinesize
, pq
);
325 s
->dsp
.vc1_h_loop_filter8(s
->dest
[j
+1], s
->uvlinesize
, pq
);
329 /***********************************************************************/
330 /** VOP Dquant decoding
331 * @param v VC-1 Context
333 static int vop_dquant_decoding(VC1Context
*v
)
335 GetBitContext
*gb
= &v
->s
.gb
;
341 pqdiff
= get_bits(gb
, 3);
342 if (pqdiff
== 7) v
->altpq
= get_bits(gb
, 5);
343 else v
->altpq
= v
->pq
+ pqdiff
+ 1;
347 v
->dquantfrm
= get_bits1(gb
);
350 v
->dqprofile
= get_bits(gb
, 2);
351 switch (v
->dqprofile
)
353 case DQPROFILE_SINGLE_EDGE
:
354 case DQPROFILE_DOUBLE_EDGES
:
355 v
->dqsbedge
= get_bits(gb
, 2);
357 case DQPROFILE_ALL_MBS
:
358 v
->dqbilevel
= get_bits1(gb
);
361 default: break; //Forbidden ?
363 if (v
->dqbilevel
|| v
->dqprofile
!= DQPROFILE_ALL_MBS
)
365 pqdiff
= get_bits(gb
, 3);
366 if (pqdiff
== 7) v
->altpq
= get_bits(gb
, 5);
367 else v
->altpq
= v
->pq
+ pqdiff
+ 1;
374 /** Put block onto picture
376 static void vc1_put_block(VC1Context
*v
, DCTELEM block
[6][64])
380 DSPContext
*dsp
= &v
->s
.dsp
;
384 for(k
= 0; k
< 6; k
++)
385 for(j
= 0; j
< 8; j
++)
386 for(i
= 0; i
< 8; i
++)
387 block
[k
][i
+ j
*8] = ((block
[k
][i
+ j
*8] - 128) << 1) + 128;
390 ys
= v
->s
.current_picture
.linesize
[0];
391 us
= v
->s
.current_picture
.linesize
[1];
392 vs
= v
->s
.current_picture
.linesize
[2];
395 dsp
->put_pixels_clamped(block
[0], Y
, ys
);
396 dsp
->put_pixels_clamped(block
[1], Y
+ 8, ys
);
398 dsp
->put_pixels_clamped(block
[2], Y
, ys
);
399 dsp
->put_pixels_clamped(block
[3], Y
+ 8, ys
);
401 if(!(v
->s
.flags
& CODEC_FLAG_GRAY
)) {
402 dsp
->put_pixels_clamped(block
[4], v
->s
.dest
[1], us
);
403 dsp
->put_pixels_clamped(block
[5], v
->s
.dest
[2], vs
);
407 /** Do motion compensation over 1 macroblock
408 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
410 static void vc1_mc_1mv(VC1Context
*v
, int dir
)
412 MpegEncContext
*s
= &v
->s
;
413 DSPContext
*dsp
= &v
->s
.dsp
;
414 uint8_t *srcY
, *srcU
, *srcV
;
415 int dxy
, uvdxy
, mx
, my
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
417 if(!v
->s
.last_picture
.data
[0])return;
419 mx
= s
->mv
[dir
][0][0];
420 my
= s
->mv
[dir
][0][1];
422 // store motion vectors for further use in B frames
423 if(s
->pict_type
== FF_P_TYPE
) {
424 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = mx
;
425 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = my
;
427 uvmx
= (mx
+ ((mx
& 3) == 3)) >> 1;
428 uvmy
= (my
+ ((my
& 3) == 3)) >> 1;
430 uvmx
= uvmx
+ ((uvmx
<0)?(uvmx
&1):-(uvmx
&1));
431 uvmy
= uvmy
+ ((uvmy
<0)?(uvmy
&1):-(uvmy
&1));
434 srcY
= s
->last_picture
.data
[0];
435 srcU
= s
->last_picture
.data
[1];
436 srcV
= s
->last_picture
.data
[2];
438 srcY
= s
->next_picture
.data
[0];
439 srcU
= s
->next_picture
.data
[1];
440 srcV
= s
->next_picture
.data
[2];
443 src_x
= s
->mb_x
* 16 + (mx
>> 2);
444 src_y
= s
->mb_y
* 16 + (my
>> 2);
445 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
446 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
448 if(v
->profile
!= PROFILE_ADVANCED
){
449 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
450 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
451 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
452 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
454 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
455 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
456 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
457 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
460 srcY
+= src_y
* s
->linesize
+ src_x
;
461 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
462 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
464 /* for grayscale we should not try to read from unknown area */
465 if(s
->flags
& CODEC_FLAG_GRAY
) {
466 srcU
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
467 srcV
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
470 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
471 || (unsigned)(src_x
- s
->mspel
) > s
->h_edge_pos
- (mx
&3) - 16 - s
->mspel
*3
472 || (unsigned)(src_y
- s
->mspel
) > s
->v_edge_pos
- (my
&3) - 16 - s
->mspel
*3){
473 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 19 * s
->linesize
;
475 srcY
-= s
->mspel
* (1 + s
->linesize
);
476 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 17+s
->mspel
*2, 17+s
->mspel
*2,
477 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
478 srcY
= s
->edge_emu_buffer
;
479 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, 8+1, 8+1,
480 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
481 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
482 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
485 /* if we deal with range reduction we need to scale source blocks */
491 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
492 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
495 src
= srcU
; src2
= srcV
;
496 for(j
= 0; j
< 9; j
++) {
497 for(i
= 0; i
< 9; i
++) {
498 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
499 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
501 src
+= s
->uvlinesize
;
502 src2
+= s
->uvlinesize
;
505 /* if we deal with intensity compensation we need to scale source blocks */
506 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
511 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
512 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = v
->luty
[src
[i
]];
515 src
= srcU
; src2
= srcV
;
516 for(j
= 0; j
< 9; j
++) {
517 for(i
= 0; i
< 9; i
++) {
518 src
[i
] = v
->lutuv
[src
[i
]];
519 src2
[i
] = v
->lutuv
[src2
[i
]];
521 src
+= s
->uvlinesize
;
522 src2
+= s
->uvlinesize
;
525 srcY
+= s
->mspel
* (1 + s
->linesize
);
529 dxy
= ((my
& 3) << 2) | (mx
& 3);
530 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] , srcY
, s
->linesize
, v
->rnd
);
531 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8, srcY
+ 8, s
->linesize
, v
->rnd
);
532 srcY
+= s
->linesize
* 8;
533 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8 * s
->linesize
, srcY
, s
->linesize
, v
->rnd
);
534 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8 * s
->linesize
+ 8, srcY
+ 8, s
->linesize
, v
->rnd
);
535 } else { // hpel mc - always used for luma
536 dxy
= (my
& 2) | ((mx
& 2) >> 1);
539 dsp
->put_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
541 dsp
->put_no_rnd_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
544 if(s
->flags
& CODEC_FLAG_GRAY
) return;
545 /* Chroma MC always uses qpel bilinear */
546 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
550 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
551 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
553 dsp
->put_no_rnd_vc1_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
554 dsp
->put_no_rnd_vc1_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
558 /** Do motion compensation for 4-MV macroblock - luminance block
560 static void vc1_mc_4mv_luma(VC1Context
*v
, int n
)
562 MpegEncContext
*s
= &v
->s
;
563 DSPContext
*dsp
= &v
->s
.dsp
;
565 int dxy
, mx
, my
, src_x
, src_y
;
568 if(!v
->s
.last_picture
.data
[0])return;
571 srcY
= s
->last_picture
.data
[0];
573 off
= s
->linesize
* 4 * (n
&2) + (n
&1) * 8;
575 src_x
= s
->mb_x
* 16 + (n
&1) * 8 + (mx
>> 2);
576 src_y
= s
->mb_y
* 16 + (n
&2) * 4 + (my
>> 2);
578 if(v
->profile
!= PROFILE_ADVANCED
){
579 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
580 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
582 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
583 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
586 srcY
+= src_y
* s
->linesize
+ src_x
;
588 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
589 || (unsigned)(src_x
- s
->mspel
) > s
->h_edge_pos
- (mx
&3) - 8 - s
->mspel
*2
590 || (unsigned)(src_y
- s
->mspel
) > s
->v_edge_pos
- (my
&3) - 8 - s
->mspel
*2){
591 srcY
-= s
->mspel
* (1 + s
->linesize
);
592 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 9+s
->mspel
*2, 9+s
->mspel
*2,
593 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
594 srcY
= s
->edge_emu_buffer
;
595 /* if we deal with range reduction we need to scale source blocks */
601 for(j
= 0; j
< 9 + s
->mspel
*2; j
++) {
602 for(i
= 0; i
< 9 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
606 /* if we deal with intensity compensation we need to scale source blocks */
607 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
612 for(j
= 0; j
< 9 + s
->mspel
*2; j
++) {
613 for(i
= 0; i
< 9 + s
->mspel
*2; i
++) src
[i
] = v
->luty
[src
[i
]];
617 srcY
+= s
->mspel
* (1 + s
->linesize
);
621 dxy
= ((my
& 3) << 2) | (mx
& 3);
622 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, v
->rnd
);
623 } else { // hpel mc - always used for luma
624 dxy
= (my
& 2) | ((mx
& 2) >> 1);
626 dsp
->put_pixels_tab
[1][dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, 8);
628 dsp
->put_no_rnd_pixels_tab
[1][dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, 8);
632 static inline int median4(int a
, int b
, int c
, int d
)
635 if(c
< d
) return (FFMIN(b
, d
) + FFMAX(a
, c
)) / 2;
636 else return (FFMIN(b
, c
) + FFMAX(a
, d
)) / 2;
638 if(c
< d
) return (FFMIN(a
, d
) + FFMAX(b
, c
)) / 2;
639 else return (FFMIN(a
, c
) + FFMAX(b
, d
)) / 2;
644 /** Do motion compensation for 4-MV macroblock - both chroma blocks
646 static void vc1_mc_4mv_chroma(VC1Context
*v
)
648 MpegEncContext
*s
= &v
->s
;
649 DSPContext
*dsp
= &v
->s
.dsp
;
650 uint8_t *srcU
, *srcV
;
651 int uvdxy
, uvmx
, uvmy
, uvsrc_x
, uvsrc_y
;
652 int i
, idx
, tx
= 0, ty
= 0;
653 int mvx
[4], mvy
[4], intra
[4];
654 static const int count
[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
656 if(!v
->s
.last_picture
.data
[0])return;
657 if(s
->flags
& CODEC_FLAG_GRAY
) return;
659 for(i
= 0; i
< 4; i
++) {
660 mvx
[i
] = s
->mv
[0][i
][0];
661 mvy
[i
] = s
->mv
[0][i
][1];
662 intra
[i
] = v
->mb_type
[0][s
->block_index
[i
]];
665 /* calculate chroma MV vector from four luma MVs */
666 idx
= (intra
[3] << 3) | (intra
[2] << 2) | (intra
[1] << 1) | intra
[0];
667 if(!idx
) { // all blocks are inter
668 tx
= median4(mvx
[0], mvx
[1], mvx
[2], mvx
[3]);
669 ty
= median4(mvy
[0], mvy
[1], mvy
[2], mvy
[3]);
670 } else if(count
[idx
] == 1) { // 3 inter blocks
673 tx
= mid_pred(mvx
[1], mvx
[2], mvx
[3]);
674 ty
= mid_pred(mvy
[1], mvy
[2], mvy
[3]);
677 tx
= mid_pred(mvx
[0], mvx
[2], mvx
[3]);
678 ty
= mid_pred(mvy
[0], mvy
[2], mvy
[3]);
681 tx
= mid_pred(mvx
[0], mvx
[1], mvx
[3]);
682 ty
= mid_pred(mvy
[0], mvy
[1], mvy
[3]);
685 tx
= mid_pred(mvx
[0], mvx
[1], mvx
[2]);
686 ty
= mid_pred(mvy
[0], mvy
[1], mvy
[2]);
689 } else if(count
[idx
] == 2) {
691 for(i
=0; i
<3;i
++) if(!intra
[i
]) {t1
= i
; break;}
692 for(i
= t1
+1; i
<4; i
++)if(!intra
[i
]) {t2
= i
; break;}
693 tx
= (mvx
[t1
] + mvx
[t2
]) / 2;
694 ty
= (mvy
[t1
] + mvy
[t2
]) / 2;
696 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
697 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
698 return; //no need to do MC for inter blocks
701 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = tx
;
702 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = ty
;
703 uvmx
= (tx
+ ((tx
&3) == 3)) >> 1;
704 uvmy
= (ty
+ ((ty
&3) == 3)) >> 1;
706 uvmx
= uvmx
+ ((uvmx
<0)?(uvmx
&1):-(uvmx
&1));
707 uvmy
= uvmy
+ ((uvmy
<0)?(uvmy
&1):-(uvmy
&1));
710 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
711 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
713 if(v
->profile
!= PROFILE_ADVANCED
){
714 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
715 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
717 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
718 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
721 srcU
= s
->last_picture
.data
[1] + uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
722 srcV
= s
->last_picture
.data
[2] + uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
723 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
724 || (unsigned)uvsrc_x
> (s
->h_edge_pos
>> 1) - 9
725 || (unsigned)uvsrc_y
> (s
->v_edge_pos
>> 1) - 9){
726 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcU
, s
->uvlinesize
, 8+1, 8+1,
727 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
728 ff_emulated_edge_mc(s
->edge_emu_buffer
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
729 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
730 srcU
= s
->edge_emu_buffer
;
731 srcV
= s
->edge_emu_buffer
+ 16;
733 /* if we deal with range reduction we need to scale source blocks */
738 src
= srcU
; src2
= srcV
;
739 for(j
= 0; j
< 9; j
++) {
740 for(i
= 0; i
< 9; i
++) {
741 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
742 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
744 src
+= s
->uvlinesize
;
745 src2
+= s
->uvlinesize
;
748 /* if we deal with intensity compensation we need to scale source blocks */
749 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
753 src
= srcU
; src2
= srcV
;
754 for(j
= 0; j
< 9; j
++) {
755 for(i
= 0; i
< 9; i
++) {
756 src
[i
] = v
->lutuv
[src
[i
]];
757 src2
[i
] = v
->lutuv
[src2
[i
]];
759 src
+= s
->uvlinesize
;
760 src2
+= s
->uvlinesize
;
765 /* Chroma MC always uses qpel bilinear */
766 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
770 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
771 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
773 dsp
->put_no_rnd_vc1_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
774 dsp
->put_no_rnd_vc1_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
778 static int decode_sequence_header_adv(VC1Context
*v
, GetBitContext
*gb
);
781 * Decode Simple/Main Profiles sequence header
782 * @see Figure 7-8, p16-17
783 * @param avctx Codec context
784 * @param gb GetBit context initialized from Codec context extra_data
787 static int decode_sequence_header(AVCodecContext
*avctx
, GetBitContext
*gb
)
789 VC1Context
*v
= avctx
->priv_data
;
791 av_log(avctx
, AV_LOG_DEBUG
, "Header: %0X\n", show_bits(gb
, 32));
792 v
->profile
= get_bits(gb
, 2);
793 if (v
->profile
== PROFILE_COMPLEX
)
795 av_log(avctx
, AV_LOG_ERROR
, "WMV3 Complex Profile is not fully supported\n");
798 if (v
->profile
== PROFILE_ADVANCED
)
800 v
->zz_8x4
= ff_vc1_adv_progressive_8x4_zz
;
801 v
->zz_4x8
= ff_vc1_adv_progressive_4x8_zz
;
802 return decode_sequence_header_adv(v
, gb
);
806 v
->zz_8x4
= wmv2_scantableA
;
807 v
->zz_4x8
= wmv2_scantableB
;
808 v
->res_sm
= get_bits(gb
, 2); //reserved
811 av_log(avctx
, AV_LOG_ERROR
,
812 "Reserved RES_SM=%i is forbidden\n", v
->res_sm
);
818 v
->frmrtq_postproc
= get_bits(gb
, 3); //common
819 // (bitrate-32kbps)/64kbps
820 v
->bitrtq_postproc
= get_bits(gb
, 5); //common
821 v
->s
.loop_filter
= get_bits1(gb
); //common
822 if(v
->s
.loop_filter
== 1 && v
->profile
== PROFILE_SIMPLE
)
824 av_log(avctx
, AV_LOG_ERROR
,
825 "LOOPFILTER shell not be enabled in simple profile\n");
827 if(v
->s
.avctx
->skip_loop_filter
>= AVDISCARD_ALL
)
828 v
->s
.loop_filter
= 0;
830 v
->res_x8
= get_bits1(gb
); //reserved
831 v
->multires
= get_bits1(gb
);
832 v
->res_fasttx
= get_bits1(gb
);
835 v
->s
.dsp
.vc1_inv_trans_8x8
= ff_simple_idct
;
836 v
->s
.dsp
.vc1_inv_trans_8x4
= ff_simple_idct84_add
;
837 v
->s
.dsp
.vc1_inv_trans_4x8
= ff_simple_idct48_add
;
838 v
->s
.dsp
.vc1_inv_trans_4x4
= ff_simple_idct44_add
;
841 v
->fastuvmc
= get_bits1(gb
); //common
842 if (!v
->profile
&& !v
->fastuvmc
)
844 av_log(avctx
, AV_LOG_ERROR
,
845 "FASTUVMC unavailable in Simple Profile\n");
848 v
->extended_mv
= get_bits1(gb
); //common
849 if (!v
->profile
&& v
->extended_mv
)
851 av_log(avctx
, AV_LOG_ERROR
,
852 "Extended MVs unavailable in Simple Profile\n");
855 v
->dquant
= get_bits(gb
, 2); //common
856 v
->vstransform
= get_bits1(gb
); //common
858 v
->res_transtab
= get_bits1(gb
);
861 av_log(avctx
, AV_LOG_ERROR
,
862 "1 for reserved RES_TRANSTAB is forbidden\n");
866 v
->overlap
= get_bits1(gb
); //common
868 v
->s
.resync_marker
= get_bits1(gb
);
869 v
->rangered
= get_bits1(gb
);
870 if (v
->rangered
&& v
->profile
== PROFILE_SIMPLE
)
872 av_log(avctx
, AV_LOG_INFO
,
873 "RANGERED should be set to 0 in simple profile\n");
876 v
->s
.max_b_frames
= avctx
->max_b_frames
= get_bits(gb
, 3); //common
877 v
->quantizer_mode
= get_bits(gb
, 2); //common
879 v
->finterpflag
= get_bits1(gb
); //common
880 v
->res_rtm_flag
= get_bits1(gb
); //reserved
881 if (!v
->res_rtm_flag
)
883 // av_log(avctx, AV_LOG_ERROR,
884 // "0 for reserved RES_RTM_FLAG is forbidden\n");
885 av_log(avctx
, AV_LOG_ERROR
,
886 "Old WMV3 version detected, only I-frames will be decoded\n");
889 //TODO: figure out what they mean (always 0x402F)
890 if(!v
->res_fasttx
) skip_bits(gb
, 16);
891 av_log(avctx
, AV_LOG_DEBUG
,
892 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
893 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
894 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
895 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
896 v
->profile
, v
->frmrtq_postproc
, v
->bitrtq_postproc
,
897 v
->s
.loop_filter
, v
->multires
, v
->fastuvmc
, v
->extended_mv
,
898 v
->rangered
, v
->vstransform
, v
->overlap
, v
->s
.resync_marker
,
899 v
->dquant
, v
->quantizer_mode
, avctx
->max_b_frames
904 static int decode_sequence_header_adv(VC1Context
*v
, GetBitContext
*gb
)
907 v
->level
= get_bits(gb
, 3);
910 av_log(v
->s
.avctx
, AV_LOG_ERROR
, "Reserved LEVEL %i\n",v
->level
);
912 v
->chromaformat
= get_bits(gb
, 2);
913 if (v
->chromaformat
!= 1)
915 av_log(v
->s
.avctx
, AV_LOG_ERROR
,
916 "Only 4:2:0 chroma format supported\n");
921 v
->frmrtq_postproc
= get_bits(gb
, 3); //common
922 // (bitrate-32kbps)/64kbps
923 v
->bitrtq_postproc
= get_bits(gb
, 5); //common
924 v
->postprocflag
= get_bits1(gb
); //common
926 v
->s
.avctx
->coded_width
= (get_bits(gb
, 12) + 1) << 1;
927 v
->s
.avctx
->coded_height
= (get_bits(gb
, 12) + 1) << 1;
928 v
->s
.avctx
->width
= v
->s
.avctx
->coded_width
;
929 v
->s
.avctx
->height
= v
->s
.avctx
->coded_height
;
930 v
->broadcast
= get_bits1(gb
);
931 v
->interlace
= get_bits1(gb
);
932 v
->tfcntrflag
= get_bits1(gb
);
933 v
->finterpflag
= get_bits1(gb
);
934 skip_bits1(gb
); // reserved
936 v
->s
.h_edge_pos
= v
->s
.avctx
->coded_width
;
937 v
->s
.v_edge_pos
= v
->s
.avctx
->coded_height
;
939 av_log(v
->s
.avctx
, AV_LOG_DEBUG
,
940 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
941 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
942 "TFCTRflag=%i, FINTERPflag=%i\n",
943 v
->level
, v
->frmrtq_postproc
, v
->bitrtq_postproc
,
944 v
->s
.loop_filter
, v
->chromaformat
, v
->broadcast
, v
->interlace
,
945 v
->tfcntrflag
, v
->finterpflag
948 v
->psf
= get_bits1(gb
);
949 if(v
->psf
) { //PsF, 6.1.13
950 av_log(v
->s
.avctx
, AV_LOG_ERROR
, "Progressive Segmented Frame mode: not supported (yet)\n");
953 v
->s
.max_b_frames
= v
->s
.avctx
->max_b_frames
= 7;
954 if(get_bits1(gb
)) { //Display Info - decoding is not affected by it
956 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "Display extended info:\n");
957 v
->s
.avctx
->coded_width
= w
= get_bits(gb
, 14) + 1;
958 v
->s
.avctx
->coded_height
= h
= get_bits(gb
, 14) + 1;
959 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "Display dimensions: %ix%i\n", w
, h
);
961 ar
= get_bits(gb
, 4);
963 v
->s
.avctx
->sample_aspect_ratio
= ff_vc1_pixel_aspect
[ar
];
967 v
->s
.avctx
->sample_aspect_ratio
= (AVRational
){w
, h
};
969 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "Aspect: %i:%i\n", v
->s
.avctx
->sample_aspect_ratio
.num
, v
->s
.avctx
->sample_aspect_ratio
.den
);
971 if(get_bits1(gb
)){ //framerate stuff
973 v
->s
.avctx
->time_base
.num
= 32;
974 v
->s
.avctx
->time_base
.den
= get_bits(gb
, 16) + 1;
977 nr
= get_bits(gb
, 8);
978 dr
= get_bits(gb
, 4);
979 if(nr
&& nr
< 8 && dr
&& dr
< 3){
980 v
->s
.avctx
->time_base
.num
= ff_vc1_fps_dr
[dr
- 1];
981 v
->s
.avctx
->time_base
.den
= ff_vc1_fps_nr
[nr
- 1] * 1000;
987 v
->color_prim
= get_bits(gb
, 8);
988 v
->transfer_char
= get_bits(gb
, 8);
989 v
->matrix_coef
= get_bits(gb
, 8);
993 v
->hrd_param_flag
= get_bits1(gb
);
994 if(v
->hrd_param_flag
) {
996 v
->hrd_num_leaky_buckets
= get_bits(gb
, 5);
997 skip_bits(gb
, 4); //bitrate exponent
998 skip_bits(gb
, 4); //buffer size exponent
999 for(i
= 0; i
< v
->hrd_num_leaky_buckets
; i
++) {
1000 skip_bits(gb
, 16); //hrd_rate[n]
1001 skip_bits(gb
, 16); //hrd_buffer[n]
1007 static int decode_entry_point(AVCodecContext
*avctx
, GetBitContext
*gb
)
1009 VC1Context
*v
= avctx
->priv_data
;
1012 av_log(avctx
, AV_LOG_DEBUG
, "Entry point: %08X\n", show_bits_long(gb
, 32));
1013 v
->broken_link
= get_bits1(gb
);
1014 v
->closed_entry
= get_bits1(gb
);
1015 v
->panscanflag
= get_bits1(gb
);
1016 v
->refdist_flag
= get_bits1(gb
);
1017 v
->s
.loop_filter
= get_bits1(gb
);
1018 v
->fastuvmc
= get_bits1(gb
);
1019 v
->extended_mv
= get_bits1(gb
);
1020 v
->dquant
= get_bits(gb
, 2);
1021 v
->vstransform
= get_bits1(gb
);
1022 v
->overlap
= get_bits1(gb
);
1023 v
->quantizer_mode
= get_bits(gb
, 2);
1025 if(v
->hrd_param_flag
){
1026 for(i
= 0; i
< v
->hrd_num_leaky_buckets
; i
++) {
1027 skip_bits(gb
, 8); //hrd_full[n]
1032 avctx
->coded_width
= (get_bits(gb
, 12)+1)<<1;
1033 avctx
->coded_height
= (get_bits(gb
, 12)+1)<<1;
1036 v
->extended_dmv
= get_bits1(gb
);
1037 if((v
->range_mapy_flag
= get_bits1(gb
))) {
1038 av_log(avctx
, AV_LOG_ERROR
, "Luma scaling is not supported, expect wrong picture\n");
1039 v
->range_mapy
= get_bits(gb
, 3);
1041 if((v
->range_mapuv_flag
= get_bits1(gb
))) {
1042 av_log(avctx
, AV_LOG_ERROR
, "Chroma scaling is not supported, expect wrong picture\n");
1043 v
->range_mapuv
= get_bits(gb
, 3);
1046 av_log(avctx
, AV_LOG_DEBUG
, "Entry point info:\n"
1047 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1048 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1049 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1050 v
->broken_link
, v
->closed_entry
, v
->panscanflag
, v
->refdist_flag
, v
->s
.loop_filter
,
1051 v
->fastuvmc
, v
->extended_mv
, v
->dquant
, v
->vstransform
, v
->overlap
, v
->quantizer_mode
);
1056 static int vc1_parse_frame_header(VC1Context
*v
, GetBitContext
* gb
)
1058 int pqindex
, lowquant
, status
;
1060 if(v
->finterpflag
) v
->interpfrm
= get_bits1(gb
);
1061 skip_bits(gb
, 2); //framecnt unused
1063 if (v
->rangered
) v
->rangeredfrm
= get_bits1(gb
);
1064 v
->s
.pict_type
= get_bits1(gb
);
1065 if (v
->s
.avctx
->max_b_frames
) {
1066 if (!v
->s
.pict_type
) {
1067 if (get_bits1(gb
)) v
->s
.pict_type
= FF_I_TYPE
;
1068 else v
->s
.pict_type
= FF_B_TYPE
;
1069 } else v
->s
.pict_type
= FF_P_TYPE
;
1070 } else v
->s
.pict_type
= v
->s
.pict_type
? FF_P_TYPE
: FF_I_TYPE
;
1073 if(v
->s
.pict_type
== FF_B_TYPE
) {
1074 v
->bfraction_lut_index
= get_vlc2(gb
, ff_vc1_bfraction_vlc
.table
, VC1_BFRACTION_VLC_BITS
, 1);
1075 v
->bfraction
= ff_vc1_bfraction_lut
[v
->bfraction_lut_index
];
1076 if(v
->bfraction
== 0) {
1077 v
->s
.pict_type
= FF_BI_TYPE
;
1080 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1081 skip_bits(gb
, 7); // skip buffer fullness
1084 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1086 if(v
->s
.pict_type
== FF_P_TYPE
)
1089 /* Quantizer stuff */
1090 pqindex
= get_bits(gb
, 5);
1091 if(!pqindex
) return -1;
1092 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1093 v
->pq
= ff_vc1_pquant_table
[0][pqindex
];
1095 v
->pq
= ff_vc1_pquant_table
[1][pqindex
];
1098 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1099 v
->pquantizer
= pqindex
< 9;
1100 if (v
->quantizer_mode
== QUANT_NON_UNIFORM
)
1102 v
->pqindex
= pqindex
;
1103 if (pqindex
< 9) v
->halfpq
= get_bits1(gb
);
1105 if (v
->quantizer_mode
== QUANT_FRAME_EXPLICIT
)
1106 v
->pquantizer
= get_bits1(gb
);
1108 if (v
->extended_mv
== 1) v
->mvrange
= get_unary(gb
, 0, 3);
1109 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1110 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1111 v
->range_x
= 1 << (v
->k_x
- 1);
1112 v
->range_y
= 1 << (v
->k_y
- 1);
1113 if (v
->multires
&& v
->s
.pict_type
!= FF_B_TYPE
) v
->respic
= get_bits(gb
, 2);
1115 if(v
->res_x8
&& (v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)){
1116 v
->x8_type
= get_bits1(gb
);
1117 }else v
->x8_type
= 0;
1118 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1119 // (v->s.pict_type == FF_P_TYPE) ? 'P' : ((v->s.pict_type == FF_I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1121 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_P_TYPE
) v
->use_ic
= 0;
1123 switch(v
->s
.pict_type
) {
1125 if (v
->pq
< 5) v
->tt_index
= 0;
1126 else if(v
->pq
< 13) v
->tt_index
= 1;
1127 else v
->tt_index
= 2;
1129 lowquant
= (v
->pq
> 12) ? 0 : 1;
1130 v
->mv_mode
= ff_vc1_mv_pmode_table
[lowquant
][get_unary(gb
, 1, 4)];
1131 if (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
1133 int scale
, shift
, i
;
1134 v
->mv_mode2
= ff_vc1_mv_pmode_table2
[lowquant
][get_unary(gb
, 1, 3)];
1135 v
->lumscale
= get_bits(gb
, 6);
1136 v
->lumshift
= get_bits(gb
, 6);
1138 /* fill lookup tables for intensity compensation */
1141 shift
= (255 - v
->lumshift
* 2) << 6;
1142 if(v
->lumshift
> 31)
1145 scale
= v
->lumscale
+ 32;
1146 if(v
->lumshift
> 31)
1147 shift
= (v
->lumshift
- 64) << 6;
1149 shift
= v
->lumshift
<< 6;
1151 for(i
= 0; i
< 256; i
++) {
1152 v
->luty
[i
] = av_clip_uint8((scale
* i
+ shift
+ 32) >> 6);
1153 v
->lutuv
[i
] = av_clip_uint8((scale
* (i
- 128) + 128*64 + 32) >> 6);
1156 if(v
->mv_mode
== MV_PMODE_1MV_HPEL
|| v
->mv_mode
== MV_PMODE_1MV_HPEL_BILIN
)
1157 v
->s
.quarter_sample
= 0;
1158 else if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
1159 if(v
->mv_mode2
== MV_PMODE_1MV_HPEL
|| v
->mv_mode2
== MV_PMODE_1MV_HPEL_BILIN
)
1160 v
->s
.quarter_sample
= 0;
1162 v
->s
.quarter_sample
= 1;
1164 v
->s
.quarter_sample
= 1;
1165 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
));
1167 if ((v
->mv_mode
== MV_PMODE_INTENSITY_COMP
&&
1168 v
->mv_mode2
== MV_PMODE_MIXED_MV
)
1169 || v
->mv_mode
== MV_PMODE_MIXED_MV
)
1171 status
= bitplane_decoding(v
->mv_type_mb_plane
, &v
->mv_type_is_raw
, v
);
1172 if (status
< 0) return -1;
1173 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB MV Type plane encoding: "
1174 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1176 v
->mv_type_is_raw
= 0;
1177 memset(v
->mv_type_mb_plane
, 0, v
->s
.mb_stride
* v
->s
.mb_height
);
1179 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1180 if (status
< 0) return -1;
1181 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1182 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1184 /* Hopefully this is correct for P frames */
1185 v
->s
.mv_table_index
= get_bits(gb
, 2); //but using ff_vc1_ tables
1186 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1190 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1191 vop_dquant_decoding(v
);
1194 v
->ttfrm
= 0; //FIXME Is that so ?
1197 v
->ttmbf
= get_bits1(gb
);
1200 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1208 if (v
->pq
< 5) v
->tt_index
= 0;
1209 else if(v
->pq
< 13) v
->tt_index
= 1;
1210 else v
->tt_index
= 2;
1212 lowquant
= (v
->pq
> 12) ? 0 : 1;
1213 v
->mv_mode
= get_bits1(gb
) ? MV_PMODE_1MV
: MV_PMODE_1MV_HPEL_BILIN
;
1214 v
->s
.quarter_sample
= (v
->mv_mode
== MV_PMODE_1MV
);
1215 v
->s
.mspel
= v
->s
.quarter_sample
;
1217 status
= bitplane_decoding(v
->direct_mb_plane
, &v
->dmb_is_raw
, v
);
1218 if (status
< 0) return -1;
1219 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Direct Type plane encoding: "
1220 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1221 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1222 if (status
< 0) return -1;
1223 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1224 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1226 v
->s
.mv_table_index
= get_bits(gb
, 2);
1227 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1231 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1232 vop_dquant_decoding(v
);
1238 v
->ttmbf
= get_bits1(gb
);
1241 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1253 v
->c_ac_table_index
= decode012(gb
);
1254 if (v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1256 v
->y_ac_table_index
= decode012(gb
);
1259 v
->s
.dc_table_index
= get_bits1(gb
);
1262 if(v
->s
.pict_type
== FF_BI_TYPE
) {
1263 v
->s
.pict_type
= FF_B_TYPE
;
1269 static int vc1_parse_frame_header_adv(VC1Context
*v
, GetBitContext
* gb
)
1271 int pqindex
, lowquant
;
1274 v
->p_frame_skipped
= 0;
1277 v
->fcm
= decode012(gb
);
1278 if(v
->fcm
) return -1; // interlaced frames/fields are not implemented
1280 switch(get_unary(gb
, 0, 4)) {
1282 v
->s
.pict_type
= FF_P_TYPE
;
1285 v
->s
.pict_type
= FF_B_TYPE
;
1288 v
->s
.pict_type
= FF_I_TYPE
;
1291 v
->s
.pict_type
= FF_BI_TYPE
;
1294 v
->s
.pict_type
= FF_P_TYPE
; // skipped pic
1295 v
->p_frame_skipped
= 1;
1301 if(!v
->interlace
|| v
->psf
) {
1302 v
->rptfrm
= get_bits(gb
, 2);
1304 v
->tff
= get_bits1(gb
);
1305 v
->rptfrm
= get_bits1(gb
);
1308 if(v
->panscanflag
) {
1311 v
->rnd
= get_bits1(gb
);
1313 v
->uvsamp
= get_bits1(gb
);
1314 if(v
->finterpflag
) v
->interpfrm
= get_bits1(gb
);
1315 if(v
->s
.pict_type
== FF_B_TYPE
) {
1316 v
->bfraction_lut_index
= get_vlc2(gb
, ff_vc1_bfraction_vlc
.table
, VC1_BFRACTION_VLC_BITS
, 1);
1317 v
->bfraction
= ff_vc1_bfraction_lut
[v
->bfraction_lut_index
];
1318 if(v
->bfraction
== 0) {
1319 v
->s
.pict_type
= FF_BI_TYPE
; /* XXX: should not happen here */
1322 pqindex
= get_bits(gb
, 5);
1323 if(!pqindex
) return -1;
1324 v
->pqindex
= pqindex
;
1325 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1326 v
->pq
= ff_vc1_pquant_table
[0][pqindex
];
1328 v
->pq
= ff_vc1_pquant_table
[1][pqindex
];
1331 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1332 v
->pquantizer
= pqindex
< 9;
1333 if (v
->quantizer_mode
== QUANT_NON_UNIFORM
)
1335 v
->pqindex
= pqindex
;
1336 if (pqindex
< 9) v
->halfpq
= get_bits1(gb
);
1338 if (v
->quantizer_mode
== QUANT_FRAME_EXPLICIT
)
1339 v
->pquantizer
= get_bits1(gb
);
1341 v
->postproc
= get_bits(gb
, 2);
1343 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_P_TYPE
) v
->use_ic
= 0;
1345 switch(v
->s
.pict_type
) {
1348 status
= bitplane_decoding(v
->acpred_plane
, &v
->acpred_is_raw
, v
);
1349 if (status
< 0) return -1;
1350 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "ACPRED plane encoding: "
1351 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1352 v
->condover
= CONDOVER_NONE
;
1353 if(v
->overlap
&& v
->pq
<= 8) {
1354 v
->condover
= decode012(gb
);
1355 if(v
->condover
== CONDOVER_SELECT
) {
1356 status
= bitplane_decoding(v
->over_flags_plane
, &v
->overflg_is_raw
, v
);
1357 if (status
< 0) return -1;
1358 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "CONDOVER plane encoding: "
1359 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1364 if (v
->extended_mv
) v
->mvrange
= get_unary(gb
, 0, 3);
1365 else v
->mvrange
= 0;
1366 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1367 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1368 v
->range_x
= 1 << (v
->k_x
- 1);
1369 v
->range_y
= 1 << (v
->k_y
- 1);
1371 if (v
->pq
< 5) v
->tt_index
= 0;
1372 else if(v
->pq
< 13) v
->tt_index
= 1;
1373 else v
->tt_index
= 2;
1375 lowquant
= (v
->pq
> 12) ? 0 : 1;
1376 v
->mv_mode
= ff_vc1_mv_pmode_table
[lowquant
][get_unary(gb
, 1, 4)];
1377 if (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
1379 int scale
, shift
, i
;
1380 v
->mv_mode2
= ff_vc1_mv_pmode_table2
[lowquant
][get_unary(gb
, 1, 3)];
1381 v
->lumscale
= get_bits(gb
, 6);
1382 v
->lumshift
= get_bits(gb
, 6);
1383 /* fill lookup tables for intensity compensation */
1386 shift
= (255 - v
->lumshift
* 2) << 6;
1387 if(v
->lumshift
> 31)
1390 scale
= v
->lumscale
+ 32;
1391 if(v
->lumshift
> 31)
1392 shift
= (v
->lumshift
- 64) << 6;
1394 shift
= v
->lumshift
<< 6;
1396 for(i
= 0; i
< 256; i
++) {
1397 v
->luty
[i
] = av_clip_uint8((scale
* i
+ shift
+ 32) >> 6);
1398 v
->lutuv
[i
] = av_clip_uint8((scale
* (i
- 128) + 128*64 + 32) >> 6);
1402 if(v
->mv_mode
== MV_PMODE_1MV_HPEL
|| v
->mv_mode
== MV_PMODE_1MV_HPEL_BILIN
)
1403 v
->s
.quarter_sample
= 0;
1404 else if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
1405 if(v
->mv_mode2
== MV_PMODE_1MV_HPEL
|| v
->mv_mode2
== MV_PMODE_1MV_HPEL_BILIN
)
1406 v
->s
.quarter_sample
= 0;
1408 v
->s
.quarter_sample
= 1;
1410 v
->s
.quarter_sample
= 1;
1411 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
));
1413 if ((v
->mv_mode
== MV_PMODE_INTENSITY_COMP
&&
1414 v
->mv_mode2
== MV_PMODE_MIXED_MV
)
1415 || v
->mv_mode
== MV_PMODE_MIXED_MV
)
1417 status
= bitplane_decoding(v
->mv_type_mb_plane
, &v
->mv_type_is_raw
, v
);
1418 if (status
< 0) return -1;
1419 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB MV Type plane encoding: "
1420 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1422 v
->mv_type_is_raw
= 0;
1423 memset(v
->mv_type_mb_plane
, 0, v
->s
.mb_stride
* v
->s
.mb_height
);
1425 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1426 if (status
< 0) return -1;
1427 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1428 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1430 /* Hopefully this is correct for P frames */
1431 v
->s
.mv_table_index
= get_bits(gb
, 2); //but using ff_vc1_ tables
1432 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1435 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1436 vop_dquant_decoding(v
);
1439 v
->ttfrm
= 0; //FIXME Is that so ?
1442 v
->ttmbf
= get_bits1(gb
);
1445 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1453 if (v
->extended_mv
) v
->mvrange
= get_unary(gb
, 0, 3);
1454 else v
->mvrange
= 0;
1455 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1456 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1457 v
->range_x
= 1 << (v
->k_x
- 1);
1458 v
->range_y
= 1 << (v
->k_y
- 1);
1460 if (v
->pq
< 5) v
->tt_index
= 0;
1461 else if(v
->pq
< 13) v
->tt_index
= 1;
1462 else v
->tt_index
= 2;
1464 lowquant
= (v
->pq
> 12) ? 0 : 1;
1465 v
->mv_mode
= get_bits1(gb
) ? MV_PMODE_1MV
: MV_PMODE_1MV_HPEL_BILIN
;
1466 v
->s
.quarter_sample
= (v
->mv_mode
== MV_PMODE_1MV
);
1467 v
->s
.mspel
= v
->s
.quarter_sample
;
1469 status
= bitplane_decoding(v
->direct_mb_plane
, &v
->dmb_is_raw
, v
);
1470 if (status
< 0) return -1;
1471 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Direct Type plane encoding: "
1472 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1473 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1474 if (status
< 0) return -1;
1475 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1476 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1478 v
->s
.mv_table_index
= get_bits(gb
, 2);
1479 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1483 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1484 vop_dquant_decoding(v
);
1490 v
->ttmbf
= get_bits1(gb
);
1493 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1503 v
->c_ac_table_index
= decode012(gb
);
1504 if (v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1506 v
->y_ac_table_index
= decode012(gb
);
1509 v
->s
.dc_table_index
= get_bits1(gb
);
1510 if ((v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
) && v
->dquant
) {
1511 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1512 vop_dquant_decoding(v
);
1516 if(v
->s
.pict_type
== FF_BI_TYPE
) {
1517 v
->s
.pict_type
= FF_B_TYPE
;
1523 /***********************************************************************/
1525 * @defgroup vc1block VC-1 Block-level functions
1526 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1532 * @brief Get macroblock-level quantizer scale
1534 #define GET_MQUANT() \
1538 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1542 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1546 mqdiff = get_bits(gb, 3); \
1547 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1548 else mquant = get_bits(gb, 5); \
1551 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1552 edges = 1 << v->dqsbedge; \
1553 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1554 edges = (3 << v->dqsbedge) % 15; \
1555 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
1557 if((edges&1) && !s->mb_x) \
1558 mquant = v->altpq; \
1559 if((edges&2) && s->first_slice_line) \
1560 mquant = v->altpq; \
1561 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
1562 mquant = v->altpq; \
1563 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
1564 mquant = v->altpq; \
1568 * @def GET_MVDATA(_dmv_x, _dmv_y)
1569 * @brief Get MV differentials
1570 * @see MVDATA decoding from 8.3.5.2, p(1)20
1571 * @param _dmv_x Horizontal differential for decoded MV
1572 * @param _dmv_y Vertical differential for decoded MV
1574 #define GET_MVDATA(_dmv_x, _dmv_y) \
1575 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table,\
1576 VC1_MV_DIFF_VLC_BITS, 2); \
1579 mb_has_coeffs = 1; \
1582 else mb_has_coeffs = 0; \
1584 if (!index) { _dmv_x = _dmv_y = 0; } \
1585 else if (index == 35) \
1587 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1588 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1590 else if (index == 36) \
1599 if (!s->quarter_sample && index1 == 5) val = 1; \
1601 if(size_table[index1] - val > 0) \
1602 val = get_bits(gb, size_table[index1] - val); \
1604 sign = 0 - (val&1); \
1605 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1608 if (!s->quarter_sample && index1 == 5) val = 1; \
1610 if(size_table[index1] - val > 0) \
1611 val = get_bits(gb, size_table[index1] - val); \
1613 sign = 0 - (val&1); \
1614 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1617 /** Predict and set motion vector
1619 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
)
1621 int xy
, wrap
, off
= 0;
1626 /* scale MV difference to be quad-pel */
1627 dmv_x
<<= 1 - s
->quarter_sample
;
1628 dmv_y
<<= 1 - s
->quarter_sample
;
1630 wrap
= s
->b8_stride
;
1631 xy
= s
->block_index
[n
];
1634 s
->mv
[0][n
][0] = s
->current_picture
.motion_val
[0][xy
][0] = 0;
1635 s
->mv
[0][n
][1] = s
->current_picture
.motion_val
[0][xy
][1] = 0;
1636 s
->current_picture
.motion_val
[1][xy
][0] = 0;
1637 s
->current_picture
.motion_val
[1][xy
][1] = 0;
1638 if(mv1
) { /* duplicate motion data for 1-MV block */
1639 s
->current_picture
.motion_val
[0][xy
+ 1][0] = 0;
1640 s
->current_picture
.motion_val
[0][xy
+ 1][1] = 0;
1641 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = 0;
1642 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = 0;
1643 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][0] = 0;
1644 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][1] = 0;
1645 s
->current_picture
.motion_val
[1][xy
+ 1][0] = 0;
1646 s
->current_picture
.motion_val
[1][xy
+ 1][1] = 0;
1647 s
->current_picture
.motion_val
[1][xy
+ wrap
][0] = 0;
1648 s
->current_picture
.motion_val
[1][xy
+ wrap
][1] = 0;
1649 s
->current_picture
.motion_val
[1][xy
+ wrap
+ 1][0] = 0;
1650 s
->current_picture
.motion_val
[1][xy
+ wrap
+ 1][1] = 0;
1655 C
= s
->current_picture
.motion_val
[0][xy
- 1];
1656 A
= s
->current_picture
.motion_val
[0][xy
- wrap
];
1658 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -1 : 2;
1660 //in 4-MV mode different blocks have different B predictor position
1663 off
= (s
->mb_x
> 0) ? -1 : 1;
1666 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -1 : 1;
1675 B
= s
->current_picture
.motion_val
[0][xy
- wrap
+ off
];
1677 if(!s
->first_slice_line
|| (n
==2 || n
==3)) { // predictor A is not out of bounds
1678 if(s
->mb_width
== 1) {
1682 px
= mid_pred(A
[0], B
[0], C
[0]);
1683 py
= mid_pred(A
[1], B
[1], C
[1]);
1685 } else if(s
->mb_x
|| (n
==1 || n
==3)) { // predictor C is not out of bounds
1691 /* Pullback MV as specified in 8.3.5.3.4 */
1694 qx
= (s
->mb_x
<< 6) + ((n
==1 || n
==3) ? 32 : 0);
1695 qy
= (s
->mb_y
<< 6) + ((n
==2 || n
==3) ? 32 : 0);
1696 X
= (s
->mb_width
<< 6) - 4;
1697 Y
= (s
->mb_height
<< 6) - 4;
1699 if(qx
+ px
< -60) px
= -60 - qx
;
1700 if(qy
+ py
< -60) py
= -60 - qy
;
1702 if(qx
+ px
< -28) px
= -28 - qx
;
1703 if(qy
+ py
< -28) py
= -28 - qy
;
1705 if(qx
+ px
> X
) px
= X
- qx
;
1706 if(qy
+ py
> Y
) py
= Y
- qy
;
1708 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1709 if((!s
->first_slice_line
|| (n
==2 || n
==3)) && (s
->mb_x
|| (n
==1 || n
==3))) {
1710 if(is_intra
[xy
- wrap
])
1711 sum
= FFABS(px
) + FFABS(py
);
1713 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
1715 if(get_bits1(&s
->gb
)) {
1723 if(is_intra
[xy
- 1])
1724 sum
= FFABS(px
) + FFABS(py
);
1726 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
1728 if(get_bits1(&s
->gb
)) {
1738 /* store MV using signed modulus of MV range defined in 4.11 */
1739 s
->mv
[0][n
][0] = s
->current_picture
.motion_val
[0][xy
][0] = ((px
+ dmv_x
+ r_x
) & ((r_x
<< 1) - 1)) - r_x
;
1740 s
->mv
[0][n
][1] = s
->current_picture
.motion_val
[0][xy
][1] = ((py
+ dmv_y
+ r_y
) & ((r_y
<< 1) - 1)) - r_y
;
1741 if(mv1
) { /* duplicate motion data for 1-MV block */
1742 s
->current_picture
.motion_val
[0][xy
+ 1][0] = s
->current_picture
.motion_val
[0][xy
][0];
1743 s
->current_picture
.motion_val
[0][xy
+ 1][1] = s
->current_picture
.motion_val
[0][xy
][1];
1744 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = s
->current_picture
.motion_val
[0][xy
][0];
1745 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = s
->current_picture
.motion_val
[0][xy
][1];
1746 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][0] = s
->current_picture
.motion_val
[0][xy
][0];
1747 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][1] = s
->current_picture
.motion_val
[0][xy
][1];
1751 /** Motion compensation for direct or interpolated blocks in B-frames
1753 static void vc1_interp_mc(VC1Context
*v
)
1755 MpegEncContext
*s
= &v
->s
;
1756 DSPContext
*dsp
= &v
->s
.dsp
;
1757 uint8_t *srcY
, *srcU
, *srcV
;
1758 int dxy
, uvdxy
, mx
, my
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
1760 if(!v
->s
.next_picture
.data
[0])return;
1762 mx
= s
->mv
[1][0][0];
1763 my
= s
->mv
[1][0][1];
1764 uvmx
= (mx
+ ((mx
& 3) == 3)) >> 1;
1765 uvmy
= (my
+ ((my
& 3) == 3)) >> 1;
1767 uvmx
= uvmx
+ ((uvmx
<0)?-(uvmx
&1):(uvmx
&1));
1768 uvmy
= uvmy
+ ((uvmy
<0)?-(uvmy
&1):(uvmy
&1));
1770 srcY
= s
->next_picture
.data
[0];
1771 srcU
= s
->next_picture
.data
[1];
1772 srcV
= s
->next_picture
.data
[2];
1774 src_x
= s
->mb_x
* 16 + (mx
>> 2);
1775 src_y
= s
->mb_y
* 16 + (my
>> 2);
1776 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
1777 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
1779 if(v
->profile
!= PROFILE_ADVANCED
){
1780 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
1781 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
1782 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
1783 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
1785 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
1786 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
1787 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
1788 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
1791 srcY
+= src_y
* s
->linesize
+ src_x
;
1792 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
1793 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
1795 /* for grayscale we should not try to read from unknown area */
1796 if(s
->flags
& CODEC_FLAG_GRAY
) {
1797 srcU
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
1798 srcV
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
1802 || (unsigned)src_x
> s
->h_edge_pos
- (mx
&3) - 16
1803 || (unsigned)src_y
> s
->v_edge_pos
- (my
&3) - 16){
1804 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 19 * s
->linesize
;
1806 srcY
-= s
->mspel
* (1 + s
->linesize
);
1807 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 17+s
->mspel
*2, 17+s
->mspel
*2,
1808 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
1809 srcY
= s
->edge_emu_buffer
;
1810 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, 8+1, 8+1,
1811 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
1812 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
1813 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
1816 /* if we deal with range reduction we need to scale source blocks */
1817 if(v
->rangeredfrm
) {
1819 uint8_t *src
, *src2
;
1822 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
1823 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
1826 src
= srcU
; src2
= srcV
;
1827 for(j
= 0; j
< 9; j
++) {
1828 for(i
= 0; i
< 9; i
++) {
1829 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
1830 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
1832 src
+= s
->uvlinesize
;
1833 src2
+= s
->uvlinesize
;
1836 srcY
+= s
->mspel
* (1 + s
->linesize
);
1840 dxy
= ((my
& 3) << 2) | (mx
& 3);
1841 dsp
->avg_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] , srcY
, s
->linesize
, v
->rnd
);
1842 dsp
->avg_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8, srcY
+ 8, s
->linesize
, v
->rnd
);
1843 srcY
+= s
->linesize
* 8;
1844 dsp
->avg_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8 * s
->linesize
, srcY
, s
->linesize
, v
->rnd
);
1845 dsp
->avg_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8 * s
->linesize
+ 8, srcY
+ 8, s
->linesize
, v
->rnd
);
1847 dxy
= (my
& 2) | ((mx
& 2) >> 1);
1850 dsp
->avg_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
1852 dsp
->avg_no_rnd_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
1855 if(s
->flags
& CODEC_FLAG_GRAY
) return;
1856 /* Chroma MC always uses qpel blilinear */
1857 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
1861 dsp
->avg_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1862 dsp
->avg_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1864 dsp
->avg_no_rnd_vc1_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1865 dsp
->avg_no_rnd_vc1_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1869 static av_always_inline
int scale_mv(int value
, int bfrac
, int inv
, int qs
)
1873 #if B_FRACTION_DEN==256
1877 return 2 * ((value
* n
+ 255) >> 9);
1878 return (value
* n
+ 128) >> 8;
1881 n
-= B_FRACTION_DEN
;
1883 return 2 * ((value
* n
+ B_FRACTION_DEN
- 1) / (2 * B_FRACTION_DEN
));
1884 return (value
* n
+ B_FRACTION_DEN
/2) / B_FRACTION_DEN
;
1888 /** Reconstruct motion vector for B-frame and do motion compensation
1890 static inline void vc1_b_mc(VC1Context
*v
, int dmv_x
[2], int dmv_y
[2], int direct
, int mode
)
1893 v
->mv_mode2
= v
->mv_mode
;
1894 v
->mv_mode
= MV_PMODE_INTENSITY_COMP
;
1899 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1902 if(mode
== BMV_TYPE_INTERPOLATED
) {
1905 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1909 if(v
->use_ic
&& (mode
== BMV_TYPE_BACKWARD
)) v
->mv_mode
= v
->mv_mode2
;
1910 vc1_mc_1mv(v
, (mode
== BMV_TYPE_BACKWARD
));
1911 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1914 static inline void vc1_pred_b_mv(VC1Context
*v
, int dmv_x
[2], int dmv_y
[2], int direct
, int mvtype
)
1916 MpegEncContext
*s
= &v
->s
;
1917 int xy
, wrap
, off
= 0;
1922 const uint8_t *is_intra
= v
->mb_type
[0];
1926 /* scale MV difference to be quad-pel */
1927 dmv_x
[0] <<= 1 - s
->quarter_sample
;
1928 dmv_y
[0] <<= 1 - s
->quarter_sample
;
1929 dmv_x
[1] <<= 1 - s
->quarter_sample
;
1930 dmv_y
[1] <<= 1 - s
->quarter_sample
;
1932 wrap
= s
->b8_stride
;
1933 xy
= s
->block_index
[0];
1936 s
->current_picture
.motion_val
[0][xy
][0] =
1937 s
->current_picture
.motion_val
[0][xy
][1] =
1938 s
->current_picture
.motion_val
[1][xy
][0] =
1939 s
->current_picture
.motion_val
[1][xy
][1] = 0;
1942 s
->mv
[0][0][0] = scale_mv(s
->next_picture
.motion_val
[1][xy
][0], v
->bfraction
, 0, s
->quarter_sample
);
1943 s
->mv
[0][0][1] = scale_mv(s
->next_picture
.motion_val
[1][xy
][1], v
->bfraction
, 0, s
->quarter_sample
);
1944 s
->mv
[1][0][0] = scale_mv(s
->next_picture
.motion_val
[1][xy
][0], v
->bfraction
, 1, s
->quarter_sample
);
1945 s
->mv
[1][0][1] = scale_mv(s
->next_picture
.motion_val
[1][xy
][1], v
->bfraction
, 1, s
->quarter_sample
);
1947 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
1948 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));
1949 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));
1950 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));
1951 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));
1953 s
->current_picture
.motion_val
[0][xy
][0] = s
->mv
[0][0][0];
1954 s
->current_picture
.motion_val
[0][xy
][1] = s
->mv
[0][0][1];
1955 s
->current_picture
.motion_val
[1][xy
][0] = s
->mv
[1][0][0];
1956 s
->current_picture
.motion_val
[1][xy
][1] = s
->mv
[1][0][1];
1960 if((mvtype
== BMV_TYPE_FORWARD
) || (mvtype
== BMV_TYPE_INTERPOLATED
)) {
1961 C
= s
->current_picture
.motion_val
[0][xy
- 2];
1962 A
= s
->current_picture
.motion_val
[0][xy
- wrap
*2];
1963 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -2 : 2;
1964 B
= s
->current_picture
.motion_val
[0][xy
- wrap
*2 + off
];
1966 if(!s
->mb_x
) C
[0] = C
[1] = 0;
1967 if(!s
->first_slice_line
) { // predictor A is not out of bounds
1968 if(s
->mb_width
== 1) {
1972 px
= mid_pred(A
[0], B
[0], C
[0]);
1973 py
= mid_pred(A
[1], B
[1], C
[1]);
1975 } else if(s
->mb_x
) { // predictor C is not out of bounds
1981 /* Pullback MV as specified in 8.3.5.3.4 */
1984 if(v
->profile
< PROFILE_ADVANCED
) {
1985 qx
= (s
->mb_x
<< 5);
1986 qy
= (s
->mb_y
<< 5);
1987 X
= (s
->mb_width
<< 5) - 4;
1988 Y
= (s
->mb_height
<< 5) - 4;
1989 if(qx
+ px
< -28) px
= -28 - qx
;
1990 if(qy
+ py
< -28) py
= -28 - qy
;
1991 if(qx
+ px
> X
) px
= X
- qx
;
1992 if(qy
+ py
> Y
) py
= Y
- qy
;
1994 qx
= (s
->mb_x
<< 6);
1995 qy
= (s
->mb_y
<< 6);
1996 X
= (s
->mb_width
<< 6) - 4;
1997 Y
= (s
->mb_height
<< 6) - 4;
1998 if(qx
+ px
< -60) px
= -60 - qx
;
1999 if(qy
+ py
< -60) py
= -60 - qy
;
2000 if(qx
+ px
> X
) px
= X
- qx
;
2001 if(qy
+ py
> Y
) py
= Y
- qy
;
2004 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2005 if(0 && !s
->first_slice_line
&& s
->mb_x
) {
2006 if(is_intra
[xy
- wrap
])
2007 sum
= FFABS(px
) + FFABS(py
);
2009 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
2011 if(get_bits1(&s
->gb
)) {
2019 if(is_intra
[xy
- 2])
2020 sum
= FFABS(px
) + FFABS(py
);
2022 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
2024 if(get_bits1(&s
->gb
)) {
2034 /* store MV using signed modulus of MV range defined in 4.11 */
2035 s
->mv
[0][0][0] = ((px
+ dmv_x
[0] + r_x
) & ((r_x
<< 1) - 1)) - r_x
;
2036 s
->mv
[0][0][1] = ((py
+ dmv_y
[0] + r_y
) & ((r_y
<< 1) - 1)) - r_y
;
2038 if((mvtype
== BMV_TYPE_BACKWARD
) || (mvtype
== BMV_TYPE_INTERPOLATED
)) {
2039 C
= s
->current_picture
.motion_val
[1][xy
- 2];
2040 A
= s
->current_picture
.motion_val
[1][xy
- wrap
*2];
2041 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -2 : 2;
2042 B
= s
->current_picture
.motion_val
[1][xy
- wrap
*2 + off
];
2044 if(!s
->mb_x
) C
[0] = C
[1] = 0;
2045 if(!s
->first_slice_line
) { // predictor A is not out of bounds
2046 if(s
->mb_width
== 1) {
2050 px
= mid_pred(A
[0], B
[0], C
[0]);
2051 py
= mid_pred(A
[1], B
[1], C
[1]);
2053 } else if(s
->mb_x
) { // predictor C is not out of bounds
2059 /* Pullback MV as specified in 8.3.5.3.4 */
2062 if(v
->profile
< PROFILE_ADVANCED
) {
2063 qx
= (s
->mb_x
<< 5);
2064 qy
= (s
->mb_y
<< 5);
2065 X
= (s
->mb_width
<< 5) - 4;
2066 Y
= (s
->mb_height
<< 5) - 4;
2067 if(qx
+ px
< -28) px
= -28 - qx
;
2068 if(qy
+ py
< -28) py
= -28 - qy
;
2069 if(qx
+ px
> X
) px
= X
- qx
;
2070 if(qy
+ py
> Y
) py
= Y
- qy
;
2072 qx
= (s
->mb_x
<< 6);
2073 qy
= (s
->mb_y
<< 6);
2074 X
= (s
->mb_width
<< 6) - 4;
2075 Y
= (s
->mb_height
<< 6) - 4;
2076 if(qx
+ px
< -60) px
= -60 - qx
;
2077 if(qy
+ py
< -60) py
= -60 - qy
;
2078 if(qx
+ px
> X
) px
= X
- qx
;
2079 if(qy
+ py
> Y
) py
= Y
- qy
;
2082 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2083 if(0 && !s
->first_slice_line
&& s
->mb_x
) {
2084 if(is_intra
[xy
- wrap
])
2085 sum
= FFABS(px
) + FFABS(py
);
2087 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
2089 if(get_bits1(&s
->gb
)) {
2097 if(is_intra
[xy
- 2])
2098 sum
= FFABS(px
) + FFABS(py
);
2100 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
2102 if(get_bits1(&s
->gb
)) {
2112 /* store MV using signed modulus of MV range defined in 4.11 */
2114 s
->mv
[1][0][0] = ((px
+ dmv_x
[1] + r_x
) & ((r_x
<< 1) - 1)) - r_x
;
2115 s
->mv
[1][0][1] = ((py
+ dmv_y
[1] + r_y
) & ((r_y
<< 1) - 1)) - r_y
;
2117 s
->current_picture
.motion_val
[0][xy
][0] = s
->mv
[0][0][0];
2118 s
->current_picture
.motion_val
[0][xy
][1] = s
->mv
[0][0][1];
2119 s
->current_picture
.motion_val
[1][xy
][0] = s
->mv
[1][0][0];
2120 s
->current_picture
.motion_val
[1][xy
][1] = s
->mv
[1][0][1];
2123 /** Get predicted DC value for I-frames only
2124 * prediction dir: left=0, top=1
2125 * @param s MpegEncContext
2126 * @param overlap flag indicating that overlap filtering is used
2127 * @param pq integer part of picture quantizer
2128 * @param[in] n block index in the current MB
2129 * @param dc_val_ptr Pointer to DC predictor
2130 * @param dir_ptr Prediction direction for use in AC prediction
2132 static inline int vc1_i_pred_dc(MpegEncContext
*s
, int overlap
, int pq
, int n
,
2133 int16_t **dc_val_ptr
, int *dir_ptr
)
2135 int a
, b
, c
, wrap
, pred
, scale
;
2137 static const uint16_t dcpred
[32] = {
2138 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2139 114, 102, 93, 85, 79, 73, 68, 64,
2140 60, 57, 54, 51, 49, 47, 45, 43,
2141 41, 39, 38, 37, 35, 34, 33
2144 /* find prediction - wmv3_dc_scale always used here in fact */
2145 if (n
< 4) scale
= s
->y_dc_scale
;
2146 else scale
= s
->c_dc_scale
;
2148 wrap
= s
->block_wrap
[n
];
2149 dc_val
= s
->dc_val
[0] + s
->block_index
[n
];
2155 b
= dc_val
[ - 1 - wrap
];
2156 a
= dc_val
[ - wrap
];
2158 if (pq
< 9 || !overlap
)
2160 /* Set outer values */
2161 if (s
->first_slice_line
&& (n
!=2 && n
!=3)) b
=a
=dcpred
[scale
];
2162 if (s
->mb_x
== 0 && (n
!=1 && n
!=3)) b
=c
=dcpred
[scale
];
2166 /* Set outer values */
2167 if (s
->first_slice_line
&& (n
!=2 && n
!=3)) b
=a
=0;
2168 if (s
->mb_x
== 0 && (n
!=1 && n
!=3)) b
=c
=0;
2171 if (abs(a
- b
) <= abs(b
- c
)) {
2179 /* update predictor */
2180 *dc_val_ptr
= &dc_val
[0];
2185 /** Get predicted DC value
2186 * prediction dir: left=0, top=1
2187 * @param s MpegEncContext
2188 * @param overlap flag indicating that overlap filtering is used
2189 * @param pq integer part of picture quantizer
2190 * @param[in] n block index in the current MB
2191 * @param a_avail flag indicating top block availability
2192 * @param c_avail flag indicating left block availability
2193 * @param dc_val_ptr Pointer to DC predictor
2194 * @param dir_ptr Prediction direction for use in AC prediction
2196 static inline int vc1_pred_dc(MpegEncContext
*s
, int overlap
, int pq
, int n
,
2197 int a_avail
, int c_avail
,
2198 int16_t **dc_val_ptr
, int *dir_ptr
)
2200 int a
, b
, c
, wrap
, pred
, scale
;
2202 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2205 /* find prediction - wmv3_dc_scale always used here in fact */
2206 if (n
< 4) scale
= s
->y_dc_scale
;
2207 else scale
= s
->c_dc_scale
;
2209 wrap
= s
->block_wrap
[n
];
2210 dc_val
= s
->dc_val
[0] + s
->block_index
[n
];
2216 b
= dc_val
[ - 1 - wrap
];
2217 a
= dc_val
[ - wrap
];
2218 /* scale predictors if needed */
2219 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2220 if(c_avail
&& (n
!= 1 && n
!=3)) {
2221 q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2223 c
= (c
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2225 if(a_avail
&& (n
!= 2 && n
!=3)) {
2226 q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2228 a
= (a
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2230 if(a_avail
&& c_avail
&& (n
!=3)) {
2233 if(n
!= 2) off
-= s
->mb_stride
;
2234 q2
= s
->current_picture
.qscale_table
[off
];
2236 b
= (b
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2239 if(a_avail
&& c_avail
) {
2240 if(abs(a
- b
) <= abs(b
- c
)) {
2247 } else if(a_avail
) {
2250 } else if(c_avail
) {
2258 /* update predictor */
2259 *dc_val_ptr
= &dc_val
[0];
2263 /** @} */ // Block group
2266 * @defgroup vc1_std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2267 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2271 static inline int vc1_coded_block_pred(MpegEncContext
* s
, int n
, uint8_t **coded_block_ptr
)
2273 int xy
, wrap
, pred
, a
, b
, c
;
2275 xy
= s
->block_index
[n
];
2276 wrap
= s
->b8_stride
;
2281 a
= s
->coded_block
[xy
- 1 ];
2282 b
= s
->coded_block
[xy
- 1 - wrap
];
2283 c
= s
->coded_block
[xy
- wrap
];
2292 *coded_block_ptr
= &s
->coded_block
[xy
];
2298 * Decode one AC coefficient
2299 * @param v The VC1 context
2300 * @param last Last coefficient
2301 * @param skip How much zero coefficients to skip
2302 * @param value Decoded AC coefficient value
2303 * @param codingset set of VLC to decode data
2306 static void vc1_decode_ac_coeff(VC1Context
*v
, int *last
, int *skip
, int *value
, int codingset
)
2308 GetBitContext
*gb
= &v
->s
.gb
;
2309 int index
, escape
, run
= 0, level
= 0, lst
= 0;
2311 index
= get_vlc2(gb
, ff_vc1_ac_coeff_table
[codingset
].table
, AC_VLC_BITS
, 3);
2312 if (index
!= vc1_ac_sizes
[codingset
] - 1) {
2313 run
= vc1_index_decode_table
[codingset
][index
][0];
2314 level
= vc1_index_decode_table
[codingset
][index
][1];
2315 lst
= index
>= vc1_last_decode_table
[codingset
];
2319 escape
= decode210(gb
);
2321 index
= get_vlc2(gb
, ff_vc1_ac_coeff_table
[codingset
].table
, AC_VLC_BITS
, 3);
2322 run
= vc1_index_decode_table
[codingset
][index
][0];
2323 level
= vc1_index_decode_table
[codingset
][index
][1];
2324 lst
= index
>= vc1_last_decode_table
[codingset
];
2327 level
+= vc1_last_delta_level_table
[codingset
][run
];
2329 level
+= vc1_delta_level_table
[codingset
][run
];
2332 run
+= vc1_last_delta_run_table
[codingset
][level
] + 1;
2334 run
+= vc1_delta_run_table
[codingset
][level
] + 1;
2340 lst
= get_bits1(gb
);
2341 if(v
->s
.esc3_level_length
== 0) {
2342 if(v
->pq
< 8 || v
->dquantfrm
) { // table 59
2343 v
->s
.esc3_level_length
= get_bits(gb
, 3);
2344 if(!v
->s
.esc3_level_length
)
2345 v
->s
.esc3_level_length
= get_bits(gb
, 2) + 8;
2347 v
->s
.esc3_level_length
= get_unary(gb
, 1, 6) + 2;
2349 v
->s
.esc3_run_length
= 3 + get_bits(gb
, 2);
2351 run
= get_bits(gb
, v
->s
.esc3_run_length
);
2352 sign
= get_bits1(gb
);
2353 level
= get_bits(gb
, v
->s
.esc3_level_length
);
2364 /** Decode intra block in intra frames - should be faster than decode_intra_block
2365 * @param v VC1Context
2366 * @param block block to decode
2367 * @param[in] n subblock index
2368 * @param coded are AC coeffs present or not
2369 * @param codingset set of VLC to decode data
2371 static int vc1_decode_i_block(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int codingset
)
2373 GetBitContext
*gb
= &v
->s
.gb
;
2374 MpegEncContext
*s
= &v
->s
;
2375 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2378 int16_t *ac_val
, *ac_val2
;
2381 /* Get DC differential */
2383 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2385 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2388 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2393 if (dcdiff
== 119 /* ESC index value */)
2395 /* TODO: Optimize */
2396 if (v
->pq
== 1) dcdiff
= get_bits(gb
, 10);
2397 else if (v
->pq
== 2) dcdiff
= get_bits(gb
, 9);
2398 else dcdiff
= get_bits(gb
, 8);
2403 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2404 else if (v
->pq
== 2)
2405 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2412 dcdiff
+= vc1_i_pred_dc(&v
->s
, v
->overlap
, v
->pq
, n
, &dc_val
, &dc_pred_dir
);
2415 /* Store the quantized DC coeff, used for prediction */
2417 block
[0] = dcdiff
* s
->y_dc_scale
;
2419 block
[0] = dcdiff
* s
->c_dc_scale
;
2432 int last
= 0, skip
, value
;
2433 const int8_t *zz_table
;
2437 scale
= v
->pq
* 2 + v
->halfpq
;
2441 zz_table
= wmv1_scantable
[2];
2443 zz_table
= wmv1_scantable
[3];
2445 zz_table
= wmv1_scantable
[1];
2447 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2449 if(dc_pred_dir
) //left
2452 ac_val
-= 16 * s
->block_wrap
[n
];
2455 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2459 block
[zz_table
[i
++]] = value
;
2462 /* apply AC prediction if needed */
2464 if(dc_pred_dir
) { //left
2465 for(k
= 1; k
< 8; k
++)
2466 block
[k
<< 3] += ac_val
[k
];
2468 for(k
= 1; k
< 8; k
++)
2469 block
[k
] += ac_val
[k
+ 8];
2472 /* save AC coeffs for further prediction */
2473 for(k
= 1; k
< 8; k
++) {
2474 ac_val2
[k
] = block
[k
<< 3];
2475 ac_val2
[k
+ 8] = block
[k
];
2478 /* scale AC coeffs */
2479 for(k
= 1; k
< 64; k
++)
2483 block
[k
] += (block
[k
] < 0) ? -v
->pq
: v
->pq
;
2486 if(s
->ac_pred
) i
= 63;
2492 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2495 scale
= v
->pq
* 2 + v
->halfpq
;
2496 memset(ac_val2
, 0, 16 * 2);
2497 if(dc_pred_dir
) {//left
2500 memcpy(ac_val2
, ac_val
, 8 * 2);
2502 ac_val
-= 16 * s
->block_wrap
[n
];
2504 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2507 /* apply AC prediction if needed */
2509 if(dc_pred_dir
) { //left
2510 for(k
= 1; k
< 8; k
++) {
2511 block
[k
<< 3] = ac_val
[k
] * scale
;
2512 if(!v
->pquantizer
&& block
[k
<< 3])
2513 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -v
->pq
: v
->pq
;
2516 for(k
= 1; k
< 8; k
++) {
2517 block
[k
] = ac_val
[k
+ 8] * scale
;
2518 if(!v
->pquantizer
&& block
[k
])
2519 block
[k
] += (block
[k
] < 0) ? -v
->pq
: v
->pq
;
2525 s
->block_last_index
[n
] = i
;
2530 /** Decode intra block in intra frames - should be faster than decode_intra_block
2531 * @param v VC1Context
2532 * @param block block to decode
2533 * @param[in] n subblock number
2534 * @param coded are AC coeffs present or not
2535 * @param codingset set of VLC to decode data
2536 * @param mquant quantizer value for this macroblock
2538 static int vc1_decode_i_block_adv(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int codingset
, int mquant
)
2540 GetBitContext
*gb
= &v
->s
.gb
;
2541 MpegEncContext
*s
= &v
->s
;
2542 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2545 int16_t *ac_val
, *ac_val2
;
2547 int a_avail
= v
->a_avail
, c_avail
= v
->c_avail
;
2548 int use_pred
= s
->ac_pred
;
2551 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2553 /* Get DC differential */
2555 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2557 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2560 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2565 if (dcdiff
== 119 /* ESC index value */)
2567 /* TODO: Optimize */
2568 if (mquant
== 1) dcdiff
= get_bits(gb
, 10);
2569 else if (mquant
== 2) dcdiff
= get_bits(gb
, 9);
2570 else dcdiff
= get_bits(gb
, 8);
2575 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2576 else if (mquant
== 2)
2577 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2584 dcdiff
+= vc1_pred_dc(&v
->s
, v
->overlap
, mquant
, n
, v
->a_avail
, v
->c_avail
, &dc_val
, &dc_pred_dir
);
2587 /* Store the quantized DC coeff, used for prediction */
2589 block
[0] = dcdiff
* s
->y_dc_scale
;
2591 block
[0] = dcdiff
* s
->c_dc_scale
;
2600 /* check if AC is needed at all */
2601 if(!a_avail
&& !c_avail
) use_pred
= 0;
2602 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2605 scale
= mquant
* 2 + ((mquant
== v
->pq
) ? v
->halfpq
: 0);
2607 if(dc_pred_dir
) //left
2610 ac_val
-= 16 * s
->block_wrap
[n
];
2612 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2613 if(dc_pred_dir
&& c_avail
&& mb_pos
) q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2614 if(!dc_pred_dir
&& a_avail
&& mb_pos
>= s
->mb_stride
) q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2615 if(dc_pred_dir
&& n
==1) q2
= q1
;
2616 if(!dc_pred_dir
&& n
==2) q2
= q1
;
2620 int last
= 0, skip
, value
;
2621 const int8_t *zz_table
;
2626 zz_table
= wmv1_scantable
[2];
2628 zz_table
= wmv1_scantable
[3];
2630 zz_table
= wmv1_scantable
[1];
2633 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2637 block
[zz_table
[i
++]] = value
;
2640 /* apply AC prediction if needed */
2642 /* scale predictors if needed*/
2644 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2645 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2647 if(dc_pred_dir
) { //left
2648 for(k
= 1; k
< 8; k
++)
2649 block
[k
<< 3] += (ac_val
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2651 for(k
= 1; k
< 8; k
++)
2652 block
[k
] += (ac_val
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2655 if(dc_pred_dir
) { //left
2656 for(k
= 1; k
< 8; k
++)
2657 block
[k
<< 3] += ac_val
[k
];
2659 for(k
= 1; k
< 8; k
++)
2660 block
[k
] += ac_val
[k
+ 8];
2664 /* save AC coeffs for further prediction */
2665 for(k
= 1; k
< 8; k
++) {
2666 ac_val2
[k
] = block
[k
<< 3];
2667 ac_val2
[k
+ 8] = block
[k
];
2670 /* scale AC coeffs */
2671 for(k
= 1; k
< 64; k
++)
2675 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2678 if(use_pred
) i
= 63;
2679 } else { // no AC coeffs
2682 memset(ac_val2
, 0, 16 * 2);
2683 if(dc_pred_dir
) {//left
2685 memcpy(ac_val2
, ac_val
, 8 * 2);
2687 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2688 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2689 for(k
= 1; k
< 8; k
++)
2690 ac_val2
[k
] = (ac_val2
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2695 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2697 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2698 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2699 for(k
= 1; k
< 8; k
++)
2700 ac_val2
[k
+ 8] = (ac_val2
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2705 /* apply AC prediction if needed */
2707 if(dc_pred_dir
) { //left
2708 for(k
= 1; k
< 8; k
++) {
2709 block
[k
<< 3] = ac_val2
[k
] * scale
;
2710 if(!v
->pquantizer
&& block
[k
<< 3])
2711 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -mquant
: mquant
;
2714 for(k
= 1; k
< 8; k
++) {
2715 block
[k
] = ac_val2
[k
+ 8] * scale
;
2716 if(!v
->pquantizer
&& block
[k
])
2717 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2723 s
->block_last_index
[n
] = i
;
2728 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2729 * @param v VC1Context
2730 * @param block block to decode
2731 * @param[in] n subblock index
2732 * @param coded are AC coeffs present or not
2733 * @param mquant block quantizer
2734 * @param codingset set of VLC to decode data
2736 static int vc1_decode_intra_block(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int mquant
, int codingset
)
2738 GetBitContext
*gb
= &v
->s
.gb
;
2739 MpegEncContext
*s
= &v
->s
;
2740 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2743 int16_t *ac_val
, *ac_val2
;
2745 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2746 int a_avail
= v
->a_avail
, c_avail
= v
->c_avail
;
2747 int use_pred
= s
->ac_pred
;
2751 /* XXX: Guard against dumb values of mquant */
2752 mquant
= (mquant
< 1) ? 0 : ( (mquant
>31) ? 31 : mquant
);
2754 /* Set DC scale - y and c use the same */
2755 s
->y_dc_scale
= s
->y_dc_scale_table
[mquant
];
2756 s
->c_dc_scale
= s
->c_dc_scale_table
[mquant
];
2758 /* Get DC differential */
2760 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2762 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2765 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2770 if (dcdiff
== 119 /* ESC index value */)
2772 /* TODO: Optimize */
2773 if (mquant
== 1) dcdiff
= get_bits(gb
, 10);
2774 else if (mquant
== 2) dcdiff
= get_bits(gb
, 9);
2775 else dcdiff
= get_bits(gb
, 8);
2780 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2781 else if (mquant
== 2)
2782 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2789 dcdiff
+= vc1_pred_dc(&v
->s
, v
->overlap
, mquant
, n
, a_avail
, c_avail
, &dc_val
, &dc_pred_dir
);
2792 /* Store the quantized DC coeff, used for prediction */
2795 block
[0] = dcdiff
* s
->y_dc_scale
;
2797 block
[0] = dcdiff
* s
->c_dc_scale
;
2806 /* check if AC is needed at all and adjust direction if needed */
2807 if(!a_avail
) dc_pred_dir
= 1;
2808 if(!c_avail
) dc_pred_dir
= 0;
2809 if(!a_avail
&& !c_avail
) use_pred
= 0;
2810 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2813 scale
= mquant
* 2 + v
->halfpq
;
2815 if(dc_pred_dir
) //left
2818 ac_val
-= 16 * s
->block_wrap
[n
];
2820 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2821 if(dc_pred_dir
&& c_avail
&& mb_pos
) q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2822 if(!dc_pred_dir
&& a_avail
&& mb_pos
>= s
->mb_stride
) q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2823 if(dc_pred_dir
&& n
==1) q2
= q1
;
2824 if(!dc_pred_dir
&& n
==2) q2
= q1
;
2828 int last
= 0, skip
, value
;
2829 const int8_t *zz_table
;
2832 zz_table
= wmv1_scantable
[0];
2835 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2839 block
[zz_table
[i
++]] = value
;
2842 /* apply AC prediction if needed */
2844 /* scale predictors if needed*/
2846 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2847 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2849 if(dc_pred_dir
) { //left
2850 for(k
= 1; k
< 8; k
++)
2851 block
[k
<< 3] += (ac_val
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2853 for(k
= 1; k
< 8; k
++)
2854 block
[k
] += (ac_val
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2857 if(dc_pred_dir
) { //left
2858 for(k
= 1; k
< 8; k
++)
2859 block
[k
<< 3] += ac_val
[k
];
2861 for(k
= 1; k
< 8; k
++)
2862 block
[k
] += ac_val
[k
+ 8];
2866 /* save AC coeffs for further prediction */
2867 for(k
= 1; k
< 8; k
++) {
2868 ac_val2
[k
] = block
[k
<< 3];
2869 ac_val2
[k
+ 8] = block
[k
];
2872 /* scale AC coeffs */
2873 for(k
= 1; k
< 64; k
++)
2877 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2880 if(use_pred
) i
= 63;
2881 } else { // no AC coeffs
2884 memset(ac_val2
, 0, 16 * 2);
2885 if(dc_pred_dir
) {//left
2887 memcpy(ac_val2
, ac_val
, 8 * 2);
2889 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2890 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2891 for(k
= 1; k
< 8; k
++)
2892 ac_val2
[k
] = (ac_val2
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2897 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2899 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2900 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2901 for(k
= 1; k
< 8; k
++)
2902 ac_val2
[k
+ 8] = (ac_val2
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2907 /* apply AC prediction if needed */
2909 if(dc_pred_dir
) { //left
2910 for(k
= 1; k
< 8; k
++) {
2911 block
[k
<< 3] = ac_val2
[k
] * scale
;
2912 if(!v
->pquantizer
&& block
[k
<< 3])
2913 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -mquant
: mquant
;
2916 for(k
= 1; k
< 8; k
++) {
2917 block
[k
] = ac_val2
[k
+ 8] * scale
;
2918 if(!v
->pquantizer
&& block
[k
])
2919 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2925 s
->block_last_index
[n
] = i
;
2932 static int vc1_decode_p_block(VC1Context
*v
, DCTELEM block
[64], int n
, int mquant
, int ttmb
, int first_block
,
2933 uint8_t *dst
, int linesize
, int skip_block
, int apply_filter
, int cbp_top
, int cbp_left
)
2935 MpegEncContext
*s
= &v
->s
;
2936 GetBitContext
*gb
= &s
->gb
;
2939 int scale
, off
, idx
, last
, skip
, value
;
2940 int ttblk
= ttmb
& 7;
2944 ttblk
= ff_vc1_ttblk_to_tt
[v
->tt_index
][get_vlc2(gb
, ff_vc1_ttblk_vlc
[v
->tt_index
].table
, VC1_TTBLK_VLC_BITS
, 1)];
2946 if(ttblk
== TT_4X4
) {
2947 subblkpat
= ~(get_vlc2(gb
, ff_vc1_subblkpat_vlc
[v
->tt_index
].table
, VC1_SUBBLKPAT_VLC_BITS
, 1) + 1);
2949 if((ttblk
!= TT_8X8
&& ttblk
!= TT_4X4
) && (v
->ttmbf
|| (ttmb
!= -1 && (ttmb
& 8) && !first_block
))) {
2950 subblkpat
= decode012(gb
);
2951 if(subblkpat
) subblkpat
^= 3; //swap decoded pattern bits
2952 if(ttblk
== TT_8X4_TOP
|| ttblk
== TT_8X4_BOTTOM
) ttblk
= TT_8X4
;
2953 if(ttblk
== TT_4X8_RIGHT
|| ttblk
== TT_4X8_LEFT
) ttblk
= TT_4X8
;
2955 scale
= 2 * mquant
+ ((v
->pq
== mquant
) ? v
->halfpq
: 0);
2957 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2958 if(ttblk
== TT_8X4_TOP
|| ttblk
== TT_8X4_BOTTOM
) {
2959 subblkpat
= 2 - (ttblk
== TT_8X4_TOP
);
2962 if(ttblk
== TT_4X8_RIGHT
|| ttblk
== TT_4X8_LEFT
) {
2963 subblkpat
= 2 - (ttblk
== TT_4X8_LEFT
);
2972 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
2976 idx
= wmv1_scantable
[0][i
++];
2977 block
[idx
] = value
* scale
;
2979 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
2982 s
->dsp
.vc1_inv_trans_8x8(block
);
2983 s
->dsp
.add_pixels_clamped(block
, dst
, linesize
);
2984 if(apply_filter
&& cbp_top
& 0xC)
2985 s
->dsp
.vc1_v_loop_filter8(dst
, linesize
, v
->pq
);
2986 if(apply_filter
&& cbp_left
& 0xA)
2987 s
->dsp
.vc1_h_loop_filter8(dst
, linesize
, v
->pq
);
2991 pat
= ~subblkpat
& 0xF;
2992 for(j
= 0; j
< 4; j
++) {
2993 last
= subblkpat
& (1 << (3 - j
));
2995 off
= (j
& 1) * 4 + (j
& 2) * 16;
2997 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3001 idx
= ff_vc1_simple_progressive_4x4_zz
[i
++];
3002 block
[idx
+ off
] = value
* scale
;
3004 block
[idx
+ off
] += (block
[idx
+ off
] < 0) ? -mquant
: mquant
;
3006 if(!(subblkpat
& (1 << (3 - j
))) && !skip_block
){
3007 s
->dsp
.vc1_inv_trans_4x4(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, linesize
, block
+ off
);
3008 if(apply_filter
&& (j
&2 ? pat
& (1<<(j
-2)) : (cbp_top
& (1 << (j
+ 2)))))
3009 s
->dsp
.vc1_v_loop_filter4(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, linesize
, v
->pq
);
3010 if(apply_filter
&& (j
&1 ? pat
& (1<<(j
-1)) : (cbp_left
& (1 << (j
+ 1)))))
3011 s
->dsp
.vc1_h_loop_filter4(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, linesize
, v
->pq
);
3016 pat
= ~((subblkpat
& 2)*6 + (subblkpat
& 1)*3) & 0xF;
3017 for(j
= 0; j
< 2; j
++) {
3018 last
= subblkpat
& (1 << (1 - j
));
3022 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3026 idx
= v
->zz_8x4
[i
++]+off
;
3027 block
[idx
] = value
* scale
;
3029 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3031 if(!(subblkpat
& (1 << (1 - j
))) && !skip_block
){
3032 s
->dsp
.vc1_inv_trans_8x4(dst
+ j
*4*linesize
, linesize
, block
+ off
);
3033 if(apply_filter
&& j
? pat
& 0x3 : (cbp_top
& 0xC))
3034 s
->dsp
.vc1_v_loop_filter8(dst
+ j
*4*linesize
, linesize
, v
->pq
);
3035 if(apply_filter
&& cbp_left
& (2 << j
))
3036 s
->dsp
.vc1_h_loop_filter4(dst
+ j
*4*linesize
, linesize
, v
->pq
);
3041 pat
= ~(subblkpat
*5) & 0xF;
3042 for(j
= 0; j
< 2; j
++) {
3043 last
= subblkpat
& (1 << (1 - j
));
3047 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3051 idx
= v
->zz_4x8
[i
++]+off
;
3052 block
[idx
] = value
* scale
;
3054 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3056 if(!(subblkpat
& (1 << (1 - j
))) && !skip_block
){
3057 s
->dsp
.vc1_inv_trans_4x8(dst
+ j
*4, linesize
, block
+ off
);
3058 if(apply_filter
&& cbp_top
& (2 << j
))
3059 s
->dsp
.vc1_v_loop_filter4(dst
+ j
*4, linesize
, v
->pq
);
3060 if(apply_filter
&& j
? pat
& 0x5 : (cbp_left
& 0xA))
3061 s
->dsp
.vc1_h_loop_filter8(dst
+ j
*4, linesize
, v
->pq
);
3069 /** @} */ // Macroblock group
3071 static const int size_table
[6] = { 0, 2, 3, 4, 5, 8 };
3072 static const int offset_table
[6] = { 0, 1, 3, 7, 15, 31 };
3074 /** Decode one P-frame MB (in Simple/Main profile)
3076 static int vc1_decode_p_mb(VC1Context
*v
)
3078 MpegEncContext
*s
= &v
->s
;
3079 GetBitContext
*gb
= &s
->gb
;
3081 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3082 int cbp
; /* cbp decoding stuff */
3083 int mqdiff
, mquant
; /* MB quantization */
3084 int ttmb
= v
->ttfrm
; /* MB Transform type */
3086 int mb_has_coeffs
= 1; /* last_flag */
3087 int dmv_x
, dmv_y
; /* Differential MV components */
3088 int index
, index1
; /* LUT indexes */
3089 int val
, sign
; /* temp values */
3090 int first_block
= 1;
3092 int skipped
, fourmv
;
3093 int block_cbp
= 0, pat
;
3094 int apply_loop_filter
;
3096 mquant
= v
->pq
; /* Loosy initialization */
3098 if (v
->mv_type_is_raw
)
3099 fourmv
= get_bits1(gb
);
3101 fourmv
= v
->mv_type_mb_plane
[mb_pos
];
3103 skipped
= get_bits1(gb
);
3105 skipped
= v
->s
.mbskip_table
[mb_pos
];
3107 s
->dsp
.clear_blocks(s
->block
[0]);
3109 apply_loop_filter
= s
->loop_filter
&& !(s
->avctx
->skip_loop_filter
>= AVDISCARD_NONKEY
);
3110 if (!fourmv
) /* 1MV mode */
3114 GET_MVDATA(dmv_x
, dmv_y
);
3117 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3118 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3120 s
->current_picture
.mb_type
[mb_pos
] = s
->mb_intra
? MB_TYPE_INTRA
: MB_TYPE_16x16
;
3121 vc1_pred_mv(s
, 0, dmv_x
, dmv_y
, 1, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3123 /* FIXME Set DC val for inter block ? */
3124 if (s
->mb_intra
&& !mb_has_coeffs
)
3127 s
->ac_pred
= get_bits1(gb
);
3130 else if (mb_has_coeffs
)
3132 if (s
->mb_intra
) s
->ac_pred
= get_bits1(gb
);
3133 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3141 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3143 if (!v
->ttmbf
&& !s
->mb_intra
&& mb_has_coeffs
)
3144 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
,
3145 VC1_TTMB_VLC_BITS
, 2);
3146 if(!s
->mb_intra
) vc1_mc_1mv(v
, 0);
3150 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3152 val
= ((cbp
>> (5 - i
)) & 1);
3153 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3154 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3156 /* check if prediction blocks A and C are available */
3157 v
->a_avail
= v
->c_avail
= 0;
3158 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3159 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3160 if(i
== 1 || i
== 3 || s
->mb_x
)
3161 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3163 vc1_decode_intra_block(v
, s
->block
[i
], i
, val
, mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3164 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3165 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3166 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3167 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3168 if(v
->pq
>= 9 && v
->overlap
) {
3170 s
->dsp
.vc1_h_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3172 s
->dsp
.vc1_v_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3174 if(apply_loop_filter
&& s
->mb_x
&& s
->mb_x
!= (s
->mb_width
- 1) && s
->mb_y
&& s
->mb_y
!= (s
->mb_height
- 1)){
3175 int left_cbp
, top_cbp
;
3177 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3178 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3180 left_cbp
= (i
& 1) ? (cbp
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3181 top_cbp
= (i
& 2) ? (cbp
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3184 s
->dsp
.vc1_v_loop_filter8(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, v
->pq
);
3186 s
->dsp
.vc1_h_loop_filter8(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, v
->pq
);
3188 block_cbp
|= 0xF << (i
<< 2);
3190 int left_cbp
= 0, top_cbp
= 0, filter
= 0;
3191 if(apply_loop_filter
&& s
->mb_x
&& s
->mb_x
!= (s
->mb_width
- 1) && s
->mb_y
&& s
->mb_y
!= (s
->mb_height
- 1)){
3194 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3195 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3197 left_cbp
= (i
& 1) ? (cbp
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3198 top_cbp
= (i
& 2) ? (cbp
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3201 s
->dsp
.vc1_v_loop_filter8(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, v
->pq
);
3203 s
->dsp
.vc1_h_loop_filter8(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, v
->pq
);
3205 pat
= vc1_decode_p_block(v
, s
->block
[i
], i
, mquant
, ttmb
, first_block
, s
->dest
[dst_idx
] + off
, (i
&4)?s
->uvlinesize
:s
->linesize
, (i
&4) && (s
->flags
& CODEC_FLAG_GRAY
), filter
, left_cbp
, top_cbp
);
3206 block_cbp
|= pat
<< (i
<< 2);
3207 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3215 for(i
= 0; i
< 6; i
++) {
3216 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3217 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3219 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_SKIP
;
3220 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3221 vc1_pred_mv(s
, 0, 0, 0, 1, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3228 if (!skipped
/* unskipped MB */)
3230 int intra_count
= 0, coded_inter
= 0;
3231 int is_intra
[6], is_coded
[6];
3233 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3236 val
= ((cbp
>> (5 - i
)) & 1);
3237 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3244 GET_MVDATA(dmv_x
, dmv_y
);
3246 vc1_pred_mv(s
, i
, dmv_x
, dmv_y
, 0, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3247 if(!s
->mb_intra
) vc1_mc_4mv_luma(v
, i
);
3248 intra_count
+= s
->mb_intra
;
3249 is_intra
[i
] = s
->mb_intra
;
3250 is_coded
[i
] = mb_has_coeffs
;
3253 is_intra
[i
] = (intra_count
>= 3);
3256 if(i
== 4) vc1_mc_4mv_chroma(v
);
3257 v
->mb_type
[0][s
->block_index
[i
]] = is_intra
[i
];
3258 if(!coded_inter
) coded_inter
= !is_intra
[i
] & is_coded
[i
];
3260 // if there are no coded blocks then don't do anything more
3261 if(!intra_count
&& !coded_inter
) return 0;
3264 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3265 /* test if block is intra and has pred */
3270 if(((!s
->first_slice_line
|| (i
==2 || i
==3)) && v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]])
3271 || ((s
->mb_x
|| (i
==1 || i
==3)) && v
->mb_type
[0][s
->block_index
[i
] - 1])) {
3276 if(intrapred
)s
->ac_pred
= get_bits1(gb
);
3277 else s
->ac_pred
= 0;
3279 if (!v
->ttmbf
&& coded_inter
)
3280 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3284 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3285 s
->mb_intra
= is_intra
[i
];
3287 /* check if prediction blocks A and C are available */
3288 v
->a_avail
= v
->c_avail
= 0;
3289 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3290 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3291 if(i
== 1 || i
== 3 || s
->mb_x
)
3292 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3294 vc1_decode_intra_block(v
, s
->block
[i
], i
, is_coded
[i
], mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3295 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3296 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3297 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3298 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, (i
&4)?s
->uvlinesize
:s
->linesize
);
3299 if(v
->pq
>= 9 && v
->overlap
) {
3301 s
->dsp
.vc1_h_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3303 s
->dsp
.vc1_v_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3305 if(v
->s
.loop_filter
&& s
->mb_x
&& s
->mb_x
!= (s
->mb_width
- 1) && s
->mb_y
&& s
->mb_y
!= (s
->mb_height
- 1)){
3306 int left_cbp
, top_cbp
;
3308 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3309 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3311 left_cbp
= (i
& 1) ? (cbp
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3312 top_cbp
= (i
& 2) ? (cbp
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3315 s
->dsp
.vc1_v_loop_filter8(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, v
->pq
);
3317 s
->dsp
.vc1_h_loop_filter8(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, v
->pq
);
3319 block_cbp
|= 0xF << (i
<< 2);
3320 } else if(is_coded
[i
]) {
3321 int left_cbp
= 0, top_cbp
= 0, filter
= 0;
3322 if(v
->s
.loop_filter
&& s
->mb_x
&& s
->mb_x
!= (s
->mb_width
- 1) && s
->mb_y
&& s
->mb_y
!= (s
->mb_height
- 1)){
3325 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3326 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3328 left_cbp
= (i
& 1) ? (cbp
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3329 top_cbp
= (i
& 2) ? (cbp
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3332 s
->dsp
.vc1_v_loop_filter8(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, v
->pq
);
3334 s
->dsp
.vc1_h_loop_filter8(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, v
->pq
);
3336 pat
= vc1_decode_p_block(v
, s
->block
[i
], i
, mquant
, ttmb
, first_block
, s
->dest
[dst_idx
] + off
, (i
&4)?s
->uvlinesize
:s
->linesize
, (i
&4) && (s
->flags
& CODEC_FLAG_GRAY
), filter
, left_cbp
, top_cbp
);
3337 block_cbp
|= pat
<< (i
<< 2);
3338 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3347 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3348 for (i
=0; i
<6; i
++) {
3349 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3350 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3354 vc1_pred_mv(s
, i
, 0, 0, 0, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3355 vc1_mc_4mv_luma(v
, i
);
3357 vc1_mc_4mv_chroma(v
);
3358 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3362 v
->cbp
[s
->mb_x
] = block_cbp
;
3364 /* Should never happen */
3368 /** Decode one B-frame MB (in Main profile)
3370 static void vc1_decode_b_mb(VC1Context
*v
)
3372 MpegEncContext
*s
= &v
->s
;
3373 GetBitContext
*gb
= &s
->gb
;
3375 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3376 int cbp
= 0; /* cbp decoding stuff */
3377 int mqdiff
, mquant
; /* MB quantization */
3378 int ttmb
= v
->ttfrm
; /* MB Transform type */
3379 int mb_has_coeffs
= 0; /* last_flag */
3380 int index
, index1
; /* LUT indexes */
3381 int val
, sign
; /* temp values */
3382 int first_block
= 1;
3384 int skipped
, direct
;
3385 int dmv_x
[2], dmv_y
[2];
3386 int bmvtype
= BMV_TYPE_BACKWARD
;
3388 mquant
= v
->pq
; /* Loosy initialization */
3392 direct
= get_bits1(gb
);
3394 direct
= v
->direct_mb_plane
[mb_pos
];
3396 skipped
= get_bits1(gb
);
3398 skipped
= v
->s
.mbskip_table
[mb_pos
];
3400 s
->dsp
.clear_blocks(s
->block
[0]);
3401 dmv_x
[0] = dmv_x
[1] = dmv_y
[0] = dmv_y
[1] = 0;
3402 for(i
= 0; i
< 6; i
++) {
3403 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3404 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3406 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3410 GET_MVDATA(dmv_x
[0], dmv_y
[0]);
3411 dmv_x
[1] = dmv_x
[0];
3412 dmv_y
[1] = dmv_y
[0];
3414 if(skipped
|| !s
->mb_intra
) {
3415 bmvtype
= decode012(gb
);
3418 bmvtype
= (v
->bfraction
>= (B_FRACTION_DEN
/2)) ? BMV_TYPE_BACKWARD
: BMV_TYPE_FORWARD
;
3421 bmvtype
= (v
->bfraction
>= (B_FRACTION_DEN
/2)) ? BMV_TYPE_FORWARD
: BMV_TYPE_BACKWARD
;
3424 bmvtype
= BMV_TYPE_INTERPOLATED
;
3425 dmv_x
[0] = dmv_y
[0] = 0;
3429 for(i
= 0; i
< 6; i
++)
3430 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3433 if(direct
) bmvtype
= BMV_TYPE_INTERPOLATED
;
3434 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3435 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3439 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3443 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3445 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3446 dmv_x
[0] = dmv_y
[0] = dmv_x
[1] = dmv_y
[1] = 0;
3447 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3448 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3450 if(!mb_has_coeffs
&& !s
->mb_intra
) {
3451 /* no coded blocks - effectively skipped */
3452 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3453 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3456 if(s
->mb_intra
&& !mb_has_coeffs
) {
3458 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3459 s
->ac_pred
= get_bits1(gb
);
3461 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3463 if(bmvtype
== BMV_TYPE_INTERPOLATED
) {
3464 GET_MVDATA(dmv_x
[0], dmv_y
[0]);
3465 if(!mb_has_coeffs
) {
3466 /* interpolated skipped block */
3467 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3468 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3472 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3474 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3477 s
->ac_pred
= get_bits1(gb
);
3478 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3480 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3481 if(!v
->ttmbf
&& !s
->mb_intra
&& mb_has_coeffs
)
3482 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3488 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3490 val
= ((cbp
>> (5 - i
)) & 1);
3491 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3492 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3494 /* check if prediction blocks A and C are available */
3495 v
->a_avail
= v
->c_avail
= 0;
3496 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3497 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3498 if(i
== 1 || i
== 3 || s
->mb_x
)
3499 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3501 vc1_decode_intra_block(v
, s
->block
[i
], i
, val
, mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3502 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3503 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3504 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3505 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3507 vc1_decode_p_block(v
, s
->block
[i
], i
, mquant
, ttmb
, first_block
, s
->dest
[dst_idx
] + off
, (i
&4)?s
->uvlinesize
:s
->linesize
, (i
&4) && (s
->flags
& CODEC_FLAG_GRAY
), 0, 0, 0);
3508 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3514 /** Decode blocks of I-frame
3516 static void vc1_decode_i_blocks(VC1Context
*v
)
3519 MpegEncContext
*s
= &v
->s
;
3524 /* select codingmode used for VLC tables selection */
3525 switch(v
->y_ac_table_index
){
3527 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3530 v
->codingset
= CS_HIGH_MOT_INTRA
;
3533 v
->codingset
= CS_MID_RATE_INTRA
;
3537 switch(v
->c_ac_table_index
){
3539 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3542 v
->codingset2
= CS_HIGH_MOT_INTER
;
3545 v
->codingset2
= CS_MID_RATE_INTER
;
3549 /* Set DC scale - y and c use the same */
3550 s
->y_dc_scale
= s
->y_dc_scale_table
[v
->pq
];
3551 s
->c_dc_scale
= s
->c_dc_scale_table
[v
->pq
];
3554 s
->mb_x
= s
->mb_y
= 0;
3556 s
->first_slice_line
= 1;
3557 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3558 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3559 ff_init_block_index(s
);
3560 ff_update_block_index(s
);
3561 s
->dsp
.clear_blocks(s
->block
[0]);
3562 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_width
;
3563 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_INTRA
;
3564 s
->current_picture
.qscale_table
[mb_pos
] = v
->pq
;
3565 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3566 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3568 // do actual MB decoding and displaying
3569 cbp
= get_vlc2(&v
->s
.gb
, ff_msmp4_mb_i_vlc
.table
, MB_INTRA_VLC_BITS
, 2);
3570 v
->s
.ac_pred
= get_bits1(&v
->s
.gb
);
3572 for(k
= 0; k
< 6; k
++) {
3573 val
= ((cbp
>> (5 - k
)) & 1);
3576 int pred
= vc1_coded_block_pred(&v
->s
, k
, &coded_val
);
3580 cbp
|= val
<< (5 - k
);
3582 vc1_decode_i_block(v
, s
->block
[k
], k
, val
, (k
<4)? v
->codingset
: v
->codingset2
);
3584 s
->dsp
.vc1_inv_trans_8x8(s
->block
[k
]);
3585 if(v
->pq
>= 9 && v
->overlap
) {
3586 for(j
= 0; j
< 64; j
++) s
->block
[k
][j
] += 128;
3590 vc1_put_block(v
, s
->block
);
3591 if(v
->pq
>= 9 && v
->overlap
) {
3593 s
->dsp
.vc1_h_overlap(s
->dest
[0], s
->linesize
);
3594 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3595 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3596 s
->dsp
.vc1_h_overlap(s
->dest
[1], s
->uvlinesize
);
3597 s
->dsp
.vc1_h_overlap(s
->dest
[2], s
->uvlinesize
);
3600 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8, s
->linesize
);
3601 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3602 if(!s
->first_slice_line
) {
3603 s
->dsp
.vc1_v_overlap(s
->dest
[0], s
->linesize
);
3604 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8, s
->linesize
);
3605 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3606 s
->dsp
.vc1_v_overlap(s
->dest
[1], s
->uvlinesize
);
3607 s
->dsp
.vc1_v_overlap(s
->dest
[2], s
->uvlinesize
);
3610 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3611 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3613 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, v
->pq
);
3615 if(get_bits_count(&s
->gb
) > v
->bits
) {
3616 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3617 av_log(s
->avctx
, AV_LOG_ERROR
, "Bits overconsumption: %i > %i\n", get_bits_count(&s
->gb
), v
->bits
);
3621 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3622 s
->first_slice_line
= 0;
3624 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3627 /** Decode blocks of I-frame for advanced profile
3629 static void vc1_decode_i_blocks_adv(VC1Context
*v
)
3632 MpegEncContext
*s
= &v
->s
;
3639 GetBitContext
*gb
= &s
->gb
;
3641 /* select codingmode used for VLC tables selection */
3642 switch(v
->y_ac_table_index
){
3644 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3647 v
->codingset
= CS_HIGH_MOT_INTRA
;
3650 v
->codingset
= CS_MID_RATE_INTRA
;
3654 switch(v
->c_ac_table_index
){
3656 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3659 v
->codingset2
= CS_HIGH_MOT_INTER
;
3662 v
->codingset2
= CS_MID_RATE_INTER
;
3667 s
->mb_x
= s
->mb_y
= 0;
3669 s
->first_slice_line
= 1;
3670 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3671 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3672 ff_init_block_index(s
);
3673 ff_update_block_index(s
);
3674 s
->dsp
.clear_blocks(s
->block
[0]);
3675 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3676 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_INTRA
;
3677 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3678 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3680 // do actual MB decoding and displaying
3681 cbp
= get_vlc2(&v
->s
.gb
, ff_msmp4_mb_i_vlc
.table
, MB_INTRA_VLC_BITS
, 2);
3682 if(v
->acpred_is_raw
)
3683 v
->s
.ac_pred
= get_bits1(&v
->s
.gb
);
3685 v
->s
.ac_pred
= v
->acpred_plane
[mb_pos
];
3687 if(v
->condover
== CONDOVER_SELECT
) {
3688 if(v
->overflg_is_raw
)
3689 overlap
= get_bits1(&v
->s
.gb
);
3691 overlap
= v
->over_flags_plane
[mb_pos
];
3693 overlap
= (v
->condover
== CONDOVER_ALL
);
3697 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3698 /* Set DC scale - y and c use the same */
3699 s
->y_dc_scale
= s
->y_dc_scale_table
[mquant
];
3700 s
->c_dc_scale
= s
->c_dc_scale_table
[mquant
];
3702 for(k
= 0; k
< 6; k
++) {
3703 val
= ((cbp
>> (5 - k
)) & 1);
3706 int pred
= vc1_coded_block_pred(&v
->s
, k
, &coded_val
);
3710 cbp
|= val
<< (5 - k
);
3712 v
->a_avail
= !s
->first_slice_line
|| (k
==2 || k
==3);
3713 v
->c_avail
= !!s
->mb_x
|| (k
==1 || k
==3);
3715 vc1_decode_i_block_adv(v
, s
->block
[k
], k
, val
, (k
<4)? v
->codingset
: v
->codingset2
, mquant
);
3717 s
->dsp
.vc1_inv_trans_8x8(s
->block
[k
]);
3718 for(j
= 0; j
< 64; j
++) s
->block
[k
][j
] += 128;
3721 vc1_put_block(v
, s
->block
);
3724 s
->dsp
.vc1_h_overlap(s
->dest
[0], s
->linesize
);
3725 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3726 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3727 s
->dsp
.vc1_h_overlap(s
->dest
[1], s
->uvlinesize
);
3728 s
->dsp
.vc1_h_overlap(s
->dest
[2], s
->uvlinesize
);
3731 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8, s
->linesize
);
3732 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3733 if(!s
->first_slice_line
) {
3734 s
->dsp
.vc1_v_overlap(s
->dest
[0], s
->linesize
);
3735 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8, s
->linesize
);
3736 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3737 s
->dsp
.vc1_v_overlap(s
->dest
[1], s
->uvlinesize
);
3738 s
->dsp
.vc1_v_overlap(s
->dest
[2], s
->uvlinesize
);
3741 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3742 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3744 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, v
->pq
);
3746 if(get_bits_count(&s
->gb
) > v
->bits
) {
3747 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3748 av_log(s
->avctx
, AV_LOG_ERROR
, "Bits overconsumption: %i > %i\n", get_bits_count(&s
->gb
), v
->bits
);
3752 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3753 s
->first_slice_line
= 0;
3755 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3758 static void vc1_decode_p_blocks(VC1Context
*v
)
3760 MpegEncContext
*s
= &v
->s
;
3762 /* select codingmode used for VLC tables selection */
3763 switch(v
->c_ac_table_index
){
3765 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3768 v
->codingset
= CS_HIGH_MOT_INTRA
;
3771 v
->codingset
= CS_MID_RATE_INTRA
;
3775 switch(v
->c_ac_table_index
){
3777 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3780 v
->codingset2
= CS_HIGH_MOT_INTER
;
3783 v
->codingset2
= CS_MID_RATE_INTER
;
3787 s
->first_slice_line
= 1;
3788 memset(v
->cbp_base
, 0, sizeof(v
->cbp_base
[0])*2*s
->mb_stride
);
3789 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3790 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3791 ff_init_block_index(s
);
3792 ff_update_block_index(s
);
3793 s
->dsp
.clear_blocks(s
->block
[0]);
3796 if(get_bits_count(&s
->gb
) > v
->bits
|| get_bits_count(&s
->gb
) < 0) {
3797 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3798 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
);
3802 memmove(v
->cbp_base
, v
->cbp
, sizeof(v
->cbp_base
[0])*s
->mb_stride
);
3803 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3804 s
->first_slice_line
= 0;
3806 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3809 static void vc1_decode_b_blocks(VC1Context
*v
)
3811 MpegEncContext
*s
= &v
->s
;
3813 /* select codingmode used for VLC tables selection */
3814 switch(v
->c_ac_table_index
){
3816 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3819 v
->codingset
= CS_HIGH_MOT_INTRA
;
3822 v
->codingset
= CS_MID_RATE_INTRA
;
3826 switch(v
->c_ac_table_index
){
3828 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3831 v
->codingset2
= CS_HIGH_MOT_INTER
;
3834 v
->codingset2
= CS_MID_RATE_INTER
;
3838 s
->first_slice_line
= 1;
3839 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3840 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3841 ff_init_block_index(s
);
3842 ff_update_block_index(s
);
3843 s
->dsp
.clear_blocks(s
->block
[0]);
3846 if(get_bits_count(&s
->gb
) > v
->bits
|| get_bits_count(&s
->gb
) < 0) {
3847 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3848 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
);
3851 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, v
->pq
);
3853 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3854 s
->first_slice_line
= 0;
3856 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3859 static void vc1_decode_skip_blocks(VC1Context
*v
)
3861 MpegEncContext
*s
= &v
->s
;
3863 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3864 s
->first_slice_line
= 1;
3865 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3867 ff_init_block_index(s
);
3868 ff_update_block_index(s
);
3869 memcpy(s
->dest
[0], s
->last_picture
.data
[0] + s
->mb_y
* 16 * s
->linesize
, s
->linesize
* 16);
3870 memcpy(s
->dest
[1], s
->last_picture
.data
[1] + s
->mb_y
* 8 * s
->uvlinesize
, s
->uvlinesize
* 8);
3871 memcpy(s
->dest
[2], s
->last_picture
.data
[2] + s
->mb_y
* 8 * s
->uvlinesize
, s
->uvlinesize
* 8);
3872 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3873 s
->first_slice_line
= 0;
3875 s
->pict_type
= FF_P_TYPE
;
3878 static void vc1_decode_blocks(VC1Context
*v
)
3881 v
->s
.esc3_level_length
= 0;
3883 ff_intrax8_decode_picture(&v
->x8
, 2*v
->pq
+v
->halfpq
, v
->pq
*(!v
->pquantizer
) );
3886 switch(v
->s
.pict_type
) {
3888 if(v
->profile
== PROFILE_ADVANCED
)
3889 vc1_decode_i_blocks_adv(v
);
3891 vc1_decode_i_blocks(v
);
3894 if(v
->p_frame_skipped
)
3895 vc1_decode_skip_blocks(v
);
3897 vc1_decode_p_blocks(v
);
3901 if(v
->profile
== PROFILE_ADVANCED
)
3902 vc1_decode_i_blocks_adv(v
);
3904 vc1_decode_i_blocks(v
);
3906 vc1_decode_b_blocks(v
);
3912 /** Find VC-1 marker in buffer
3913 * @return position where next marker starts or end of buffer if no marker found
3915 static av_always_inline
const uint8_t* find_next_marker(const uint8_t *src
, const uint8_t *end
)
3917 uint32_t mrk
= 0xFFFFFFFF;
3919 if(end
-src
< 4) return end
;
3921 mrk
= (mrk
<< 8) | *src
++;
3928 static av_always_inline
int vc1_unescape_buffer(const uint8_t *src
, int size
, uint8_t *dst
)
3933 for(dsize
= 0; dsize
< size
; dsize
++) *dst
++ = *src
++;
3936 for(i
= 0; i
< size
; i
++, src
++) {
3937 if(src
[0] == 3 && i
>= 2 && !src
[-1] && !src
[-2] && i
< size
-1 && src
[1] < 4) {
3938 dst
[dsize
++] = src
[1];
3942 dst
[dsize
++] = *src
;
3947 /** Initialize a VC1/WMV3 decoder
3948 * @todo TODO: Handle VC-1 IDUs (Transport level?)
3949 * @todo TODO: Decypher remaining bits in extra_data
3951 static av_cold
int vc1_decode_init(AVCodecContext
*avctx
)
3953 VC1Context
*v
= avctx
->priv_data
;
3954 MpegEncContext
*s
= &v
->s
;
3957 if (!avctx
->extradata_size
|| !avctx
->extradata
) return -1;
3958 if (!(avctx
->flags
& CODEC_FLAG_GRAY
))
3959 avctx
->pix_fmt
= avctx
->get_format(avctx
, avctx
->codec
->pix_fmts
);
3961 avctx
->pix_fmt
= PIX_FMT_GRAY8
;
3962 avctx
->hwaccel
= ff_find_hwaccel(avctx
->codec
->id
, avctx
->pix_fmt
);
3964 avctx
->flags
|= CODEC_FLAG_EMU_EDGE
;
3965 v
->s
.flags
|= CODEC_FLAG_EMU_EDGE
;
3967 if(avctx
->idct_algo
==FF_IDCT_AUTO
){
3968 avctx
->idct_algo
=FF_IDCT_WMV2
;
3971 if(ff_h263_decode_init(avctx
) < 0)
3973 if (vc1_init_common(v
) < 0) return -1;
3975 avctx
->coded_width
= avctx
->width
;
3976 avctx
->coded_height
= avctx
->height
;
3977 if (avctx
->codec_id
== CODEC_ID_WMV3
)
3981 // looks like WMV3 has a sequence header stored in the extradata
3982 // advanced sequence header may be before the first frame
3983 // the last byte of the extradata is a version number, 1 for the
3984 // samples we can decode
3986 init_get_bits(&gb
, avctx
->extradata
, avctx
->extradata_size
*8);
3988 if (decode_sequence_header(avctx
, &gb
) < 0)
3991 count
= avctx
->extradata_size
*8 - get_bits_count(&gb
);
3994 av_log(avctx
, AV_LOG_INFO
, "Extra data: %i bits left, value: %X\n",
3995 count
, get_bits(&gb
, count
));
3999 av_log(avctx
, AV_LOG_INFO
, "Read %i bits in overflow\n", -count
);
4001 } else { // VC1/WVC1
4002 const uint8_t *start
= avctx
->extradata
;
4003 uint8_t *end
= avctx
->extradata
+ avctx
->extradata_size
;
4004 const uint8_t *next
;
4005 int size
, buf2_size
;
4006 uint8_t *buf2
= NULL
;
4007 int seq_initialized
= 0, ep_initialized
= 0;
4009 if(avctx
->extradata_size
< 16) {
4010 av_log(avctx
, AV_LOG_ERROR
, "Extradata size too small: %i\n", avctx
->extradata_size
);
4014 buf2
= av_mallocz(avctx
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
4015 if(start
[0]) start
++; // in WVC1 extradata first byte is its size
4017 for(; next
< end
; start
= next
){
4018 next
= find_next_marker(start
+ 4, end
);
4019 size
= next
- start
- 4;
4020 if(size
<= 0) continue;
4021 buf2_size
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4022 init_get_bits(&gb
, buf2
, buf2_size
* 8);
4023 switch(AV_RB32(start
)){
4024 case VC1_CODE_SEQHDR
:
4025 if(decode_sequence_header(avctx
, &gb
) < 0){
4029 seq_initialized
= 1;
4031 case VC1_CODE_ENTRYPOINT
:
4032 if(decode_entry_point(avctx
, &gb
) < 0){
4041 if(!seq_initialized
|| !ep_initialized
){
4042 av_log(avctx
, AV_LOG_ERROR
, "Incomplete extradata\n");
4046 avctx
->has_b_frames
= !!(avctx
->max_b_frames
);
4047 s
->low_delay
= !avctx
->has_b_frames
;
4049 s
->mb_width
= (avctx
->coded_width
+15)>>4;
4050 s
->mb_height
= (avctx
->coded_height
+15)>>4;
4052 /* Allocate mb bitplanes */
4053 v
->mv_type_mb_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4054 v
->direct_mb_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4055 v
->acpred_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4056 v
->over_flags_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4058 v
->cbp_base
= av_malloc(sizeof(v
->cbp_base
[0]) * 2 * s
->mb_stride
);
4059 v
->cbp
= v
->cbp_base
+ s
->mb_stride
;
4061 /* allocate block type info in that way so it could be used with s->block_index[] */
4062 v
->mb_type_base
= av_malloc(s
->b8_stride
* (s
->mb_height
* 2 + 1) + s
->mb_stride
* (s
->mb_height
+ 1) * 2);
4063 v
->mb_type
[0] = v
->mb_type_base
+ s
->b8_stride
+ 1;
4064 v
->mb_type
[1] = v
->mb_type_base
+ s
->b8_stride
* (s
->mb_height
* 2 + 1) + s
->mb_stride
+ 1;
4065 v
->mb_type
[2] = v
->mb_type
[1] + s
->mb_stride
* (s
->mb_height
+ 1);
4067 /* Init coded blocks info */
4068 if (v
->profile
== PROFILE_ADVANCED
)
4070 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
4072 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
4076 ff_intrax8_common_init(&v
->x8
,s
);
4081 /** Decode a VC1/WMV3 frame
4082 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4084 static int vc1_decode_frame(AVCodecContext
*avctx
,
4085 void *data
, int *data_size
,
4088 const uint8_t *buf
= avpkt
->data
;
4089 int buf_size
= avpkt
->size
;
4090 VC1Context
*v
= avctx
->priv_data
;
4091 MpegEncContext
*s
= &v
->s
;
4092 AVFrame
*pict
= data
;
4093 uint8_t *buf2
= NULL
;
4094 const uint8_t *buf_start
= buf
;
4096 /* no supplementary picture */
4097 if (buf_size
== 0) {
4098 /* special case for last picture */
4099 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
4100 *pict
= *(AVFrame
*)s
->next_picture_ptr
;
4101 s
->next_picture_ptr
= NULL
;
4103 *data_size
= sizeof(AVFrame
);
4109 /* We need to set current_picture_ptr before reading the header,
4110 * otherwise we cannot store anything in there. */
4111 if(s
->current_picture_ptr
==NULL
|| s
->current_picture_ptr
->data
[0]){
4112 int i
= ff_find_unused_picture(s
, 0);
4113 s
->current_picture_ptr
= &s
->picture
[i
];
4116 if (s
->avctx
->codec
->capabilities
&CODEC_CAP_HWACCEL_VDPAU
){
4117 if (v
->profile
< PROFILE_ADVANCED
)
4118 avctx
->pix_fmt
= PIX_FMT_VDPAU_WMV3
;
4120 avctx
->pix_fmt
= PIX_FMT_VDPAU_VC1
;
4123 //for advanced profile we may need to parse and unescape data
4124 if (avctx
->codec_id
== CODEC_ID_VC1
) {
4126 buf2
= av_mallocz(buf_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
4128 if(IS_MARKER(AV_RB32(buf
))){ /* frame starts with marker and needs to be parsed */
4129 const uint8_t *start
, *end
, *next
;
4133 for(start
= buf
, end
= buf
+ buf_size
; next
< end
; start
= next
){
4134 next
= find_next_marker(start
+ 4, end
);
4135 size
= next
- start
- 4;
4136 if(size
<= 0) continue;
4137 switch(AV_RB32(start
)){
4138 case VC1_CODE_FRAME
:
4139 if (avctx
->hwaccel
||
4140 s
->avctx
->codec
->capabilities
&CODEC_CAP_HWACCEL_VDPAU
)
4142 buf_size2
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4144 case VC1_CODE_ENTRYPOINT
: /* it should be before frame data */
4145 buf_size2
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4146 init_get_bits(&s
->gb
, buf2
, buf_size2
*8);
4147 decode_entry_point(avctx
, &s
->gb
);
4149 case VC1_CODE_SLICE
:
4150 av_log(avctx
, AV_LOG_ERROR
, "Sliced decoding is not implemented (yet)\n");
4155 }else if(v
->interlace
&& ((buf
[0] & 0xC0) == 0xC0)){ /* WVC1 interlaced stores both fields divided by marker */
4156 const uint8_t *divider
;
4158 divider
= find_next_marker(buf
, buf
+ buf_size
);
4159 if((divider
== (buf
+ buf_size
)) || AV_RB32(divider
) != VC1_CODE_FIELD
){
4160 av_log(avctx
, AV_LOG_ERROR
, "Error in WVC1 interlaced frame\n");
4165 buf_size2
= vc1_unescape_buffer(buf
, divider
- buf
, buf2
);
4167 av_free(buf2
);return -1;
4169 buf_size2
= vc1_unescape_buffer(buf
, buf_size
, buf2
);
4171 init_get_bits(&s
->gb
, buf2
, buf_size2
*8);
4173 init_get_bits(&s
->gb
, buf
, buf_size
*8);
4174 // do parse frame header
4175 if(v
->profile
< PROFILE_ADVANCED
) {
4176 if(vc1_parse_frame_header(v
, &s
->gb
) == -1) {
4181 if(vc1_parse_frame_header_adv(v
, &s
->gb
) == -1) {
4187 if(s
->pict_type
!= FF_I_TYPE
&& !v
->res_rtm_flag
){
4193 s
->current_picture
.pict_type
= s
->pict_type
;
4194 s
->current_picture
.key_frame
= s
->pict_type
== FF_I_TYPE
;
4196 /* skip B-frames if we don't have reference frames */
4197 if(s
->last_picture_ptr
==NULL
&& (s
->pict_type
==FF_B_TYPE
|| s
->dropable
)){
4199 return -1;//buf_size;
4201 /* skip b frames if we are in a hurry */
4202 if(avctx
->hurry_up
&& s
->pict_type
==FF_B_TYPE
) return -1;//buf_size;
4203 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& s
->pict_type
==FF_B_TYPE
)
4204 || (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& s
->pict_type
!=FF_I_TYPE
)
4205 || avctx
->skip_frame
>= AVDISCARD_ALL
) {
4209 /* skip everything if we are in a hurry>=5 */
4210 if(avctx
->hurry_up
>=5) {
4212 return -1;//buf_size;
4215 if(s
->next_p_frame_damaged
){
4216 if(s
->pict_type
==FF_B_TYPE
)
4219 s
->next_p_frame_damaged
=0;
4222 if(MPV_frame_start(s
, avctx
) < 0) {
4227 s
->me
.qpel_put
= s
->dsp
.put_qpel_pixels_tab
;
4228 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
4230 if ((CONFIG_VC1_VDPAU_DECODER
|| CONFIG_WMV3_VDPAU_DECODER
)
4231 &&s
->avctx
->codec
->capabilities
&CODEC_CAP_HWACCEL_VDPAU
)
4232 ff_vdpau_vc1_decode_picture(s
, buf_start
, (buf
+ buf_size
) - buf_start
);
4233 else if (avctx
->hwaccel
) {
4234 if (avctx
->hwaccel
->start_frame(avctx
, buf
, buf_size
) < 0)
4236 if (avctx
->hwaccel
->decode_slice(avctx
, buf_start
, (buf
+ buf_size
) - buf_start
) < 0)
4238 if (avctx
->hwaccel
->end_frame(avctx
) < 0)
4241 ff_er_frame_start(s
);
4243 v
->bits
= buf_size
* 8;
4244 vc1_decode_blocks(v
);
4245 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
4246 // if(get_bits_count(&s->gb) > buf_size * 8)
4253 assert(s
->current_picture
.pict_type
== s
->current_picture_ptr
->pict_type
);
4254 assert(s
->current_picture
.pict_type
== s
->pict_type
);
4255 if (s
->pict_type
== FF_B_TYPE
|| s
->low_delay
) {
4256 *pict
= *(AVFrame
*)s
->current_picture_ptr
;
4257 } else if (s
->last_picture_ptr
!= NULL
) {
4258 *pict
= *(AVFrame
*)s
->last_picture_ptr
;
4261 if(s
->last_picture_ptr
|| s
->low_delay
){
4262 *data_size
= sizeof(AVFrame
);
4263 ff_print_debug_info(s
, pict
);
4266 /* Return the Picture timestamp as the frame number */
4267 /* we subtract 1 because it is added on utils.c */
4268 avctx
->frame_number
= s
->picture_number
- 1;
4275 /** Close a VC1/WMV3 decoder
4276 * @warning Initial try at using MpegEncContext stuff
4278 static av_cold
int vc1_decode_end(AVCodecContext
*avctx
)
4280 VC1Context
*v
= avctx
->priv_data
;
4282 av_freep(&v
->hrd_rate
);
4283 av_freep(&v
->hrd_buffer
);
4284 MPV_common_end(&v
->s
);
4285 av_freep(&v
->mv_type_mb_plane
);
4286 av_freep(&v
->direct_mb_plane
);
4287 av_freep(&v
->acpred_plane
);
4288 av_freep(&v
->over_flags_plane
);
4289 av_freep(&v
->mb_type_base
);
4290 av_freep(&v
->cbp_base
);
4291 ff_intrax8_common_end(&v
->x8
);
4296 AVCodec vc1_decoder
= {
4307 .long_name
= NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
4308 .pix_fmts
= ff_hwaccel_pixfmt_list_420
4311 AVCodec wmv3_decoder
= {
4322 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
4323 .pix_fmts
= ff_hwaccel_pixfmt_list_420
4326 #if CONFIG_WMV3_VDPAU_DECODER
4327 AVCodec wmv3_vdpau_decoder
= {
4336 CODEC_CAP_DR1
| CODEC_CAP_DELAY
| CODEC_CAP_HWACCEL_VDPAU
,
4338 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
4339 .pix_fmts
= (enum PixelFormat
[]){PIX_FMT_VDPAU_WMV3
, PIX_FMT_NONE
}
4343 #if CONFIG_VC1_VDPAU_DECODER
4344 AVCodec vc1_vdpau_decoder
= {
4353 CODEC_CAP_DR1
| CODEC_CAP_DELAY
| CODEC_CAP_HWACCEL_VDPAU
,
4355 .long_name
= NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
4356 .pix_fmts
= (enum PixelFormat
[]){PIX_FMT_VDPAU_VC1
, PIX_FMT_NONE
}