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
25 * VC-1 and WMV3 decoder
30 #include "mpegvideo.h"
33 #include "vc1acdata.h"
34 #include "msmpeg4data.h"
36 #include "simple_idct.h"
41 #define MB_INTRA_VLC_BITS 9
45 extern int ff_VDPAU_vc1_decode_picture(MpegEncContext
*s
, AVCodecContext
*avctx
, VC1Context
*v
, const uint8_t *buf
, int buf_size
);
47 static const uint16_t table_mb_intra
[64][2];
50 static const enum PixelFormat pixfmt_vdpau_vc1_simple_420
[] = {
51 PIX_FMT_VDPAU_VC1_SIMPLE
,
53 static const enum PixelFormat pixfmt_vdpau_vc1_main_420
[] = {
54 PIX_FMT_VDPAU_VC1_MAIN
,
56 static const enum PixelFormat pixfmt_vdpau_vc1_advanced_420
[] = {
57 PIX_FMT_VDPAU_VC1_ADVANCED
,
62 * Init VC-1 specific tables and VC1Context members
63 * @param v The VC1Context to initialize
66 static int vc1_init_common(VC1Context
*v
)
71 v
->hrd_rate
= v
->hrd_buffer
= NULL
;
77 init_vlc(&ff_vc1_bfraction_vlc
, VC1_BFRACTION_VLC_BITS
, 23,
78 ff_vc1_bfraction_bits
, 1, 1,
79 ff_vc1_bfraction_codes
, 1, 1, 1);
80 init_vlc(&ff_vc1_norm2_vlc
, VC1_NORM2_VLC_BITS
, 4,
81 ff_vc1_norm2_bits
, 1, 1,
82 ff_vc1_norm2_codes
, 1, 1, 1);
83 init_vlc(&ff_vc1_norm6_vlc
, VC1_NORM6_VLC_BITS
, 64,
84 ff_vc1_norm6_bits
, 1, 1,
85 ff_vc1_norm6_codes
, 2, 2, 1);
86 init_vlc(&ff_vc1_imode_vlc
, VC1_IMODE_VLC_BITS
, 7,
87 ff_vc1_imode_bits
, 1, 1,
88 ff_vc1_imode_codes
, 1, 1, 1);
91 init_vlc(&ff_vc1_ttmb_vlc
[i
], VC1_TTMB_VLC_BITS
, 16,
92 ff_vc1_ttmb_bits
[i
], 1, 1,
93 ff_vc1_ttmb_codes
[i
], 2, 2, 1);
94 init_vlc(&ff_vc1_ttblk_vlc
[i
], VC1_TTBLK_VLC_BITS
, 8,
95 ff_vc1_ttblk_bits
[i
], 1, 1,
96 ff_vc1_ttblk_codes
[i
], 1, 1, 1);
97 init_vlc(&ff_vc1_subblkpat_vlc
[i
], VC1_SUBBLKPAT_VLC_BITS
, 15,
98 ff_vc1_subblkpat_bits
[i
], 1, 1,
99 ff_vc1_subblkpat_codes
[i
], 1, 1, 1);
103 init_vlc(&ff_vc1_4mv_block_pattern_vlc
[i
], VC1_4MV_BLOCK_PATTERN_VLC_BITS
, 16,
104 ff_vc1_4mv_block_pattern_bits
[i
], 1, 1,
105 ff_vc1_4mv_block_pattern_codes
[i
], 1, 1, 1);
106 init_vlc(&ff_vc1_cbpcy_p_vlc
[i
], VC1_CBPCY_P_VLC_BITS
, 64,
107 ff_vc1_cbpcy_p_bits
[i
], 1, 1,
108 ff_vc1_cbpcy_p_codes
[i
], 2, 2, 1);
109 init_vlc(&ff_vc1_mv_diff_vlc
[i
], VC1_MV_DIFF_VLC_BITS
, 73,
110 ff_vc1_mv_diff_bits
[i
], 1, 1,
111 ff_vc1_mv_diff_codes
[i
], 2, 2, 1);
114 init_vlc(&ff_vc1_ac_coeff_table
[i
], AC_VLC_BITS
, vc1_ac_sizes
[i
],
115 &vc1_ac_tables
[i
][0][1], 8, 4,
116 &vc1_ac_tables
[i
][0][0], 8, 4, 1);
117 init_vlc(&ff_msmp4_mb_i_vlc
, MB_INTRA_VLC_BITS
, 64,
118 &ff_msmp4_mb_i_table
[0][1], 4, 2,
119 &ff_msmp4_mb_i_table
[0][0], 4, 2, 1);
124 v
->mvrange
= 0; /* 7.1.1.18, p80 */
129 /***********************************************************************/
131 * @defgroup bitplane VC9 Bitplane decoding
136 /** @addtogroup bitplane
149 /** @} */ //imode defines
151 /** Decode rows by checking if they are skipped
152 * @param plane Buffer to store decoded bits
153 * @param[in] width Width of this buffer
154 * @param[in] height Height of this buffer
155 * @param[in] stride of this buffer
157 static void decode_rowskip(uint8_t* plane
, int width
, int height
, int stride
, GetBitContext
*gb
){
160 for (y
=0; y
<height
; y
++){
161 if (!get_bits1(gb
)) //rowskip
162 memset(plane
, 0, width
);
164 for (x
=0; x
<width
; x
++)
165 plane
[x
] = get_bits1(gb
);
170 /** Decode columns by checking if they are skipped
171 * @param plane Buffer to store decoded bits
172 * @param[in] width Width of this buffer
173 * @param[in] height Height of this buffer
174 * @param[in] stride of this buffer
175 * @todo FIXME: Optimize
177 static void decode_colskip(uint8_t* plane
, int width
, int height
, int stride
, GetBitContext
*gb
){
180 for (x
=0; x
<width
; x
++){
181 if (!get_bits1(gb
)) //colskip
182 for (y
=0; y
<height
; y
++)
185 for (y
=0; y
<height
; y
++)
186 plane
[y
*stride
] = get_bits1(gb
);
191 /** Decode a bitplane's bits
192 * @param bp Bitplane where to store the decode bits
193 * @param v VC-1 context for bit reading and logging
195 * @todo FIXME: Optimize
197 static int bitplane_decoding(uint8_t* data
, int *raw_flag
, VC1Context
*v
)
199 GetBitContext
*gb
= &v
->s
.gb
;
201 int imode
, x
, y
, code
, offset
;
202 uint8_t invert
, *planep
= data
;
203 int width
, height
, stride
;
205 width
= v
->s
.mb_width
;
206 height
= v
->s
.mb_height
;
207 stride
= v
->s
.mb_stride
;
208 invert
= get_bits1(gb
);
209 imode
= get_vlc2(gb
, ff_vc1_imode_vlc
.table
, VC1_IMODE_VLC_BITS
, 1);
215 //Data is actually read in the MB layer (same for all tests == "raw")
216 *raw_flag
= 1; //invert ignored
220 if ((height
* width
) & 1)
222 *planep
++ = get_bits1(gb
);
226 // decode bitplane as one long line
227 for (y
= offset
; y
< height
* width
; y
+= 2) {
228 code
= get_vlc2(gb
, ff_vc1_norm2_vlc
.table
, VC1_NORM2_VLC_BITS
, 1);
229 *planep
++ = code
& 1;
231 if(offset
== width
) {
233 planep
+= stride
- width
;
235 *planep
++ = code
>> 1;
237 if(offset
== width
) {
239 planep
+= stride
- width
;
245 if(!(height
% 3) && (width
% 3)) { // use 2x3 decoding
246 for(y
= 0; y
< height
; y
+= 3) {
247 for(x
= width
& 1; x
< width
; x
+= 2) {
248 code
= get_vlc2(gb
, ff_vc1_norm6_vlc
.table
, VC1_NORM6_VLC_BITS
, 2);
250 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "invalid NORM-6 VLC\n");
253 planep
[x
+ 0] = (code
>> 0) & 1;
254 planep
[x
+ 1] = (code
>> 1) & 1;
255 planep
[x
+ 0 + stride
] = (code
>> 2) & 1;
256 planep
[x
+ 1 + stride
] = (code
>> 3) & 1;
257 planep
[x
+ 0 + stride
* 2] = (code
>> 4) & 1;
258 planep
[x
+ 1 + stride
* 2] = (code
>> 5) & 1;
260 planep
+= stride
* 3;
262 if(width
& 1) decode_colskip(data
, 1, height
, stride
, &v
->s
.gb
);
264 planep
+= (height
& 1) * stride
;
265 for(y
= height
& 1; y
< height
; y
+= 2) {
266 for(x
= width
% 3; x
< width
; x
+= 3) {
267 code
= get_vlc2(gb
, ff_vc1_norm6_vlc
.table
, VC1_NORM6_VLC_BITS
, 2);
269 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "invalid NORM-6 VLC\n");
272 planep
[x
+ 0] = (code
>> 0) & 1;
273 planep
[x
+ 1] = (code
>> 1) & 1;
274 planep
[x
+ 2] = (code
>> 2) & 1;
275 planep
[x
+ 0 + stride
] = (code
>> 3) & 1;
276 planep
[x
+ 1 + stride
] = (code
>> 4) & 1;
277 planep
[x
+ 2 + stride
] = (code
>> 5) & 1;
279 planep
+= stride
* 2;
282 if(x
) decode_colskip(data
, x
, height
, stride
, &v
->s
.gb
);
283 if(height
& 1) decode_rowskip(data
+x
, width
- x
, 1, stride
, &v
->s
.gb
);
287 decode_rowskip(data
, width
, height
, stride
, &v
->s
.gb
);
290 decode_colskip(data
, width
, height
, stride
, &v
->s
.gb
);
295 /* Applying diff operator */
296 if (imode
== IMODE_DIFF2
|| imode
== IMODE_DIFF6
)
300 for (x
=1; x
<width
; x
++)
301 planep
[x
] ^= planep
[x
-1];
302 for (y
=1; y
<height
; y
++)
305 planep
[0] ^= planep
[-stride
];
306 for (x
=1; x
<width
; x
++)
308 if (planep
[x
-1] != planep
[x
-stride
]) planep
[x
] ^= invert
;
309 else planep
[x
] ^= planep
[x
-1];
316 for (x
=0; x
<stride
*height
; x
++) planep
[x
] = !planep
[x
]; //FIXME stride
318 return (imode
<<1) + invert
;
321 /** @} */ //Bitplane group
323 #define FILTSIGN(a) ((a) >= 0 ? 1 : -1)
325 * VC-1 in-loop deblocking filter for one line
326 * @param src source block type
327 * @param pq block quantizer
328 * @return whether other 3 pairs should be filtered or not
331 static int vc1_filter_line(uint8_t* src
, int stride
, int pq
){
332 int a0
, a1
, a2
, a3
, d
, clip
, filt3
= 0;
333 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
335 a0
= (2*(src
[-2*stride
] - src
[ 1*stride
]) - 5*(src
[-1*stride
] - src
[ 0*stride
]) + 4) >> 3;
337 a1
= (2*(src
[-4*stride
] - src
[-1*stride
]) - 5*(src
[-3*stride
] - src
[-2*stride
]) + 4) >> 3;
338 a2
= (2*(src
[ 0*stride
] - src
[ 3*stride
]) - 5*(src
[ 1*stride
] - src
[ 2*stride
]) + 4) >> 3;
339 a3
= FFMIN(FFABS(a1
), FFABS(a2
));
341 d
= 5 * ((a0
>=0 ? a3
: -a3
) - a0
) / 8;
342 clip
= (src
[-1*stride
] - src
[ 0*stride
])/2;
346 d
= av_clip(d
, 0, clip
);
348 d
= av_clip(d
, clip
, 0);
349 src
[-1*stride
] = cm
[src
[-1*stride
] - d
];
350 src
[ 0*stride
] = cm
[src
[ 0*stride
] + d
];
358 * VC-1 in-loop deblocking filter
359 * @param src source block type
360 * @param len edge length to filter (4 or 8 pixels)
361 * @param pq block quantizer
364 static void vc1_loop_filter(uint8_t* src
, int step
, int stride
, int len
, int pq
)
369 for(i
= 0; i
< len
; i
+= 4){
370 filt3
= vc1_filter_line(src
+ 2*step
, stride
, pq
);
372 vc1_filter_line(src
+ 0*step
, stride
, pq
);
373 vc1_filter_line(src
+ 1*step
, stride
, pq
);
374 vc1_filter_line(src
+ 3*step
, stride
, pq
);
380 static void vc1_loop_filter_iblk(MpegEncContext
*s
, int pq
)
383 if(!s
->first_slice_line
)
384 vc1_loop_filter(s
->dest
[0], 1, s
->linesize
, 16, pq
);
385 vc1_loop_filter(s
->dest
[0] + 8*s
->linesize
, 1, s
->linesize
, 16, pq
);
386 for(i
= !s
->mb_x
*8; i
< 16; i
+= 8)
387 vc1_loop_filter(s
->dest
[0] + i
, s
->linesize
, 1, 16, pq
);
388 for(j
= 0; j
< 2; j
++){
389 if(!s
->first_slice_line
)
390 vc1_loop_filter(s
->dest
[j
+1], 1, s
->uvlinesize
, 8, pq
);
392 vc1_loop_filter(s
->dest
[j
+1], s
->uvlinesize
, 1, 8, pq
);
396 /***********************************************************************/
397 /** VOP Dquant decoding
398 * @param v VC-1 Context
400 static int vop_dquant_decoding(VC1Context
*v
)
402 GetBitContext
*gb
= &v
->s
.gb
;
408 pqdiff
= get_bits(gb
, 3);
409 if (pqdiff
== 7) v
->altpq
= get_bits(gb
, 5);
410 else v
->altpq
= v
->pq
+ pqdiff
+ 1;
414 v
->dquantfrm
= get_bits1(gb
);
417 v
->dqprofile
= get_bits(gb
, 2);
418 switch (v
->dqprofile
)
420 case DQPROFILE_SINGLE_EDGE
:
421 case DQPROFILE_DOUBLE_EDGES
:
422 v
->dqsbedge
= get_bits(gb
, 2);
424 case DQPROFILE_ALL_MBS
:
425 v
->dqbilevel
= get_bits1(gb
);
428 default: break; //Forbidden ?
430 if (v
->dqbilevel
|| v
->dqprofile
!= DQPROFILE_ALL_MBS
)
432 pqdiff
= get_bits(gb
, 3);
433 if (pqdiff
== 7) v
->altpq
= get_bits(gb
, 5);
434 else v
->altpq
= v
->pq
+ pqdiff
+ 1;
441 /** Put block onto picture
443 static void vc1_put_block(VC1Context
*v
, DCTELEM block
[6][64])
447 DSPContext
*dsp
= &v
->s
.dsp
;
451 for(k
= 0; k
< 6; k
++)
452 for(j
= 0; j
< 8; j
++)
453 for(i
= 0; i
< 8; i
++)
454 block
[k
][i
+ j
*8] = ((block
[k
][i
+ j
*8] - 128) << 1) + 128;
457 ys
= v
->s
.current_picture
.linesize
[0];
458 us
= v
->s
.current_picture
.linesize
[1];
459 vs
= v
->s
.current_picture
.linesize
[2];
462 dsp
->put_pixels_clamped(block
[0], Y
, ys
);
463 dsp
->put_pixels_clamped(block
[1], Y
+ 8, ys
);
465 dsp
->put_pixels_clamped(block
[2], Y
, ys
);
466 dsp
->put_pixels_clamped(block
[3], Y
+ 8, ys
);
468 if(!(v
->s
.flags
& CODEC_FLAG_GRAY
)) {
469 dsp
->put_pixels_clamped(block
[4], v
->s
.dest
[1], us
);
470 dsp
->put_pixels_clamped(block
[5], v
->s
.dest
[2], vs
);
474 /** Do motion compensation over 1 macroblock
475 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
477 static void vc1_mc_1mv(VC1Context
*v
, int dir
)
479 MpegEncContext
*s
= &v
->s
;
480 DSPContext
*dsp
= &v
->s
.dsp
;
481 uint8_t *srcY
, *srcU
, *srcV
;
482 int dxy
, uvdxy
, mx
, my
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
484 if(!v
->s
.last_picture
.data
[0])return;
486 mx
= s
->mv
[dir
][0][0];
487 my
= s
->mv
[dir
][0][1];
489 // store motion vectors for further use in B frames
490 if(s
->pict_type
== FF_P_TYPE
) {
491 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = mx
;
492 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = my
;
494 uvmx
= (mx
+ ((mx
& 3) == 3)) >> 1;
495 uvmy
= (my
+ ((my
& 3) == 3)) >> 1;
497 uvmx
= uvmx
+ ((uvmx
<0)?(uvmx
&1):-(uvmx
&1));
498 uvmy
= uvmy
+ ((uvmy
<0)?(uvmy
&1):-(uvmy
&1));
501 srcY
= s
->last_picture
.data
[0];
502 srcU
= s
->last_picture
.data
[1];
503 srcV
= s
->last_picture
.data
[2];
505 srcY
= s
->next_picture
.data
[0];
506 srcU
= s
->next_picture
.data
[1];
507 srcV
= s
->next_picture
.data
[2];
510 src_x
= s
->mb_x
* 16 + (mx
>> 2);
511 src_y
= s
->mb_y
* 16 + (my
>> 2);
512 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
513 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
515 if(v
->profile
!= PROFILE_ADVANCED
){
516 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
517 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
518 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
519 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
521 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
522 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
523 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
524 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
527 srcY
+= src_y
* s
->linesize
+ src_x
;
528 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
529 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
531 /* for grayscale we should not try to read from unknown area */
532 if(s
->flags
& CODEC_FLAG_GRAY
) {
533 srcU
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
534 srcV
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
537 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
538 || (unsigned)(src_x
- s
->mspel
) > s
->h_edge_pos
- (mx
&3) - 16 - s
->mspel
*3
539 || (unsigned)(src_y
- s
->mspel
) > s
->v_edge_pos
- (my
&3) - 16 - s
->mspel
*3){
540 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 19 * s
->linesize
;
542 srcY
-= s
->mspel
* (1 + s
->linesize
);
543 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 17+s
->mspel
*2, 17+s
->mspel
*2,
544 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
545 srcY
= s
->edge_emu_buffer
;
546 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, 8+1, 8+1,
547 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
548 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
549 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
552 /* if we deal with range reduction we need to scale source blocks */
558 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
559 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
562 src
= srcU
; src2
= srcV
;
563 for(j
= 0; j
< 9; j
++) {
564 for(i
= 0; i
< 9; i
++) {
565 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
566 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
568 src
+= s
->uvlinesize
;
569 src2
+= s
->uvlinesize
;
572 /* if we deal with intensity compensation we need to scale source blocks */
573 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
578 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
579 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = v
->luty
[src
[i
]];
582 src
= srcU
; src2
= srcV
;
583 for(j
= 0; j
< 9; j
++) {
584 for(i
= 0; i
< 9; i
++) {
585 src
[i
] = v
->lutuv
[src
[i
]];
586 src2
[i
] = v
->lutuv
[src2
[i
]];
588 src
+= s
->uvlinesize
;
589 src2
+= s
->uvlinesize
;
592 srcY
+= s
->mspel
* (1 + s
->linesize
);
596 dxy
= ((my
& 3) << 2) | (mx
& 3);
597 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] , srcY
, s
->linesize
, v
->rnd
);
598 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8, srcY
+ 8, s
->linesize
, v
->rnd
);
599 srcY
+= s
->linesize
* 8;
600 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8 * s
->linesize
, srcY
, s
->linesize
, v
->rnd
);
601 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8 * s
->linesize
+ 8, srcY
+ 8, s
->linesize
, v
->rnd
);
602 } else { // hpel mc - always used for luma
603 dxy
= (my
& 2) | ((mx
& 2) >> 1);
606 dsp
->put_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
608 dsp
->put_no_rnd_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
611 if(s
->flags
& CODEC_FLAG_GRAY
) return;
612 /* Chroma MC always uses qpel bilinear */
613 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
617 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
618 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
620 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
621 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
625 /** Do motion compensation for 4-MV macroblock - luminance block
627 static void vc1_mc_4mv_luma(VC1Context
*v
, int n
)
629 MpegEncContext
*s
= &v
->s
;
630 DSPContext
*dsp
= &v
->s
.dsp
;
632 int dxy
, mx
, my
, src_x
, src_y
;
635 if(!v
->s
.last_picture
.data
[0])return;
638 srcY
= s
->last_picture
.data
[0];
640 off
= s
->linesize
* 4 * (n
&2) + (n
&1) * 8;
642 src_x
= s
->mb_x
* 16 + (n
&1) * 8 + (mx
>> 2);
643 src_y
= s
->mb_y
* 16 + (n
&2) * 4 + (my
>> 2);
645 if(v
->profile
!= PROFILE_ADVANCED
){
646 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
647 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
649 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
650 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
653 srcY
+= src_y
* s
->linesize
+ src_x
;
655 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
656 || (unsigned)(src_x
- s
->mspel
) > s
->h_edge_pos
- (mx
&3) - 8 - s
->mspel
*2
657 || (unsigned)(src_y
- s
->mspel
) > s
->v_edge_pos
- (my
&3) - 8 - s
->mspel
*2){
658 srcY
-= s
->mspel
* (1 + s
->linesize
);
659 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 9+s
->mspel
*2, 9+s
->mspel
*2,
660 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
661 srcY
= s
->edge_emu_buffer
;
662 /* if we deal with range reduction we need to scale source blocks */
668 for(j
= 0; j
< 9 + s
->mspel
*2; j
++) {
669 for(i
= 0; i
< 9 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
673 /* if we deal with intensity compensation we need to scale source blocks */
674 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
679 for(j
= 0; j
< 9 + s
->mspel
*2; j
++) {
680 for(i
= 0; i
< 9 + s
->mspel
*2; i
++) src
[i
] = v
->luty
[src
[i
]];
684 srcY
+= s
->mspel
* (1 + s
->linesize
);
688 dxy
= ((my
& 3) << 2) | (mx
& 3);
689 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, v
->rnd
);
690 } else { // hpel mc - always used for luma
691 dxy
= (my
& 2) | ((mx
& 2) >> 1);
693 dsp
->put_pixels_tab
[1][dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, 8);
695 dsp
->put_no_rnd_pixels_tab
[1][dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, 8);
699 static inline int median4(int a
, int b
, int c
, int d
)
702 if(c
< d
) return (FFMIN(b
, d
) + FFMAX(a
, c
)) / 2;
703 else return (FFMIN(b
, c
) + FFMAX(a
, d
)) / 2;
705 if(c
< d
) return (FFMIN(a
, d
) + FFMAX(b
, c
)) / 2;
706 else return (FFMIN(a
, c
) + FFMAX(b
, d
)) / 2;
711 /** Do motion compensation for 4-MV macroblock - both chroma blocks
713 static void vc1_mc_4mv_chroma(VC1Context
*v
)
715 MpegEncContext
*s
= &v
->s
;
716 DSPContext
*dsp
= &v
->s
.dsp
;
717 uint8_t *srcU
, *srcV
;
718 int uvdxy
, uvmx
, uvmy
, uvsrc_x
, uvsrc_y
;
719 int i
, idx
, tx
= 0, ty
= 0;
720 int mvx
[4], mvy
[4], intra
[4];
721 static const int count
[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
723 if(!v
->s
.last_picture
.data
[0])return;
724 if(s
->flags
& CODEC_FLAG_GRAY
) return;
726 for(i
= 0; i
< 4; i
++) {
727 mvx
[i
] = s
->mv
[0][i
][0];
728 mvy
[i
] = s
->mv
[0][i
][1];
729 intra
[i
] = v
->mb_type
[0][s
->block_index
[i
]];
732 /* calculate chroma MV vector from four luma MVs */
733 idx
= (intra
[3] << 3) | (intra
[2] << 2) | (intra
[1] << 1) | intra
[0];
734 if(!idx
) { // all blocks are inter
735 tx
= median4(mvx
[0], mvx
[1], mvx
[2], mvx
[3]);
736 ty
= median4(mvy
[0], mvy
[1], mvy
[2], mvy
[3]);
737 } else if(count
[idx
] == 1) { // 3 inter blocks
740 tx
= mid_pred(mvx
[1], mvx
[2], mvx
[3]);
741 ty
= mid_pred(mvy
[1], mvy
[2], mvy
[3]);
744 tx
= mid_pred(mvx
[0], mvx
[2], mvx
[3]);
745 ty
= mid_pred(mvy
[0], mvy
[2], mvy
[3]);
748 tx
= mid_pred(mvx
[0], mvx
[1], mvx
[3]);
749 ty
= mid_pred(mvy
[0], mvy
[1], mvy
[3]);
752 tx
= mid_pred(mvx
[0], mvx
[1], mvx
[2]);
753 ty
= mid_pred(mvy
[0], mvy
[1], mvy
[2]);
756 } else if(count
[idx
] == 2) {
758 for(i
=0; i
<3;i
++) if(!intra
[i
]) {t1
= i
; break;}
759 for(i
= t1
+1; i
<4; i
++)if(!intra
[i
]) {t2
= i
; break;}
760 tx
= (mvx
[t1
] + mvx
[t2
]) / 2;
761 ty
= (mvy
[t1
] + mvy
[t2
]) / 2;
763 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
764 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
765 return; //no need to do MC for inter blocks
768 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = tx
;
769 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = ty
;
770 uvmx
= (tx
+ ((tx
&3) == 3)) >> 1;
771 uvmy
= (ty
+ ((ty
&3) == 3)) >> 1;
773 uvmx
= uvmx
+ ((uvmx
<0)?(uvmx
&1):-(uvmx
&1));
774 uvmy
= uvmy
+ ((uvmy
<0)?(uvmy
&1):-(uvmy
&1));
777 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
778 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
780 if(v
->profile
!= PROFILE_ADVANCED
){
781 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
782 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
784 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
785 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
788 srcU
= s
->last_picture
.data
[1] + uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
789 srcV
= s
->last_picture
.data
[2] + uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
790 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
791 || (unsigned)uvsrc_x
> (s
->h_edge_pos
>> 1) - 9
792 || (unsigned)uvsrc_y
> (s
->v_edge_pos
>> 1) - 9){
793 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcU
, s
->uvlinesize
, 8+1, 8+1,
794 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
795 ff_emulated_edge_mc(s
->edge_emu_buffer
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
796 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
797 srcU
= s
->edge_emu_buffer
;
798 srcV
= s
->edge_emu_buffer
+ 16;
800 /* if we deal with range reduction we need to scale source blocks */
805 src
= srcU
; src2
= srcV
;
806 for(j
= 0; j
< 9; j
++) {
807 for(i
= 0; i
< 9; i
++) {
808 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
809 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
811 src
+= s
->uvlinesize
;
812 src2
+= s
->uvlinesize
;
815 /* if we deal with intensity compensation we need to scale source blocks */
816 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
820 src
= srcU
; src2
= srcV
;
821 for(j
= 0; j
< 9; j
++) {
822 for(i
= 0; i
< 9; i
++) {
823 src
[i
] = v
->lutuv
[src
[i
]];
824 src2
[i
] = v
->lutuv
[src2
[i
]];
826 src
+= s
->uvlinesize
;
827 src2
+= s
->uvlinesize
;
832 /* Chroma MC always uses qpel bilinear */
833 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
837 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
838 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
840 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
841 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
846 static int decode_postinit(VC1Context
*v
, AVCodecContext
*avctx
)
848 if (avctx
->pix_fmt
!= PIX_FMT_NONE
){
852 if (avctx
->vdpau_acceleration
) { // VC1
853 if (v
->profile
== 0) {
854 avctx
->pix_fmt
= avctx
->get_format(avctx
, pixfmt_vdpau_vc1_simple_420
);
855 } else if (v
->profile
== 1) {
856 avctx
->pix_fmt
= avctx
->get_format(avctx
, pixfmt_vdpau_vc1_main_420
);
857 } else if (v
->profile
== 3) {
858 avctx
->pix_fmt
= avctx
->get_format(avctx
, pixfmt_vdpau_vc1_advanced_420
);
868 static int decode_sequence_header_adv(VC1Context
*v
, GetBitContext
*gb
);
871 * Decode Simple/Main Profiles sequence header
872 * @see Figure 7-8, p16-17
873 * @param avctx Codec context
874 * @param gb GetBit context initialized from Codec context extra_data
877 static int decode_sequence_header(AVCodecContext
*avctx
, GetBitContext
*gb
)
879 VC1Context
*v
= avctx
->priv_data
;
881 av_log(avctx
, AV_LOG_DEBUG
, "Header: %0X\n", show_bits(gb
, 32));
882 v
->profile
= get_bits(gb
, 2);
883 if (v
->profile
== PROFILE_COMPLEX
)
885 av_log(avctx
, AV_LOG_ERROR
, "WMV3 Complex Profile is not fully supported\n");
888 if (v
->profile
== PROFILE_ADVANCED
)
890 v
->zz_8x4
= ff_vc1_adv_progressive_8x4_zz
;
891 v
->zz_4x8
= ff_vc1_adv_progressive_4x8_zz
;
892 return decode_sequence_header_adv(v
, gb
);
896 v
->zz_8x4
= wmv2_scantableA
;
897 v
->zz_4x8
= wmv2_scantableB
;
898 v
->res_sm
= get_bits(gb
, 2); //reserved
901 av_log(avctx
, AV_LOG_ERROR
,
902 "Reserved RES_SM=%i is forbidden\n", v
->res_sm
);
908 v
->frmrtq_postproc
= get_bits(gb
, 3); //common
909 // (bitrate-32kbps)/64kbps
910 v
->bitrtq_postproc
= get_bits(gb
, 5); //common
911 v
->s
.loop_filter
= get_bits1(gb
); //common
912 if(v
->s
.loop_filter
== 1 && v
->profile
== PROFILE_SIMPLE
)
914 av_log(avctx
, AV_LOG_ERROR
,
915 "LOOPFILTER shell not be enabled in simple profile\n");
917 if(v
->s
.avctx
->skip_loop_filter
>= AVDISCARD_ALL
)
918 v
->s
.loop_filter
= 0;
920 v
->res_x8
= get_bits1(gb
); //reserved
921 v
->multires
= get_bits1(gb
);
922 v
->res_fasttx
= get_bits1(gb
);
925 v
->s
.dsp
.vc1_inv_trans_8x8
= ff_simple_idct
;
926 v
->s
.dsp
.vc1_inv_trans_8x4
= ff_simple_idct84_add
;
927 v
->s
.dsp
.vc1_inv_trans_4x8
= ff_simple_idct48_add
;
928 v
->s
.dsp
.vc1_inv_trans_4x4
= ff_simple_idct44_add
;
931 v
->fastuvmc
= get_bits1(gb
); //common
932 if (!v
->profile
&& !v
->fastuvmc
)
934 av_log(avctx
, AV_LOG_ERROR
,
935 "FASTUVMC unavailable in Simple Profile\n");
938 v
->extended_mv
= get_bits1(gb
); //common
939 if (!v
->profile
&& v
->extended_mv
)
941 av_log(avctx
, AV_LOG_ERROR
,
942 "Extended MVs unavailable in Simple Profile\n");
945 v
->dquant
= get_bits(gb
, 2); //common
946 v
->vstransform
= get_bits1(gb
); //common
948 v
->res_transtab
= get_bits1(gb
);
951 av_log(avctx
, AV_LOG_ERROR
,
952 "1 for reserved RES_TRANSTAB is forbidden\n");
956 v
->overlap
= get_bits1(gb
); //common
958 v
->s
.resync_marker
= get_bits1(gb
);
959 v
->rangered
= get_bits1(gb
);
960 if (v
->rangered
&& v
->profile
== PROFILE_SIMPLE
)
962 av_log(avctx
, AV_LOG_INFO
,
963 "RANGERED should be set to 0 in simple profile\n");
966 v
->s
.max_b_frames
= avctx
->max_b_frames
= get_bits(gb
, 3); //common
967 v
->quantizer_mode
= get_bits(gb
, 2); //common
969 v
->finterpflag
= get_bits1(gb
); //common
970 v
->res_rtm_flag
= get_bits1(gb
); //reserved
971 if (!v
->res_rtm_flag
)
973 // av_log(avctx, AV_LOG_ERROR,
974 // "0 for reserved RES_RTM_FLAG is forbidden\n");
975 av_log(avctx
, AV_LOG_ERROR
,
976 "Old WMV3 version detected, only I-frames will be decoded\n");
979 //TODO: figure out what they mean (always 0x402F)
980 if(!v
->res_fasttx
) skip_bits(gb
, 16);
981 av_log(avctx
, AV_LOG_DEBUG
,
982 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
983 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
984 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
985 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
986 v
->profile
, v
->frmrtq_postproc
, v
->bitrtq_postproc
,
987 v
->s
.loop_filter
, v
->multires
, v
->fastuvmc
, v
->extended_mv
,
988 v
->rangered
, v
->vstransform
, v
->overlap
, v
->s
.resync_marker
,
989 v
->dquant
, v
->quantizer_mode
, avctx
->max_b_frames
994 static int decode_sequence_header_adv(VC1Context
*v
, GetBitContext
*gb
)
997 v
->level
= get_bits(gb
, 3);
1000 av_log(v
->s
.avctx
, AV_LOG_ERROR
, "Reserved LEVEL %i\n",v
->level
);
1002 v
->chromaformat
= get_bits(gb
, 2);
1003 if (v
->chromaformat
!= 1)
1005 av_log(v
->s
.avctx
, AV_LOG_ERROR
,
1006 "Only 4:2:0 chroma format supported\n");
1011 v
->frmrtq_postproc
= get_bits(gb
, 3); //common
1012 // (bitrate-32kbps)/64kbps
1013 v
->bitrtq_postproc
= get_bits(gb
, 5); //common
1014 v
->postprocflag
= get_bits1(gb
); //common
1016 v
->s
.avctx
->coded_width
= (get_bits(gb
, 12) + 1) << 1;
1017 v
->s
.avctx
->coded_height
= (get_bits(gb
, 12) + 1) << 1;
1018 v
->s
.avctx
->width
= v
->s
.avctx
->coded_width
;
1019 v
->s
.avctx
->height
= v
->s
.avctx
->coded_height
;
1020 v
->broadcast
= get_bits1(gb
);
1021 v
->interlace
= get_bits1(gb
);
1022 v
->tfcntrflag
= get_bits1(gb
);
1023 v
->finterpflag
= get_bits1(gb
);
1024 skip_bits1(gb
); // reserved
1026 v
->s
.h_edge_pos
= v
->s
.avctx
->coded_width
;
1027 v
->s
.v_edge_pos
= v
->s
.avctx
->coded_height
;
1029 av_log(v
->s
.avctx
, AV_LOG_DEBUG
,
1030 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1031 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
1032 "TFCTRflag=%i, FINTERPflag=%i\n",
1033 v
->level
, v
->frmrtq_postproc
, v
->bitrtq_postproc
,
1034 v
->s
.loop_filter
, v
->chromaformat
, v
->broadcast
, v
->interlace
,
1035 v
->tfcntrflag
, v
->finterpflag
1038 v
->psf
= get_bits1(gb
);
1039 if(v
->psf
) { //PsF, 6.1.13
1040 av_log(v
->s
.avctx
, AV_LOG_ERROR
, "Progressive Segmented Frame mode: not supported (yet)\n");
1043 v
->s
.max_b_frames
= v
->s
.avctx
->max_b_frames
= 7;
1044 if(get_bits1(gb
)) { //Display Info - decoding is not affected by it
1046 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "Display extended info:\n");
1047 // FIXME: The w/h parsed here are the *display* width/height, not the
1048 // coded width/height. Ideally, we should make the commented
1049 // assignments below, but that causes problems:
1050 // * The SW decoder in this file experiences errors, because it
1051 // assumes these assigned values are the coded size:
1052 // [vc1 @ 0x86f2130]concealing 150 DC, 150 AC, 150 MV errors
1053 // * VDPAU also assumes these are the coded size, since this is the
1054 // only size passed to vo_vdpau.c:config(). This causes errors
1055 // during the decode process.
1056 // However, simply removing these assignments is not the complete fix,
1057 // because without them, the stream is displayed at its coded size,
1058 // not this requested display size. Ideally, setting:
1059 // sample_aspect_ratio = (AVRational){w, h}
1060 // in the case when ar is not present/set would persuade other modules
1061 // to scale to this requested size. However, sample_aspect_ratio
1062 // appears to be completely ignored elsewhere.
1063 /*v->s.avctx->width = v->s.width =*/ w
= get_bits(gb
, 14) + 1;
1064 /*v->s.avctx->height = v->s.height =*/ h
= get_bits(gb
, 14) + 1;
1065 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "Display dimensions: %ix%i\n", w
, h
);
1067 ar
= get_bits(gb
, 4);
1069 v
->s
.avctx
->sample_aspect_ratio
= ff_vc1_pixel_aspect
[ar
];
1071 w
= get_bits(gb
, 8);
1072 h
= get_bits(gb
, 8);
1073 v
->s
.avctx
->sample_aspect_ratio
= (AVRational
){w
, h
};
1076 if(get_bits1(gb
)){ //framerate stuff
1078 v
->s
.avctx
->time_base
.num
= 32;
1079 v
->s
.avctx
->time_base
.den
= get_bits(gb
, 16) + 1;
1082 nr
= get_bits(gb
, 8);
1083 dr
= get_bits(gb
, 4);
1084 if(nr
&& nr
< 8 && dr
&& dr
< 3){
1085 v
->s
.avctx
->time_base
.num
= ff_vc1_fps_dr
[dr
- 1];
1086 v
->s
.avctx
->time_base
.den
= ff_vc1_fps_nr
[nr
- 1] * 1000;
1092 v
->color_prim
= get_bits(gb
, 8);
1093 v
->transfer_char
= get_bits(gb
, 8);
1094 v
->matrix_coef
= get_bits(gb
, 8);
1098 v
->hrd_param_flag
= get_bits1(gb
);
1099 if(v
->hrd_param_flag
) {
1101 v
->hrd_num_leaky_buckets
= get_bits(gb
, 5);
1102 skip_bits(gb
, 4); //bitrate exponent
1103 skip_bits(gb
, 4); //buffer size exponent
1104 for(i
= 0; i
< v
->hrd_num_leaky_buckets
; i
++) {
1105 skip_bits(gb
, 16); //hrd_rate[n]
1106 skip_bits(gb
, 16); //hrd_buffer[n]
1112 static int decode_entry_point(AVCodecContext
*avctx
, GetBitContext
*gb
)
1114 VC1Context
*v
= avctx
->priv_data
;
1115 int i
, blink
, clentry
;
1117 av_log(avctx
, AV_LOG_DEBUG
, "Entry point: %08X\n", show_bits_long(gb
, 32));
1118 blink
= get_bits1(gb
); // broken link
1119 clentry
= get_bits1(gb
); // closed entry
1120 v
->panscanflag
= get_bits1(gb
);
1121 v
->refdist_flag
= get_bits1(gb
);
1122 v
->s
.loop_filter
= get_bits1(gb
);
1123 v
->fastuvmc
= get_bits1(gb
);
1124 v
->extended_mv
= get_bits1(gb
);
1125 v
->dquant
= get_bits(gb
, 2);
1126 v
->vstransform
= get_bits1(gb
);
1127 v
->overlap
= get_bits1(gb
);
1128 v
->quantizer_mode
= get_bits(gb
, 2);
1130 if(v
->hrd_param_flag
){
1131 for(i
= 0; i
< v
->hrd_num_leaky_buckets
; i
++) {
1132 skip_bits(gb
, 8); //hrd_full[n]
1137 avctx
->coded_width
= (get_bits(gb
, 12)+1)<<1;
1138 avctx
->coded_height
= (get_bits(gb
, 12)+1)<<1;
1141 v
->extended_dmv
= get_bits1(gb
);
1142 v
->range_mapy_flag
= get_bits1(gb
);
1143 if(v
->range_mapy_flag
) {
1144 av_log(avctx
, AV_LOG_ERROR
, "Luma scaling is not supported, expect wrong picture\n");
1145 v
->range_mapy
= get_bits(gb
, 3);
1147 v
->range_mapuv_flag
= get_bits1(gb
);
1148 if(v
->range_mapuv_flag
) {
1149 av_log(avctx
, AV_LOG_ERROR
, "Chroma scaling is not supported, expect wrong picture\n");
1150 v
->range_mapuv
= get_bits(gb
, 3);
1153 av_log(avctx
, AV_LOG_DEBUG
, "Entry point info:\n"
1154 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1155 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1156 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1157 blink
, clentry
, v
->panscanflag
, v
->refdist_flag
, v
->s
.loop_filter
,
1158 v
->fastuvmc
, v
->extended_mv
, v
->dquant
, v
->vstransform
, v
->overlap
, v
->quantizer_mode
);
1163 static int vc1_parse_frame_header(VC1Context
*v
, GetBitContext
* gb
)
1165 int pqindex
, lowquant
, status
;
1167 if(v
->finterpflag
) v
->interpfrm
= get_bits1(gb
);
1168 skip_bits(gb
, 2); //framecnt unused
1170 if (v
->rangered
) v
->rangeredfrm
= get_bits1(gb
);
1171 v
->s
.pict_type
= get_bits1(gb
);
1172 if (v
->s
.avctx
->max_b_frames
) {
1173 if (!v
->s
.pict_type
) {
1174 if (get_bits1(gb
)) v
->s
.pict_type
= FF_I_TYPE
;
1175 else v
->s
.pict_type
= FF_B_TYPE
;
1176 } else v
->s
.pict_type
= FF_P_TYPE
;
1177 } else v
->s
.pict_type
= v
->s
.pict_type
? FF_P_TYPE
: FF_I_TYPE
;
1180 if(v
->s
.pict_type
== FF_B_TYPE
) {
1181 v
->bfraction
= get_vlc2(gb
, ff_vc1_bfraction_vlc
.table
, VC1_BFRACTION_VLC_BITS
, 1);
1182 v
->bfraction
= ff_vc1_bfraction_lut
[v
->bfraction
];
1183 if(v
->bfraction
== 0) {
1184 v
->s
.pict_type
= FF_BI_TYPE
;
1187 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1188 skip_bits(gb
, 7); // skip buffer fullness
1191 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1193 if(v
->s
.pict_type
== FF_P_TYPE
)
1196 /* Quantizer stuff */
1197 pqindex
= get_bits(gb
, 5);
1198 if(!pqindex
) return -1;
1199 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1200 v
->pq
= ff_vc1_pquant_table
[0][pqindex
];
1202 v
->pq
= ff_vc1_pquant_table
[1][pqindex
];
1205 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1206 v
->pquantizer
= pqindex
< 9;
1207 if (v
->quantizer_mode
== QUANT_NON_UNIFORM
)
1209 v
->pqindex
= pqindex
;
1210 if (pqindex
< 9) v
->halfpq
= get_bits1(gb
);
1212 if (v
->quantizer_mode
== QUANT_FRAME_EXPLICIT
)
1213 v
->pquantizer
= get_bits1(gb
);
1215 if (v
->extended_mv
== 1) v
->mvrange
= get_unary(gb
, 0, 3);
1216 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1217 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1218 v
->range_x
= 1 << (v
->k_x
- 1);
1219 v
->range_y
= 1 << (v
->k_y
- 1);
1220 if (v
->profile
== PROFILE_ADVANCED
)
1222 if (v
->postprocflag
) v
->postproc
= get_bits1(gb
);
1225 if (v
->multires
&& v
->s
.pict_type
!= FF_B_TYPE
) v
->respic
= get_bits(gb
, 2);
1227 if(v
->res_x8
&& (v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)){
1228 v
->x8_type
= get_bits1(gb
);
1229 }else v
->x8_type
= 0;
1230 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1231 // (v->s.pict_type == FF_P_TYPE) ? 'P' : ((v->s.pict_type == FF_I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1233 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_P_TYPE
) v
->use_ic
= 0;
1235 switch(v
->s
.pict_type
) {
1237 if (v
->pq
< 5) v
->tt_index
= 0;
1238 else if(v
->pq
< 13) v
->tt_index
= 1;
1239 else v
->tt_index
= 2;
1241 lowquant
= (v
->pq
> 12) ? 0 : 1;
1242 v
->mv_mode
= ff_vc1_mv_pmode_table
[lowquant
][get_unary(gb
, 1, 4)];
1243 if (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
1245 int scale
, shift
, i
;
1246 v
->mv_mode2
= ff_vc1_mv_pmode_table2
[lowquant
][get_unary(gb
, 1, 3)];
1247 v
->lumscale
= get_bits(gb
, 6);
1248 v
->lumshift
= get_bits(gb
, 6);
1250 /* fill lookup tables for intensity compensation */
1253 shift
= (255 - v
->lumshift
* 2) << 6;
1254 if(v
->lumshift
> 31)
1257 scale
= v
->lumscale
+ 32;
1258 if(v
->lumshift
> 31)
1259 shift
= (v
->lumshift
- 64) << 6;
1261 shift
= v
->lumshift
<< 6;
1263 for(i
= 0; i
< 256; i
++) {
1264 v
->luty
[i
] = av_clip_uint8((scale
* i
+ shift
+ 32) >> 6);
1265 v
->lutuv
[i
] = av_clip_uint8((scale
* (i
- 128) + 128*64 + 32) >> 6);
1268 if(v
->mv_mode
== MV_PMODE_1MV_HPEL
|| v
->mv_mode
== MV_PMODE_1MV_HPEL_BILIN
)
1269 v
->s
.quarter_sample
= 0;
1270 else if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
1271 if(v
->mv_mode2
== MV_PMODE_1MV_HPEL
|| v
->mv_mode2
== MV_PMODE_1MV_HPEL_BILIN
)
1272 v
->s
.quarter_sample
= 0;
1274 v
->s
.quarter_sample
= 1;
1276 v
->s
.quarter_sample
= 1;
1277 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
));
1279 if ((v
->mv_mode
== MV_PMODE_INTENSITY_COMP
&&
1280 v
->mv_mode2
== MV_PMODE_MIXED_MV
)
1281 || v
->mv_mode
== MV_PMODE_MIXED_MV
)
1283 status
= bitplane_decoding(v
->mv_type_mb_plane
, &v
->mv_type_is_raw
, v
);
1284 if (status
< 0) return -1;
1285 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB MV Type plane encoding: "
1286 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1288 v
->mv_type_is_raw
= 0;
1289 memset(v
->mv_type_mb_plane
, 0, v
->s
.mb_stride
* v
->s
.mb_height
);
1291 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1292 if (status
< 0) return -1;
1293 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1294 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1296 /* Hopefully this is correct for P frames */
1297 v
->s
.mv_table_index
= get_bits(gb
, 2); //but using ff_vc1_ tables
1298 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1302 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1303 vop_dquant_decoding(v
);
1306 v
->ttfrm
= 0; //FIXME Is that so ?
1309 v
->ttmbf
= get_bits1(gb
);
1312 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1320 if (v
->pq
< 5) v
->tt_index
= 0;
1321 else if(v
->pq
< 13) v
->tt_index
= 1;
1322 else v
->tt_index
= 2;
1324 lowquant
= (v
->pq
> 12) ? 0 : 1;
1325 v
->mv_mode
= get_bits1(gb
) ? MV_PMODE_1MV
: MV_PMODE_1MV_HPEL_BILIN
;
1326 v
->s
.quarter_sample
= (v
->mv_mode
== MV_PMODE_1MV
);
1327 v
->s
.mspel
= v
->s
.quarter_sample
;
1329 status
= bitplane_decoding(v
->direct_mb_plane
, &v
->dmb_is_raw
, v
);
1330 if (status
< 0) return -1;
1331 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Direct Type plane encoding: "
1332 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1333 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1334 if (status
< 0) return -1;
1335 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1336 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1338 v
->s
.mv_table_index
= get_bits(gb
, 2);
1339 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1343 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1344 vop_dquant_decoding(v
);
1350 v
->ttmbf
= get_bits1(gb
);
1353 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1365 v
->c_ac_table_index
= decode012(gb
);
1366 if (v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1368 v
->y_ac_table_index
= decode012(gb
);
1371 v
->s
.dc_table_index
= get_bits1(gb
);
1374 if(v
->s
.pict_type
== FF_BI_TYPE
) {
1375 v
->s
.pict_type
= FF_B_TYPE
;
1381 static int vc1_parse_frame_header_adv(VC1Context
*v
, GetBitContext
* gb
)
1383 int pqindex
, lowquant
;
1386 v
->p_frame_skipped
= 0;
1389 v
->fcm
= decode012(gb
);
1390 if(v
->fcm
) return -1; // interlaced frames/fields are not implemented
1392 switch(get_unary(gb
, 0, 4)) {
1394 v
->s
.pict_type
= FF_P_TYPE
;
1397 v
->s
.pict_type
= FF_B_TYPE
;
1400 v
->s
.pict_type
= FF_I_TYPE
;
1403 v
->s
.pict_type
= FF_BI_TYPE
;
1406 v
->s
.pict_type
= FF_P_TYPE
; // skipped pic
1407 v
->p_frame_skipped
= 1;
1413 if(!v
->interlace
|| v
->psf
) {
1414 v
->rptfrm
= get_bits(gb
, 2);
1416 v
->tff
= get_bits1(gb
);
1417 v
->rptfrm
= get_bits1(gb
);
1420 if(v
->panscanflag
) {
1423 v
->rnd
= get_bits1(gb
);
1425 v
->uvsamp
= get_bits1(gb
);
1426 if(v
->finterpflag
) v
->interpfrm
= get_bits1(gb
);
1427 if(v
->s
.pict_type
== FF_B_TYPE
) {
1428 v
->bfraction
= get_vlc2(gb
, ff_vc1_bfraction_vlc
.table
, VC1_BFRACTION_VLC_BITS
, 1);
1429 v
->bfraction
= ff_vc1_bfraction_lut
[v
->bfraction
];
1430 if(v
->bfraction
== 0) {
1431 v
->s
.pict_type
= FF_BI_TYPE
; /* XXX: should not happen here */
1434 pqindex
= get_bits(gb
, 5);
1435 if(!pqindex
) return -1;
1436 v
->pqindex
= pqindex
;
1437 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1438 v
->pq
= ff_vc1_pquant_table
[0][pqindex
];
1440 v
->pq
= ff_vc1_pquant_table
[1][pqindex
];
1443 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1444 v
->pquantizer
= pqindex
< 9;
1445 if (v
->quantizer_mode
== QUANT_NON_UNIFORM
)
1447 v
->pqindex
= pqindex
;
1448 if (pqindex
< 9) v
->halfpq
= get_bits1(gb
);
1450 if (v
->quantizer_mode
== QUANT_FRAME_EXPLICIT
)
1451 v
->pquantizer
= get_bits1(gb
);
1453 v
->postproc
= get_bits1(gb
);
1455 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_P_TYPE
) v
->use_ic
= 0;
1458 v
->postproc
= get_bits(gb
, 2);
1460 switch(v
->s
.pict_type
) {
1463 status
= bitplane_decoding(v
->acpred_plane
, &v
->acpred_is_raw
, v
);
1464 if (status
< 0) return -1;
1465 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "ACPRED plane encoding: "
1466 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1467 v
->condover
= CONDOVER_NONE
;
1468 if(v
->overlap
&& v
->pq
<= 8) {
1469 v
->condover
= decode012(gb
);
1470 if(v
->condover
== CONDOVER_SELECT
) {
1471 status
= bitplane_decoding(v
->over_flags_plane
, &v
->overflg_is_raw
, v
);
1472 if (status
< 0) return -1;
1473 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "CONDOVER plane encoding: "
1474 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1479 if (v
->extended_mv
) v
->mvrange
= get_unary(gb
, 0, 3);
1480 else v
->mvrange
= 0;
1481 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1482 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1483 v
->range_x
= 1 << (v
->k_x
- 1);
1484 v
->range_y
= 1 << (v
->k_y
- 1);
1486 if (v
->pq
< 5) v
->tt_index
= 0;
1487 else if(v
->pq
< 13) v
->tt_index
= 1;
1488 else v
->tt_index
= 2;
1490 lowquant
= (v
->pq
> 12) ? 0 : 1;
1491 v
->mv_mode
= ff_vc1_mv_pmode_table
[lowquant
][get_unary(gb
, 1, 4)];
1492 if (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
1494 int scale
, shift
, i
;
1495 v
->mv_mode2
= ff_vc1_mv_pmode_table2
[lowquant
][get_unary(gb
, 1, 3)];
1496 v
->lumscale
= get_bits(gb
, 6);
1497 v
->lumshift
= get_bits(gb
, 6);
1498 /* fill lookup tables for intensity compensation */
1501 shift
= (255 - v
->lumshift
* 2) << 6;
1502 if(v
->lumshift
> 31)
1505 scale
= v
->lumscale
+ 32;
1506 if(v
->lumshift
> 31)
1507 shift
= (v
->lumshift
- 64) << 6;
1509 shift
= v
->lumshift
<< 6;
1511 for(i
= 0; i
< 256; i
++) {
1512 v
->luty
[i
] = av_clip_uint8((scale
* i
+ shift
+ 32) >> 6);
1513 v
->lutuv
[i
] = av_clip_uint8((scale
* (i
- 128) + 128*64 + 32) >> 6);
1517 if(v
->mv_mode
== MV_PMODE_1MV_HPEL
|| v
->mv_mode
== MV_PMODE_1MV_HPEL_BILIN
)
1518 v
->s
.quarter_sample
= 0;
1519 else if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
1520 if(v
->mv_mode2
== MV_PMODE_1MV_HPEL
|| v
->mv_mode2
== MV_PMODE_1MV_HPEL_BILIN
)
1521 v
->s
.quarter_sample
= 0;
1523 v
->s
.quarter_sample
= 1;
1525 v
->s
.quarter_sample
= 1;
1526 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
));
1528 if ((v
->mv_mode
== MV_PMODE_INTENSITY_COMP
&&
1529 v
->mv_mode2
== MV_PMODE_MIXED_MV
)
1530 || v
->mv_mode
== MV_PMODE_MIXED_MV
)
1532 status
= bitplane_decoding(v
->mv_type_mb_plane
, &v
->mv_type_is_raw
, v
);
1533 if (status
< 0) return -1;
1534 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB MV Type plane encoding: "
1535 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1537 v
->mv_type_is_raw
= 0;
1538 memset(v
->mv_type_mb_plane
, 0, v
->s
.mb_stride
* v
->s
.mb_height
);
1540 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1541 if (status
< 0) return -1;
1542 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1543 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1545 /* Hopefully this is correct for P frames */
1546 v
->s
.mv_table_index
= get_bits(gb
, 2); //but using ff_vc1_ tables
1547 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1550 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1551 vop_dquant_decoding(v
);
1554 v
->ttfrm
= 0; //FIXME Is that so ?
1557 v
->ttmbf
= get_bits1(gb
);
1560 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1568 if (v
->extended_mv
) v
->mvrange
= get_unary(gb
, 0, 3);
1569 else v
->mvrange
= 0;
1570 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1571 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1572 v
->range_x
= 1 << (v
->k_x
- 1);
1573 v
->range_y
= 1 << (v
->k_y
- 1);
1575 if (v
->pq
< 5) v
->tt_index
= 0;
1576 else if(v
->pq
< 13) v
->tt_index
= 1;
1577 else v
->tt_index
= 2;
1579 lowquant
= (v
->pq
> 12) ? 0 : 1;
1580 v
->mv_mode
= get_bits1(gb
) ? MV_PMODE_1MV
: MV_PMODE_1MV_HPEL_BILIN
;
1581 v
->s
.quarter_sample
= (v
->mv_mode
== MV_PMODE_1MV
);
1582 v
->s
.mspel
= v
->s
.quarter_sample
;
1584 status
= bitplane_decoding(v
->direct_mb_plane
, &v
->dmb_is_raw
, v
);
1585 if (status
< 0) return -1;
1586 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Direct Type plane encoding: "
1587 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1588 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1589 if (status
< 0) return -1;
1590 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1591 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1593 v
->s
.mv_table_index
= get_bits(gb
, 2);
1594 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1598 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1599 vop_dquant_decoding(v
);
1605 v
->ttmbf
= get_bits1(gb
);
1608 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1618 v
->c_ac_table_index
= decode012(gb
);
1619 if (v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1621 v
->y_ac_table_index
= decode012(gb
);
1624 v
->s
.dc_table_index
= get_bits1(gb
);
1625 if ((v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
) && v
->dquant
) {
1626 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1627 vop_dquant_decoding(v
);
1631 if(v
->s
.pict_type
== FF_BI_TYPE
) {
1632 v
->s
.pict_type
= FF_B_TYPE
;
1638 /***********************************************************************/
1640 * @defgroup block VC-1 Block-level functions
1641 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1647 * @brief Get macroblock-level quantizer scale
1649 #define GET_MQUANT() \
1653 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1657 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1661 mqdiff = get_bits(gb, 3); \
1662 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1663 else mquant = get_bits(gb, 5); \
1666 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1667 edges = 1 << v->dqsbedge; \
1668 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1669 edges = (3 << v->dqsbedge) % 15; \
1670 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
1672 if((edges&1) && !s->mb_x) \
1673 mquant = v->altpq; \
1674 if((edges&2) && s->first_slice_line) \
1675 mquant = v->altpq; \
1676 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
1677 mquant = v->altpq; \
1678 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
1679 mquant = v->altpq; \
1683 * @def GET_MVDATA(_dmv_x, _dmv_y)
1684 * @brief Get MV differentials
1685 * @see MVDATA decoding from 8.3.5.2, p(1)20
1686 * @param _dmv_x Horizontal differential for decoded MV
1687 * @param _dmv_y Vertical differential for decoded MV
1689 #define GET_MVDATA(_dmv_x, _dmv_y) \
1690 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table,\
1691 VC1_MV_DIFF_VLC_BITS, 2); \
1694 mb_has_coeffs = 1; \
1697 else mb_has_coeffs = 0; \
1699 if (!index) { _dmv_x = _dmv_y = 0; } \
1700 else if (index == 35) \
1702 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1703 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1705 else if (index == 36) \
1714 if (!s->quarter_sample && index1 == 5) val = 1; \
1716 if(size_table[index1] - val > 0) \
1717 val = get_bits(gb, size_table[index1] - val); \
1719 sign = 0 - (val&1); \
1720 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1723 if (!s->quarter_sample && index1 == 5) val = 1; \
1725 if(size_table[index1] - val > 0) \
1726 val = get_bits(gb, size_table[index1] - val); \
1728 sign = 0 - (val&1); \
1729 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1732 /** Predict and set motion vector
1734 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
)
1736 int xy
, wrap
, off
= 0;
1741 /* scale MV difference to be quad-pel */
1742 dmv_x
<<= 1 - s
->quarter_sample
;
1743 dmv_y
<<= 1 - s
->quarter_sample
;
1745 wrap
= s
->b8_stride
;
1746 xy
= s
->block_index
[n
];
1749 s
->mv
[0][n
][0] = s
->current_picture
.motion_val
[0][xy
][0] = 0;
1750 s
->mv
[0][n
][1] = s
->current_picture
.motion_val
[0][xy
][1] = 0;
1751 s
->current_picture
.motion_val
[1][xy
][0] = 0;
1752 s
->current_picture
.motion_val
[1][xy
][1] = 0;
1753 if(mv1
) { /* duplicate motion data for 1-MV block */
1754 s
->current_picture
.motion_val
[0][xy
+ 1][0] = 0;
1755 s
->current_picture
.motion_val
[0][xy
+ 1][1] = 0;
1756 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = 0;
1757 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = 0;
1758 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][0] = 0;
1759 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][1] = 0;
1760 s
->current_picture
.motion_val
[1][xy
+ 1][0] = 0;
1761 s
->current_picture
.motion_val
[1][xy
+ 1][1] = 0;
1762 s
->current_picture
.motion_val
[1][xy
+ wrap
][0] = 0;
1763 s
->current_picture
.motion_val
[1][xy
+ wrap
][1] = 0;
1764 s
->current_picture
.motion_val
[1][xy
+ wrap
+ 1][0] = 0;
1765 s
->current_picture
.motion_val
[1][xy
+ wrap
+ 1][1] = 0;
1770 C
= s
->current_picture
.motion_val
[0][xy
- 1];
1771 A
= s
->current_picture
.motion_val
[0][xy
- wrap
];
1773 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -1 : 2;
1775 //in 4-MV mode different blocks have different B predictor position
1778 off
= (s
->mb_x
> 0) ? -1 : 1;
1781 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -1 : 1;
1790 B
= s
->current_picture
.motion_val
[0][xy
- wrap
+ off
];
1792 if(!s
->first_slice_line
|| (n
==2 || n
==3)) { // predictor A is not out of bounds
1793 if(s
->mb_width
== 1) {
1797 px
= mid_pred(A
[0], B
[0], C
[0]);
1798 py
= mid_pred(A
[1], B
[1], C
[1]);
1800 } else if(s
->mb_x
|| (n
==1 || n
==3)) { // predictor C is not out of bounds
1806 /* Pullback MV as specified in 8.3.5.3.4 */
1809 qx
= (s
->mb_x
<< 6) + ((n
==1 || n
==3) ? 32 : 0);
1810 qy
= (s
->mb_y
<< 6) + ((n
==2 || n
==3) ? 32 : 0);
1811 X
= (s
->mb_width
<< 6) - 4;
1812 Y
= (s
->mb_height
<< 6) - 4;
1814 if(qx
+ px
< -60) px
= -60 - qx
;
1815 if(qy
+ py
< -60) py
= -60 - qy
;
1817 if(qx
+ px
< -28) px
= -28 - qx
;
1818 if(qy
+ py
< -28) py
= -28 - qy
;
1820 if(qx
+ px
> X
) px
= X
- qx
;
1821 if(qy
+ py
> Y
) py
= Y
- qy
;
1823 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1824 if((!s
->first_slice_line
|| (n
==2 || n
==3)) && (s
->mb_x
|| (n
==1 || n
==3))) {
1825 if(is_intra
[xy
- wrap
])
1826 sum
= FFABS(px
) + FFABS(py
);
1828 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
1830 if(get_bits1(&s
->gb
)) {
1838 if(is_intra
[xy
- 1])
1839 sum
= FFABS(px
) + FFABS(py
);
1841 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
1843 if(get_bits1(&s
->gb
)) {
1853 /* store MV using signed modulus of MV range defined in 4.11 */
1854 s
->mv
[0][n
][0] = s
->current_picture
.motion_val
[0][xy
][0] = ((px
+ dmv_x
+ r_x
) & ((r_x
<< 1) - 1)) - r_x
;
1855 s
->mv
[0][n
][1] = s
->current_picture
.motion_val
[0][xy
][1] = ((py
+ dmv_y
+ r_y
) & ((r_y
<< 1) - 1)) - r_y
;
1856 if(mv1
) { /* duplicate motion data for 1-MV block */
1857 s
->current_picture
.motion_val
[0][xy
+ 1][0] = s
->current_picture
.motion_val
[0][xy
][0];
1858 s
->current_picture
.motion_val
[0][xy
+ 1][1] = s
->current_picture
.motion_val
[0][xy
][1];
1859 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = s
->current_picture
.motion_val
[0][xy
][0];
1860 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = s
->current_picture
.motion_val
[0][xy
][1];
1861 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][0] = s
->current_picture
.motion_val
[0][xy
][0];
1862 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][1] = s
->current_picture
.motion_val
[0][xy
][1];
1866 /** Motion compensation for direct or interpolated blocks in B-frames
1868 static void vc1_interp_mc(VC1Context
*v
)
1870 MpegEncContext
*s
= &v
->s
;
1871 DSPContext
*dsp
= &v
->s
.dsp
;
1872 uint8_t *srcY
, *srcU
, *srcV
;
1873 int dxy
, uvdxy
, mx
, my
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
1875 if(!v
->s
.next_picture
.data
[0])return;
1877 mx
= s
->mv
[1][0][0];
1878 my
= s
->mv
[1][0][1];
1879 uvmx
= (mx
+ ((mx
& 3) == 3)) >> 1;
1880 uvmy
= (my
+ ((my
& 3) == 3)) >> 1;
1882 uvmx
= uvmx
+ ((uvmx
<0)?-(uvmx
&1):(uvmx
&1));
1883 uvmy
= uvmy
+ ((uvmy
<0)?-(uvmy
&1):(uvmy
&1));
1885 srcY
= s
->next_picture
.data
[0];
1886 srcU
= s
->next_picture
.data
[1];
1887 srcV
= s
->next_picture
.data
[2];
1889 src_x
= s
->mb_x
* 16 + (mx
>> 2);
1890 src_y
= s
->mb_y
* 16 + (my
>> 2);
1891 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
1892 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
1894 if(v
->profile
!= PROFILE_ADVANCED
){
1895 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
1896 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
1897 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
1898 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
1900 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
1901 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
1902 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
1903 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
1906 srcY
+= src_y
* s
->linesize
+ src_x
;
1907 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
1908 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
1910 /* for grayscale we should not try to read from unknown area */
1911 if(s
->flags
& CODEC_FLAG_GRAY
) {
1912 srcU
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
1913 srcV
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
1917 || (unsigned)src_x
> s
->h_edge_pos
- (mx
&3) - 16
1918 || (unsigned)src_y
> s
->v_edge_pos
- (my
&3) - 16){
1919 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 19 * s
->linesize
;
1921 srcY
-= s
->mspel
* (1 + s
->linesize
);
1922 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 17+s
->mspel
*2, 17+s
->mspel
*2,
1923 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
1924 srcY
= s
->edge_emu_buffer
;
1925 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, 8+1, 8+1,
1926 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
1927 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
1928 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
1931 /* if we deal with range reduction we need to scale source blocks */
1932 if(v
->rangeredfrm
) {
1934 uint8_t *src
, *src2
;
1937 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
1938 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
1941 src
= srcU
; src2
= srcV
;
1942 for(j
= 0; j
< 9; j
++) {
1943 for(i
= 0; i
< 9; i
++) {
1944 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
1945 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
1947 src
+= s
->uvlinesize
;
1948 src2
+= s
->uvlinesize
;
1951 srcY
+= s
->mspel
* (1 + s
->linesize
);
1956 dxy
= ((my
& 1) << 1) | (mx
& 1);
1958 dsp
->avg_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
1960 if(s
->flags
& CODEC_FLAG_GRAY
) return;
1961 /* Chroma MC always uses qpel blilinear */
1962 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
1965 dsp
->avg_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1966 dsp
->avg_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1969 static av_always_inline
int scale_mv(int value
, int bfrac
, int inv
, int qs
)
1973 #if B_FRACTION_DEN==256
1977 return 2 * ((value
* n
+ 255) >> 9);
1978 return (value
* n
+ 128) >> 8;
1981 n
-= B_FRACTION_DEN
;
1983 return 2 * ((value
* n
+ B_FRACTION_DEN
- 1) / (2 * B_FRACTION_DEN
));
1984 return (value
* n
+ B_FRACTION_DEN
/2) / B_FRACTION_DEN
;
1988 /** Reconstruct motion vector for B-frame and do motion compensation
1990 static inline void vc1_b_mc(VC1Context
*v
, int dmv_x
[2], int dmv_y
[2], int direct
, int mode
)
1993 v
->mv_mode2
= v
->mv_mode
;
1994 v
->mv_mode
= MV_PMODE_INTENSITY_COMP
;
1999 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
2002 if(mode
== BMV_TYPE_INTERPOLATED
) {
2005 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
2009 if(v
->use_ic
&& (mode
== BMV_TYPE_BACKWARD
)) v
->mv_mode
= v
->mv_mode2
;
2010 vc1_mc_1mv(v
, (mode
== BMV_TYPE_BACKWARD
));
2011 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
2014 static inline void vc1_pred_b_mv(VC1Context
*v
, int dmv_x
[2], int dmv_y
[2], int direct
, int mvtype
)
2016 MpegEncContext
*s
= &v
->s
;
2017 int xy
, wrap
, off
= 0;
2022 const uint8_t *is_intra
= v
->mb_type
[0];
2026 /* scale MV difference to be quad-pel */
2027 dmv_x
[0] <<= 1 - s
->quarter_sample
;
2028 dmv_y
[0] <<= 1 - s
->quarter_sample
;
2029 dmv_x
[1] <<= 1 - s
->quarter_sample
;
2030 dmv_y
[1] <<= 1 - s
->quarter_sample
;
2032 wrap
= s
->b8_stride
;
2033 xy
= s
->block_index
[0];
2036 s
->current_picture
.motion_val
[0][xy
][0] =
2037 s
->current_picture
.motion_val
[0][xy
][1] =
2038 s
->current_picture
.motion_val
[1][xy
][0] =
2039 s
->current_picture
.motion_val
[1][xy
][1] = 0;
2042 s
->mv
[0][0][0] = scale_mv(s
->next_picture
.motion_val
[1][xy
][0], v
->bfraction
, 0, s
->quarter_sample
);
2043 s
->mv
[0][0][1] = scale_mv(s
->next_picture
.motion_val
[1][xy
][1], v
->bfraction
, 0, s
->quarter_sample
);
2044 s
->mv
[1][0][0] = scale_mv(s
->next_picture
.motion_val
[1][xy
][0], v
->bfraction
, 1, s
->quarter_sample
);
2045 s
->mv
[1][0][1] = scale_mv(s
->next_picture
.motion_val
[1][xy
][1], v
->bfraction
, 1, s
->quarter_sample
);
2047 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
2048 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));
2049 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));
2050 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));
2051 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));
2053 s
->current_picture
.motion_val
[0][xy
][0] = s
->mv
[0][0][0];
2054 s
->current_picture
.motion_val
[0][xy
][1] = s
->mv
[0][0][1];
2055 s
->current_picture
.motion_val
[1][xy
][0] = s
->mv
[1][0][0];
2056 s
->current_picture
.motion_val
[1][xy
][1] = s
->mv
[1][0][1];
2060 if((mvtype
== BMV_TYPE_FORWARD
) || (mvtype
== BMV_TYPE_INTERPOLATED
)) {
2061 C
= s
->current_picture
.motion_val
[0][xy
- 2];
2062 A
= s
->current_picture
.motion_val
[0][xy
- wrap
*2];
2063 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -2 : 2;
2064 B
= s
->current_picture
.motion_val
[0][xy
- wrap
*2 + off
];
2066 if(!s
->mb_x
) C
[0] = C
[1] = 0;
2067 if(!s
->first_slice_line
) { // predictor A is not out of bounds
2068 if(s
->mb_width
== 1) {
2072 px
= mid_pred(A
[0], B
[0], C
[0]);
2073 py
= mid_pred(A
[1], B
[1], C
[1]);
2075 } else if(s
->mb_x
) { // predictor C is not out of bounds
2081 /* Pullback MV as specified in 8.3.5.3.4 */
2084 if(v
->profile
< PROFILE_ADVANCED
) {
2085 qx
= (s
->mb_x
<< 5);
2086 qy
= (s
->mb_y
<< 5);
2087 X
= (s
->mb_width
<< 5) - 4;
2088 Y
= (s
->mb_height
<< 5) - 4;
2089 if(qx
+ px
< -28) px
= -28 - qx
;
2090 if(qy
+ py
< -28) py
= -28 - qy
;
2091 if(qx
+ px
> X
) px
= X
- qx
;
2092 if(qy
+ py
> Y
) py
= Y
- qy
;
2094 qx
= (s
->mb_x
<< 6);
2095 qy
= (s
->mb_y
<< 6);
2096 X
= (s
->mb_width
<< 6) - 4;
2097 Y
= (s
->mb_height
<< 6) - 4;
2098 if(qx
+ px
< -60) px
= -60 - qx
;
2099 if(qy
+ py
< -60) py
= -60 - qy
;
2100 if(qx
+ px
> X
) px
= X
- qx
;
2101 if(qy
+ py
> Y
) py
= Y
- qy
;
2104 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2105 if(0 && !s
->first_slice_line
&& s
->mb_x
) {
2106 if(is_intra
[xy
- wrap
])
2107 sum
= FFABS(px
) + FFABS(py
);
2109 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
2111 if(get_bits1(&s
->gb
)) {
2119 if(is_intra
[xy
- 2])
2120 sum
= FFABS(px
) + FFABS(py
);
2122 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
2124 if(get_bits1(&s
->gb
)) {
2134 /* store MV using signed modulus of MV range defined in 4.11 */
2135 s
->mv
[0][0][0] = ((px
+ dmv_x
[0] + r_x
) & ((r_x
<< 1) - 1)) - r_x
;
2136 s
->mv
[0][0][1] = ((py
+ dmv_y
[0] + r_y
) & ((r_y
<< 1) - 1)) - r_y
;
2138 if((mvtype
== BMV_TYPE_BACKWARD
) || (mvtype
== BMV_TYPE_INTERPOLATED
)) {
2139 C
= s
->current_picture
.motion_val
[1][xy
- 2];
2140 A
= s
->current_picture
.motion_val
[1][xy
- wrap
*2];
2141 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -2 : 2;
2142 B
= s
->current_picture
.motion_val
[1][xy
- wrap
*2 + off
];
2144 if(!s
->mb_x
) C
[0] = C
[1] = 0;
2145 if(!s
->first_slice_line
) { // predictor A is not out of bounds
2146 if(s
->mb_width
== 1) {
2150 px
= mid_pred(A
[0], B
[0], C
[0]);
2151 py
= mid_pred(A
[1], B
[1], C
[1]);
2153 } else if(s
->mb_x
) { // predictor C is not out of bounds
2159 /* Pullback MV as specified in 8.3.5.3.4 */
2162 if(v
->profile
< PROFILE_ADVANCED
) {
2163 qx
= (s
->mb_x
<< 5);
2164 qy
= (s
->mb_y
<< 5);
2165 X
= (s
->mb_width
<< 5) - 4;
2166 Y
= (s
->mb_height
<< 5) - 4;
2167 if(qx
+ px
< -28) px
= -28 - qx
;
2168 if(qy
+ py
< -28) py
= -28 - qy
;
2169 if(qx
+ px
> X
) px
= X
- qx
;
2170 if(qy
+ py
> Y
) py
= Y
- qy
;
2172 qx
= (s
->mb_x
<< 6);
2173 qy
= (s
->mb_y
<< 6);
2174 X
= (s
->mb_width
<< 6) - 4;
2175 Y
= (s
->mb_height
<< 6) - 4;
2176 if(qx
+ px
< -60) px
= -60 - qx
;
2177 if(qy
+ py
< -60) py
= -60 - qy
;
2178 if(qx
+ px
> X
) px
= X
- qx
;
2179 if(qy
+ py
> Y
) py
= Y
- qy
;
2182 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2183 if(0 && !s
->first_slice_line
&& s
->mb_x
) {
2184 if(is_intra
[xy
- wrap
])
2185 sum
= FFABS(px
) + FFABS(py
);
2187 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
2189 if(get_bits1(&s
->gb
)) {
2197 if(is_intra
[xy
- 2])
2198 sum
= FFABS(px
) + FFABS(py
);
2200 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
2202 if(get_bits1(&s
->gb
)) {
2212 /* store MV using signed modulus of MV range defined in 4.11 */
2214 s
->mv
[1][0][0] = ((px
+ dmv_x
[1] + r_x
) & ((r_x
<< 1) - 1)) - r_x
;
2215 s
->mv
[1][0][1] = ((py
+ dmv_y
[1] + r_y
) & ((r_y
<< 1) - 1)) - r_y
;
2217 s
->current_picture
.motion_val
[0][xy
][0] = s
->mv
[0][0][0];
2218 s
->current_picture
.motion_val
[0][xy
][1] = s
->mv
[0][0][1];
2219 s
->current_picture
.motion_val
[1][xy
][0] = s
->mv
[1][0][0];
2220 s
->current_picture
.motion_val
[1][xy
][1] = s
->mv
[1][0][1];
2223 /** Get predicted DC value for I-frames only
2224 * prediction dir: left=0, top=1
2225 * @param s MpegEncContext
2226 * @param[in] n block index in the current MB
2227 * @param dc_val_ptr Pointer to DC predictor
2228 * @param dir_ptr Prediction direction for use in AC prediction
2230 static inline int vc1_i_pred_dc(MpegEncContext
*s
, int overlap
, int pq
, int n
,
2231 int16_t **dc_val_ptr
, int *dir_ptr
)
2233 int a
, b
, c
, wrap
, pred
, scale
;
2235 static const uint16_t dcpred
[32] = {
2236 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2237 114, 102, 93, 85, 79, 73, 68, 64,
2238 60, 57, 54, 51, 49, 47, 45, 43,
2239 41, 39, 38, 37, 35, 34, 33
2242 /* find prediction - wmv3_dc_scale always used here in fact */
2243 if (n
< 4) scale
= s
->y_dc_scale
;
2244 else scale
= s
->c_dc_scale
;
2246 wrap
= s
->block_wrap
[n
];
2247 dc_val
= s
->dc_val
[0] + s
->block_index
[n
];
2253 b
= dc_val
[ - 1 - wrap
];
2254 a
= dc_val
[ - wrap
];
2256 if (pq
< 9 || !overlap
)
2258 /* Set outer values */
2259 if (s
->first_slice_line
&& (n
!=2 && n
!=3)) b
=a
=dcpred
[scale
];
2260 if (s
->mb_x
== 0 && (n
!=1 && n
!=3)) b
=c
=dcpred
[scale
];
2264 /* Set outer values */
2265 if (s
->first_slice_line
&& (n
!=2 && n
!=3)) b
=a
=0;
2266 if (s
->mb_x
== 0 && (n
!=1 && n
!=3)) b
=c
=0;
2269 if (abs(a
- b
) <= abs(b
- c
)) {
2277 /* update predictor */
2278 *dc_val_ptr
= &dc_val
[0];
2283 /** Get predicted DC value
2284 * prediction dir: left=0, top=1
2285 * @param s MpegEncContext
2286 * @param[in] n block index in the current MB
2287 * @param dc_val_ptr Pointer to DC predictor
2288 * @param dir_ptr Prediction direction for use in AC prediction
2290 static inline int vc1_pred_dc(MpegEncContext
*s
, int overlap
, int pq
, int n
,
2291 int a_avail
, int c_avail
,
2292 int16_t **dc_val_ptr
, int *dir_ptr
)
2294 int a
, b
, c
, wrap
, pred
, scale
;
2296 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2299 /* find prediction - wmv3_dc_scale always used here in fact */
2300 if (n
< 4) scale
= s
->y_dc_scale
;
2301 else scale
= s
->c_dc_scale
;
2303 wrap
= s
->block_wrap
[n
];
2304 dc_val
= s
->dc_val
[0] + s
->block_index
[n
];
2310 b
= dc_val
[ - 1 - wrap
];
2311 a
= dc_val
[ - wrap
];
2312 /* scale predictors if needed */
2313 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2314 if(c_avail
&& (n
!= 1 && n
!=3)) {
2315 q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2317 c
= (c
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2319 if(a_avail
&& (n
!= 2 && n
!=3)) {
2320 q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2322 a
= (a
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2324 if(a_avail
&& c_avail
&& (n
!=3)) {
2327 if(n
!= 2) off
-= s
->mb_stride
;
2328 q2
= s
->current_picture
.qscale_table
[off
];
2330 b
= (b
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2333 if(a_avail
&& c_avail
) {
2334 if(abs(a
- b
) <= abs(b
- c
)) {
2341 } else if(a_avail
) {
2344 } else if(c_avail
) {
2352 /* update predictor */
2353 *dc_val_ptr
= &dc_val
[0];
2359 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2360 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2364 static inline int vc1_coded_block_pred(MpegEncContext
* s
, int n
, uint8_t **coded_block_ptr
)
2366 int xy
, wrap
, pred
, a
, b
, c
;
2368 xy
= s
->block_index
[n
];
2369 wrap
= s
->b8_stride
;
2374 a
= s
->coded_block
[xy
- 1 ];
2375 b
= s
->coded_block
[xy
- 1 - wrap
];
2376 c
= s
->coded_block
[xy
- wrap
];
2385 *coded_block_ptr
= &s
->coded_block
[xy
];
2391 * Decode one AC coefficient
2392 * @param v The VC1 context
2393 * @param last Last coefficient
2394 * @param skip How much zero coefficients to skip
2395 * @param value Decoded AC coefficient value
2398 static void vc1_decode_ac_coeff(VC1Context
*v
, int *last
, int *skip
, int *value
, int codingset
)
2400 GetBitContext
*gb
= &v
->s
.gb
;
2401 int index
, escape
, run
= 0, level
= 0, lst
= 0;
2403 index
= get_vlc2(gb
, ff_vc1_ac_coeff_table
[codingset
].table
, AC_VLC_BITS
, 3);
2404 if (index
!= vc1_ac_sizes
[codingset
] - 1) {
2405 run
= vc1_index_decode_table
[codingset
][index
][0];
2406 level
= vc1_index_decode_table
[codingset
][index
][1];
2407 lst
= index
>= vc1_last_decode_table
[codingset
];
2411 escape
= decode210(gb
);
2413 index
= get_vlc2(gb
, ff_vc1_ac_coeff_table
[codingset
].table
, AC_VLC_BITS
, 3);
2414 run
= vc1_index_decode_table
[codingset
][index
][0];
2415 level
= vc1_index_decode_table
[codingset
][index
][1];
2416 lst
= index
>= vc1_last_decode_table
[codingset
];
2419 level
+= vc1_last_delta_level_table
[codingset
][run
];
2421 level
+= vc1_delta_level_table
[codingset
][run
];
2424 run
+= vc1_last_delta_run_table
[codingset
][level
] + 1;
2426 run
+= vc1_delta_run_table
[codingset
][level
] + 1;
2432 lst
= get_bits1(gb
);
2433 if(v
->s
.esc3_level_length
== 0) {
2434 if(v
->pq
< 8 || v
->dquantfrm
) { // table 59
2435 v
->s
.esc3_level_length
= get_bits(gb
, 3);
2436 if(!v
->s
.esc3_level_length
)
2437 v
->s
.esc3_level_length
= get_bits(gb
, 2) + 8;
2439 v
->s
.esc3_level_length
= get_unary(gb
, 1, 6) + 2;
2441 v
->s
.esc3_run_length
= 3 + get_bits(gb
, 2);
2443 run
= get_bits(gb
, v
->s
.esc3_run_length
);
2444 sign
= get_bits1(gb
);
2445 level
= get_bits(gb
, v
->s
.esc3_level_length
);
2456 /** Decode intra block in intra frames - should be faster than decode_intra_block
2457 * @param v VC1Context
2458 * @param block block to decode
2459 * @param coded are AC coeffs present or not
2460 * @param codingset set of VLC to decode data
2462 static int vc1_decode_i_block(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int codingset
)
2464 GetBitContext
*gb
= &v
->s
.gb
;
2465 MpegEncContext
*s
= &v
->s
;
2466 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2469 int16_t *ac_val
, *ac_val2
;
2472 /* Get DC differential */
2474 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2476 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2479 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2484 if (dcdiff
== 119 /* ESC index value */)
2486 /* TODO: Optimize */
2487 if (v
->pq
== 1) dcdiff
= get_bits(gb
, 10);
2488 else if (v
->pq
== 2) dcdiff
= get_bits(gb
, 9);
2489 else dcdiff
= get_bits(gb
, 8);
2494 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2495 else if (v
->pq
== 2)
2496 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2503 dcdiff
+= vc1_i_pred_dc(&v
->s
, v
->overlap
, v
->pq
, n
, &dc_val
, &dc_pred_dir
);
2506 /* Store the quantized DC coeff, used for prediction */
2508 block
[0] = dcdiff
* s
->y_dc_scale
;
2510 block
[0] = dcdiff
* s
->c_dc_scale
;
2523 int last
= 0, skip
, value
;
2524 const int8_t *zz_table
;
2528 scale
= v
->pq
* 2 + v
->halfpq
;
2532 zz_table
= wmv1_scantable
[2];
2534 zz_table
= wmv1_scantable
[3];
2536 zz_table
= wmv1_scantable
[1];
2538 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2540 if(dc_pred_dir
) //left
2543 ac_val
-= 16 * s
->block_wrap
[n
];
2546 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2550 block
[zz_table
[i
++]] = value
;
2553 /* apply AC prediction if needed */
2555 if(dc_pred_dir
) { //left
2556 for(k
= 1; k
< 8; k
++)
2557 block
[k
<< 3] += ac_val
[k
];
2559 for(k
= 1; k
< 8; k
++)
2560 block
[k
] += ac_val
[k
+ 8];
2563 /* save AC coeffs for further prediction */
2564 for(k
= 1; k
< 8; k
++) {
2565 ac_val2
[k
] = block
[k
<< 3];
2566 ac_val2
[k
+ 8] = block
[k
];
2569 /* scale AC coeffs */
2570 for(k
= 1; k
< 64; k
++)
2574 block
[k
] += (block
[k
] < 0) ? -v
->pq
: v
->pq
;
2577 if(s
->ac_pred
) i
= 63;
2583 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2586 scale
= v
->pq
* 2 + v
->halfpq
;
2587 memset(ac_val2
, 0, 16 * 2);
2588 if(dc_pred_dir
) {//left
2591 memcpy(ac_val2
, ac_val
, 8 * 2);
2593 ac_val
-= 16 * s
->block_wrap
[n
];
2595 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2598 /* apply AC prediction if needed */
2600 if(dc_pred_dir
) { //left
2601 for(k
= 1; k
< 8; k
++) {
2602 block
[k
<< 3] = ac_val
[k
] * scale
;
2603 if(!v
->pquantizer
&& block
[k
<< 3])
2604 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -v
->pq
: v
->pq
;
2607 for(k
= 1; k
< 8; k
++) {
2608 block
[k
] = ac_val
[k
+ 8] * scale
;
2609 if(!v
->pquantizer
&& block
[k
])
2610 block
[k
] += (block
[k
] < 0) ? -v
->pq
: v
->pq
;
2616 s
->block_last_index
[n
] = i
;
2621 /** Decode intra block in intra frames - should be faster than decode_intra_block
2622 * @param v VC1Context
2623 * @param block block to decode
2624 * @param coded are AC coeffs present or not
2625 * @param codingset set of VLC to decode data
2627 static int vc1_decode_i_block_adv(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int codingset
, int mquant
)
2629 GetBitContext
*gb
= &v
->s
.gb
;
2630 MpegEncContext
*s
= &v
->s
;
2631 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2634 int16_t *ac_val
, *ac_val2
;
2636 int a_avail
= v
->a_avail
, c_avail
= v
->c_avail
;
2637 int use_pred
= s
->ac_pred
;
2640 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2642 /* Get DC differential */
2644 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2646 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2649 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2654 if (dcdiff
== 119 /* ESC index value */)
2656 /* TODO: Optimize */
2657 if (mquant
== 1) dcdiff
= get_bits(gb
, 10);
2658 else if (mquant
== 2) dcdiff
= get_bits(gb
, 9);
2659 else dcdiff
= get_bits(gb
, 8);
2664 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2665 else if (mquant
== 2)
2666 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2673 dcdiff
+= vc1_pred_dc(&v
->s
, v
->overlap
, mquant
, n
, v
->a_avail
, v
->c_avail
, &dc_val
, &dc_pred_dir
);
2676 /* Store the quantized DC coeff, used for prediction */
2678 block
[0] = dcdiff
* s
->y_dc_scale
;
2680 block
[0] = dcdiff
* s
->c_dc_scale
;
2689 /* check if AC is needed at all */
2690 if(!a_avail
&& !c_avail
) use_pred
= 0;
2691 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2694 scale
= mquant
* 2 + ((mquant
== v
->pq
) ? v
->halfpq
: 0);
2696 if(dc_pred_dir
) //left
2699 ac_val
-= 16 * s
->block_wrap
[n
];
2701 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2702 if(dc_pred_dir
&& c_avail
&& mb_pos
) q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2703 if(!dc_pred_dir
&& a_avail
&& mb_pos
>= s
->mb_stride
) q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2704 if(dc_pred_dir
&& n
==1) q2
= q1
;
2705 if(!dc_pred_dir
&& n
==2) q2
= q1
;
2709 int last
= 0, skip
, value
;
2710 const int8_t *zz_table
;
2715 zz_table
= wmv1_scantable
[2];
2717 zz_table
= wmv1_scantable
[3];
2719 zz_table
= wmv1_scantable
[1];
2722 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2726 block
[zz_table
[i
++]] = value
;
2729 /* apply AC prediction if needed */
2731 /* scale predictors if needed*/
2733 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2734 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2736 if(dc_pred_dir
) { //left
2737 for(k
= 1; k
< 8; k
++)
2738 block
[k
<< 3] += (ac_val
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2740 for(k
= 1; k
< 8; k
++)
2741 block
[k
] += (ac_val
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2744 if(dc_pred_dir
) { //left
2745 for(k
= 1; k
< 8; k
++)
2746 block
[k
<< 3] += ac_val
[k
];
2748 for(k
= 1; k
< 8; k
++)
2749 block
[k
] += ac_val
[k
+ 8];
2753 /* save AC coeffs for further prediction */
2754 for(k
= 1; k
< 8; k
++) {
2755 ac_val2
[k
] = block
[k
<< 3];
2756 ac_val2
[k
+ 8] = block
[k
];
2759 /* scale AC coeffs */
2760 for(k
= 1; k
< 64; k
++)
2764 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2767 if(use_pred
) i
= 63;
2768 } else { // no AC coeffs
2771 memset(ac_val2
, 0, 16 * 2);
2772 if(dc_pred_dir
) {//left
2774 memcpy(ac_val2
, ac_val
, 8 * 2);
2776 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2777 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2778 for(k
= 1; k
< 8; k
++)
2779 ac_val2
[k
] = (ac_val2
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2784 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2786 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2787 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2788 for(k
= 1; k
< 8; k
++)
2789 ac_val2
[k
+ 8] = (ac_val2
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2794 /* apply AC prediction if needed */
2796 if(dc_pred_dir
) { //left
2797 for(k
= 1; k
< 8; k
++) {
2798 block
[k
<< 3] = ac_val2
[k
] * scale
;
2799 if(!v
->pquantizer
&& block
[k
<< 3])
2800 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -mquant
: mquant
;
2803 for(k
= 1; k
< 8; k
++) {
2804 block
[k
] = ac_val2
[k
+ 8] * scale
;
2805 if(!v
->pquantizer
&& block
[k
])
2806 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2812 s
->block_last_index
[n
] = i
;
2817 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2818 * @param v VC1Context
2819 * @param block block to decode
2820 * @param coded are AC coeffs present or not
2821 * @param mquant block quantizer
2822 * @param codingset set of VLC to decode data
2824 static int vc1_decode_intra_block(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int mquant
, int codingset
)
2826 GetBitContext
*gb
= &v
->s
.gb
;
2827 MpegEncContext
*s
= &v
->s
;
2828 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2831 int16_t *ac_val
, *ac_val2
;
2833 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2834 int a_avail
= v
->a_avail
, c_avail
= v
->c_avail
;
2835 int use_pred
= s
->ac_pred
;
2839 /* XXX: Guard against dumb values of mquant */
2840 mquant
= (mquant
< 1) ? 0 : ( (mquant
>31) ? 31 : mquant
);
2842 /* Set DC scale - y and c use the same */
2843 s
->y_dc_scale
= s
->y_dc_scale_table
[mquant
];
2844 s
->c_dc_scale
= s
->c_dc_scale_table
[mquant
];
2846 /* Get DC differential */
2848 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2850 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2853 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2858 if (dcdiff
== 119 /* ESC index value */)
2860 /* TODO: Optimize */
2861 if (mquant
== 1) dcdiff
= get_bits(gb
, 10);
2862 else if (mquant
== 2) dcdiff
= get_bits(gb
, 9);
2863 else dcdiff
= get_bits(gb
, 8);
2868 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2869 else if (mquant
== 2)
2870 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2877 dcdiff
+= vc1_pred_dc(&v
->s
, v
->overlap
, mquant
, n
, a_avail
, c_avail
, &dc_val
, &dc_pred_dir
);
2880 /* Store the quantized DC coeff, used for prediction */
2883 block
[0] = dcdiff
* s
->y_dc_scale
;
2885 block
[0] = dcdiff
* s
->c_dc_scale
;
2894 /* check if AC is needed at all and adjust direction if needed */
2895 if(!a_avail
) dc_pred_dir
= 1;
2896 if(!c_avail
) dc_pred_dir
= 0;
2897 if(!a_avail
&& !c_avail
) use_pred
= 0;
2898 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2901 scale
= mquant
* 2 + v
->halfpq
;
2903 if(dc_pred_dir
) //left
2906 ac_val
-= 16 * s
->block_wrap
[n
];
2908 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2909 if(dc_pred_dir
&& c_avail
&& mb_pos
) q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2910 if(!dc_pred_dir
&& a_avail
&& mb_pos
>= s
->mb_stride
) q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2911 if(dc_pred_dir
&& n
==1) q2
= q1
;
2912 if(!dc_pred_dir
&& n
==2) q2
= q1
;
2916 int last
= 0, skip
, value
;
2917 const int8_t *zz_table
;
2920 zz_table
= wmv1_scantable
[0];
2923 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2927 block
[zz_table
[i
++]] = value
;
2930 /* apply AC prediction if needed */
2932 /* scale predictors if needed*/
2934 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2935 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2937 if(dc_pred_dir
) { //left
2938 for(k
= 1; k
< 8; k
++)
2939 block
[k
<< 3] += (ac_val
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2941 for(k
= 1; k
< 8; k
++)
2942 block
[k
] += (ac_val
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2945 if(dc_pred_dir
) { //left
2946 for(k
= 1; k
< 8; k
++)
2947 block
[k
<< 3] += ac_val
[k
];
2949 for(k
= 1; k
< 8; k
++)
2950 block
[k
] += ac_val
[k
+ 8];
2954 /* save AC coeffs for further prediction */
2955 for(k
= 1; k
< 8; k
++) {
2956 ac_val2
[k
] = block
[k
<< 3];
2957 ac_val2
[k
+ 8] = block
[k
];
2960 /* scale AC coeffs */
2961 for(k
= 1; k
< 64; k
++)
2965 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2968 if(use_pred
) i
= 63;
2969 } else { // no AC coeffs
2972 memset(ac_val2
, 0, 16 * 2);
2973 if(dc_pred_dir
) {//left
2975 memcpy(ac_val2
, ac_val
, 8 * 2);
2977 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2978 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2979 for(k
= 1; k
< 8; k
++)
2980 ac_val2
[k
] = (ac_val2
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2985 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2987 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2988 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2989 for(k
= 1; k
< 8; k
++)
2990 ac_val2
[k
+ 8] = (ac_val2
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2995 /* apply AC prediction if needed */
2997 if(dc_pred_dir
) { //left
2998 for(k
= 1; k
< 8; k
++) {
2999 block
[k
<< 3] = ac_val2
[k
] * scale
;
3000 if(!v
->pquantizer
&& block
[k
<< 3])
3001 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -mquant
: mquant
;
3004 for(k
= 1; k
< 8; k
++) {
3005 block
[k
] = ac_val2
[k
+ 8] * scale
;
3006 if(!v
->pquantizer
&& block
[k
])
3007 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
3013 s
->block_last_index
[n
] = i
;
3020 static int vc1_decode_p_block(VC1Context
*v
, DCTELEM block
[64], int n
, int mquant
, int ttmb
, int first_block
,
3021 uint8_t *dst
, int linesize
, int skip_block
, int apply_filter
, int cbp_top
, int cbp_left
)
3023 MpegEncContext
*s
= &v
->s
;
3024 GetBitContext
*gb
= &s
->gb
;
3027 int scale
, off
, idx
, last
, skip
, value
;
3028 int ttblk
= ttmb
& 7;
3032 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)];
3034 if(ttblk
== TT_4X4
) {
3035 subblkpat
= ~(get_vlc2(gb
, ff_vc1_subblkpat_vlc
[v
->tt_index
].table
, VC1_SUBBLKPAT_VLC_BITS
, 1) + 1);
3037 if((ttblk
!= TT_8X8
&& ttblk
!= TT_4X4
) && (v
->ttmbf
|| (ttmb
!= -1 && (ttmb
& 8) && !first_block
))) {
3038 subblkpat
= decode012(gb
);
3039 if(subblkpat
) subblkpat
^= 3; //swap decoded pattern bits
3040 if(ttblk
== TT_8X4_TOP
|| ttblk
== TT_8X4_BOTTOM
) ttblk
= TT_8X4
;
3041 if(ttblk
== TT_4X8_RIGHT
|| ttblk
== TT_4X8_LEFT
) ttblk
= TT_4X8
;
3043 scale
= 2 * mquant
+ ((v
->pq
== mquant
) ? v
->halfpq
: 0);
3045 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3046 if(ttblk
== TT_8X4_TOP
|| ttblk
== TT_8X4_BOTTOM
) {
3047 subblkpat
= 2 - (ttblk
== TT_8X4_TOP
);
3050 if(ttblk
== TT_4X8_RIGHT
|| ttblk
== TT_4X8_LEFT
) {
3051 subblkpat
= 2 - (ttblk
== TT_4X8_LEFT
);
3060 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3064 idx
= wmv1_scantable
[0][i
++];
3065 block
[idx
] = value
* scale
;
3067 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3070 s
->dsp
.vc1_inv_trans_8x8(block
);
3071 s
->dsp
.add_pixels_clamped(block
, dst
, linesize
);
3072 if(apply_filter
&& cbp_top
& 0xC)
3073 vc1_loop_filter(dst
, 1, linesize
, 8, mquant
);
3074 if(apply_filter
&& cbp_left
& 0xA)
3075 vc1_loop_filter(dst
, linesize
, 1, 8, mquant
);
3079 pat
= ~subblkpat
& 0xF;
3080 for(j
= 0; j
< 4; j
++) {
3081 last
= subblkpat
& (1 << (3 - j
));
3083 off
= (j
& 1) * 4 + (j
& 2) * 16;
3085 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3089 idx
= ff_vc1_simple_progressive_4x4_zz
[i
++];
3090 block
[idx
+ off
] = value
* scale
;
3092 block
[idx
+ off
] += (block
[idx
+ off
] < 0) ? -mquant
: mquant
;
3094 if(!(subblkpat
& (1 << (3 - j
))) && !skip_block
){
3095 s
->dsp
.vc1_inv_trans_4x4(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, linesize
, block
+ off
);
3096 if(apply_filter
&& (j
&2 ? pat
& (1<<(j
-2)) : (cbp_top
& (1 << (j
+ 2)))))
3097 vc1_loop_filter(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, 1, linesize
, 4, mquant
);
3098 if(apply_filter
&& (j
&1 ? pat
& (1<<(j
-1)) : (cbp_left
& (1 << (j
+ 1)))))
3099 vc1_loop_filter(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, linesize
, 1, 4, mquant
);
3104 pat
= ~((subblkpat
& 2)*6 + (subblkpat
& 1)*3) & 0xF;
3105 for(j
= 0; j
< 2; j
++) {
3106 last
= subblkpat
& (1 << (1 - j
));
3110 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3114 idx
= v
->zz_8x4
[i
++]+off
;
3115 block
[idx
] = value
* scale
;
3117 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3119 if(!(subblkpat
& (1 << (1 - j
))) && !skip_block
){
3120 s
->dsp
.vc1_inv_trans_8x4(dst
+ j
*4*linesize
, linesize
, block
+ off
);
3121 if(apply_filter
&& j
? pat
& 0x3 : (cbp_top
& 0xC))
3122 vc1_loop_filter(dst
+ j
*4*linesize
, 1, linesize
, 8, mquant
);
3123 if(apply_filter
&& cbp_left
& (2 << j
))
3124 vc1_loop_filter(dst
+ j
*4*linesize
, linesize
, 1, 4, mquant
);
3129 pat
= ~(subblkpat
*5) & 0xF;
3130 for(j
= 0; j
< 2; j
++) {
3131 last
= subblkpat
& (1 << (1 - j
));
3135 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3139 idx
= v
->zz_4x8
[i
++]+off
;
3140 block
[idx
] = value
* scale
;
3142 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3144 if(!(subblkpat
& (1 << (1 - j
))) && !skip_block
){
3145 s
->dsp
.vc1_inv_trans_4x8(dst
+ j
*4, linesize
, block
+ off
);
3146 if(apply_filter
&& cbp_top
& (2 << j
))
3147 vc1_loop_filter(dst
+ j
*4, 1, linesize
, 4, mquant
);
3148 if(apply_filter
&& j
? pat
& 0x5 : (cbp_left
& 0xA))
3149 vc1_loop_filter(dst
+ j
*4, linesize
, 1, 8, mquant
);
3158 /** Decode one P-frame MB (in Simple/Main profile)
3160 static int vc1_decode_p_mb(VC1Context
*v
)
3162 MpegEncContext
*s
= &v
->s
;
3163 GetBitContext
*gb
= &s
->gb
;
3165 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3166 int cbp
; /* cbp decoding stuff */
3167 int mqdiff
, mquant
; /* MB quantization */
3168 int ttmb
= v
->ttfrm
; /* MB Transform type */
3170 static const int size_table
[6] = { 0, 2, 3, 4, 5, 8 },
3171 offset_table
[6] = { 0, 1, 3, 7, 15, 31 };
3172 int mb_has_coeffs
= 1; /* last_flag */
3173 int dmv_x
, dmv_y
; /* Differential MV components */
3174 int index
, index1
; /* LUT indexes */
3175 int val
, sign
; /* temp values */
3176 int first_block
= 1;
3178 int skipped
, fourmv
;
3179 int block_cbp
= 0, pat
;
3180 int apply_loop_filter
;
3182 mquant
= v
->pq
; /* Loosy initialization */
3184 if (v
->mv_type_is_raw
)
3185 fourmv
= get_bits1(gb
);
3187 fourmv
= v
->mv_type_mb_plane
[mb_pos
];
3189 skipped
= get_bits1(gb
);
3191 skipped
= v
->s
.mbskip_table
[mb_pos
];
3193 s
->dsp
.clear_blocks(s
->block
[0]);
3195 apply_loop_filter
= s
->loop_filter
&& !(s
->avctx
->skip_loop_filter
>= AVDISCARD_NONKEY
);
3196 if (!fourmv
) /* 1MV mode */
3200 GET_MVDATA(dmv_x
, dmv_y
);
3203 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3204 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3206 s
->current_picture
.mb_type
[mb_pos
] = s
->mb_intra
? MB_TYPE_INTRA
: MB_TYPE_16x16
;
3207 vc1_pred_mv(s
, 0, dmv_x
, dmv_y
, 1, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3209 /* FIXME Set DC val for inter block ? */
3210 if (s
->mb_intra
&& !mb_has_coeffs
)
3213 s
->ac_pred
= get_bits1(gb
);
3216 else if (mb_has_coeffs
)
3218 if (s
->mb_intra
) s
->ac_pred
= get_bits1(gb
);
3219 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3227 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3229 if (!v
->ttmbf
&& !s
->mb_intra
&& mb_has_coeffs
)
3230 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
,
3231 VC1_TTMB_VLC_BITS
, 2);
3232 if(!s
->mb_intra
) vc1_mc_1mv(v
, 0);
3236 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3238 val
= ((cbp
>> (5 - i
)) & 1);
3239 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3240 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3242 /* check if prediction blocks A and C are available */
3243 v
->a_avail
= v
->c_avail
= 0;
3244 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3245 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3246 if(i
== 1 || i
== 3 || s
->mb_x
)
3247 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3249 vc1_decode_intra_block(v
, s
->block
[i
], i
, val
, mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3250 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3251 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3252 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3253 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3254 if(v
->pq
>= 9 && v
->overlap
) {
3256 s
->dsp
.vc1_h_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3258 s
->dsp
.vc1_v_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3260 if(apply_loop_filter
&& s
->mb_x
&& s
->mb_x
!= (s
->mb_width
- 1) && s
->mb_y
&& s
->mb_y
!= (s
->mb_height
- 1)){
3261 int left_cbp
, top_cbp
;
3263 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3264 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3266 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3267 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3270 vc1_loop_filter(s
->dest
[dst_idx
] + off
, 1, i
& 4 ? s
->uvlinesize
: s
->linesize
, 8, mquant
);
3272 vc1_loop_filter(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, 1, 8, mquant
);
3274 block_cbp
|= 0xF << (i
<< 2);
3276 int left_cbp
= 0, top_cbp
= 0, filter
= 0;
3277 if(apply_loop_filter
&& s
->mb_x
&& s
->mb_x
!= (s
->mb_width
- 1) && s
->mb_y
&& s
->mb_y
!= (s
->mb_height
- 1)){
3280 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3281 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3283 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3284 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3287 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
);
3288 block_cbp
|= pat
<< (i
<< 2);
3289 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3297 for(i
= 0; i
< 6; i
++) {
3298 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3299 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3301 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_SKIP
;
3302 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3303 vc1_pred_mv(s
, 0, 0, 0, 1, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3310 if (!skipped
/* unskipped MB */)
3312 int intra_count
= 0, coded_inter
= 0;
3313 int is_intra
[6], is_coded
[6];
3315 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3318 val
= ((cbp
>> (5 - i
)) & 1);
3319 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3326 GET_MVDATA(dmv_x
, dmv_y
);
3328 vc1_pred_mv(s
, i
, dmv_x
, dmv_y
, 0, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3329 if(!s
->mb_intra
) vc1_mc_4mv_luma(v
, i
);
3330 intra_count
+= s
->mb_intra
;
3331 is_intra
[i
] = s
->mb_intra
;
3332 is_coded
[i
] = mb_has_coeffs
;
3335 is_intra
[i
] = (intra_count
>= 3);
3338 if(i
== 4) vc1_mc_4mv_chroma(v
);
3339 v
->mb_type
[0][s
->block_index
[i
]] = is_intra
[i
];
3340 if(!coded_inter
) coded_inter
= !is_intra
[i
] & is_coded
[i
];
3342 // if there are no coded blocks then don't do anything more
3343 if(!intra_count
&& !coded_inter
) return 0;
3346 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3347 /* test if block is intra and has pred */
3352 if(((!s
->first_slice_line
|| (i
==2 || i
==3)) && v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]])
3353 || ((s
->mb_x
|| (i
==1 || i
==3)) && v
->mb_type
[0][s
->block_index
[i
] - 1])) {
3358 if(intrapred
)s
->ac_pred
= get_bits1(gb
);
3359 else s
->ac_pred
= 0;
3361 if (!v
->ttmbf
&& coded_inter
)
3362 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3366 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3367 s
->mb_intra
= is_intra
[i
];
3369 /* check if prediction blocks A and C are available */
3370 v
->a_avail
= v
->c_avail
= 0;
3371 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3372 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3373 if(i
== 1 || i
== 3 || s
->mb_x
)
3374 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3376 vc1_decode_intra_block(v
, s
->block
[i
], i
, is_coded
[i
], mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3377 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3378 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3379 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3380 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, (i
&4)?s
->uvlinesize
:s
->linesize
);
3381 if(v
->pq
>= 9 && v
->overlap
) {
3383 s
->dsp
.vc1_h_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3385 s
->dsp
.vc1_v_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3387 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)){
3388 int left_cbp
, top_cbp
;
3390 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3391 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3393 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3394 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3397 vc1_loop_filter(s
->dest
[dst_idx
] + off
, 1, i
& 4 ? s
->uvlinesize
: s
->linesize
, 8, mquant
);
3399 vc1_loop_filter(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, 1, 8, mquant
);
3401 block_cbp
|= 0xF << (i
<< 2);
3402 } else if(is_coded
[i
]) {
3403 int left_cbp
= 0, top_cbp
= 0, filter
= 0;
3404 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)){
3407 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3408 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3410 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3411 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3414 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
);
3415 block_cbp
|= pat
<< (i
<< 2);
3416 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3425 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3426 for (i
=0; i
<6; i
++) {
3427 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3428 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3432 vc1_pred_mv(s
, i
, 0, 0, 0, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3433 vc1_mc_4mv_luma(v
, i
);
3435 vc1_mc_4mv_chroma(v
);
3436 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3440 v
->cbp
[s
->mb_x
] = block_cbp
;
3442 /* Should never happen */
3446 /** Decode one B-frame MB (in Main profile)
3448 static void vc1_decode_b_mb(VC1Context
*v
)
3450 MpegEncContext
*s
= &v
->s
;
3451 GetBitContext
*gb
= &s
->gb
;
3453 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3454 int cbp
= 0; /* cbp decoding stuff */
3455 int mqdiff
, mquant
; /* MB quantization */
3456 int ttmb
= v
->ttfrm
; /* MB Transform type */
3458 static const int size_table
[6] = { 0, 2, 3, 4, 5, 8 },
3459 offset_table
[6] = { 0, 1, 3, 7, 15, 31 };
3460 int mb_has_coeffs
= 0; /* last_flag */
3461 int index
, index1
; /* LUT indexes */
3462 int val
, sign
; /* temp values */
3463 int first_block
= 1;
3465 int skipped
, direct
;
3466 int dmv_x
[2], dmv_y
[2];
3467 int bmvtype
= BMV_TYPE_BACKWARD
;
3469 mquant
= v
->pq
; /* Loosy initialization */
3473 direct
= get_bits1(gb
);
3475 direct
= v
->direct_mb_plane
[mb_pos
];
3477 skipped
= get_bits1(gb
);
3479 skipped
= v
->s
.mbskip_table
[mb_pos
];
3481 s
->dsp
.clear_blocks(s
->block
[0]);
3482 dmv_x
[0] = dmv_x
[1] = dmv_y
[0] = dmv_y
[1] = 0;
3483 for(i
= 0; i
< 6; i
++) {
3484 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3485 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3487 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3491 GET_MVDATA(dmv_x
[0], dmv_y
[0]);
3492 dmv_x
[1] = dmv_x
[0];
3493 dmv_y
[1] = dmv_y
[0];
3495 if(skipped
|| !s
->mb_intra
) {
3496 bmvtype
= decode012(gb
);
3499 bmvtype
= (v
->bfraction
>= (B_FRACTION_DEN
/2)) ? BMV_TYPE_BACKWARD
: BMV_TYPE_FORWARD
;
3502 bmvtype
= (v
->bfraction
>= (B_FRACTION_DEN
/2)) ? BMV_TYPE_FORWARD
: BMV_TYPE_BACKWARD
;
3505 bmvtype
= BMV_TYPE_INTERPOLATED
;
3506 dmv_x
[0] = dmv_y
[0] = 0;
3510 for(i
= 0; i
< 6; i
++)
3511 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3514 if(direct
) bmvtype
= BMV_TYPE_INTERPOLATED
;
3515 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3516 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3520 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3524 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3526 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3527 dmv_x
[0] = dmv_y
[0] = dmv_x
[1] = dmv_y
[1] = 0;
3528 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3529 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3531 if(!mb_has_coeffs
&& !s
->mb_intra
) {
3532 /* no coded blocks - effectively skipped */
3533 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3534 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3537 if(s
->mb_intra
&& !mb_has_coeffs
) {
3539 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3540 s
->ac_pred
= get_bits1(gb
);
3542 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3544 if(bmvtype
== BMV_TYPE_INTERPOLATED
) {
3545 GET_MVDATA(dmv_x
[0], dmv_y
[0]);
3546 if(!mb_has_coeffs
) {
3547 /* interpolated skipped block */
3548 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3549 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3553 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3555 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3558 s
->ac_pred
= get_bits1(gb
);
3559 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3561 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3562 if(!v
->ttmbf
&& !s
->mb_intra
&& mb_has_coeffs
)
3563 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3569 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3571 val
= ((cbp
>> (5 - i
)) & 1);
3572 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3573 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3575 /* check if prediction blocks A and C are available */
3576 v
->a_avail
= v
->c_avail
= 0;
3577 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3578 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3579 if(i
== 1 || i
== 3 || s
->mb_x
)
3580 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3582 vc1_decode_intra_block(v
, s
->block
[i
], i
, val
, mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3583 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3584 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3585 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3586 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3588 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);
3589 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3595 /** Decode blocks of I-frame
3597 static void vc1_decode_i_blocks(VC1Context
*v
)
3600 MpegEncContext
*s
= &v
->s
;
3605 /* select codingmode used for VLC tables selection */
3606 switch(v
->y_ac_table_index
){
3608 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3611 v
->codingset
= CS_HIGH_MOT_INTRA
;
3614 v
->codingset
= CS_MID_RATE_INTRA
;
3618 switch(v
->c_ac_table_index
){
3620 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3623 v
->codingset2
= CS_HIGH_MOT_INTER
;
3626 v
->codingset2
= CS_MID_RATE_INTER
;
3630 /* Set DC scale - y and c use the same */
3631 s
->y_dc_scale
= s
->y_dc_scale_table
[v
->pq
];
3632 s
->c_dc_scale
= s
->c_dc_scale_table
[v
->pq
];
3635 s
->mb_x
= s
->mb_y
= 0;
3637 s
->first_slice_line
= 1;
3638 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3639 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3640 ff_init_block_index(s
);
3641 ff_update_block_index(s
);
3642 s
->dsp
.clear_blocks(s
->block
[0]);
3643 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_width
;
3644 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_INTRA
;
3645 s
->current_picture
.qscale_table
[mb_pos
] = v
->pq
;
3646 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3647 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3649 // do actual MB decoding and displaying
3650 cbp
= get_vlc2(&v
->s
.gb
, ff_msmp4_mb_i_vlc
.table
, MB_INTRA_VLC_BITS
, 2);
3651 v
->s
.ac_pred
= get_bits1(&v
->s
.gb
);
3653 for(k
= 0; k
< 6; k
++) {
3654 val
= ((cbp
>> (5 - k
)) & 1);
3657 int pred
= vc1_coded_block_pred(&v
->s
, k
, &coded_val
);
3661 cbp
|= val
<< (5 - k
);
3663 vc1_decode_i_block(v
, s
->block
[k
], k
, val
, (k
<4)? v
->codingset
: v
->codingset2
);
3665 s
->dsp
.vc1_inv_trans_8x8(s
->block
[k
]);
3666 if(v
->pq
>= 9 && v
->overlap
) {
3667 for(j
= 0; j
< 64; j
++) s
->block
[k
][j
] += 128;
3671 vc1_put_block(v
, s
->block
);
3672 if(v
->pq
>= 9 && v
->overlap
) {
3674 s
->dsp
.vc1_h_overlap(s
->dest
[0], s
->linesize
);
3675 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3676 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3677 s
->dsp
.vc1_h_overlap(s
->dest
[1], s
->uvlinesize
);
3678 s
->dsp
.vc1_h_overlap(s
->dest
[2], s
->uvlinesize
);
3681 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8, s
->linesize
);
3682 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3683 if(!s
->first_slice_line
) {
3684 s
->dsp
.vc1_v_overlap(s
->dest
[0], s
->linesize
);
3685 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8, s
->linesize
);
3686 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3687 s
->dsp
.vc1_v_overlap(s
->dest
[1], s
->uvlinesize
);
3688 s
->dsp
.vc1_v_overlap(s
->dest
[2], s
->uvlinesize
);
3691 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3692 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3694 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, s
->current_picture
.qscale_table
[mb_pos
]);
3696 if(get_bits_count(&s
->gb
) > v
->bits
) {
3697 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3698 av_log(s
->avctx
, AV_LOG_ERROR
, "Bits overconsumption: %i > %i\n", get_bits_count(&s
->gb
), v
->bits
);
3702 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3703 s
->first_slice_line
= 0;
3705 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3708 /** Decode blocks of I-frame for advanced profile
3710 static void vc1_decode_i_blocks_adv(VC1Context
*v
)
3713 MpegEncContext
*s
= &v
->s
;
3720 GetBitContext
*gb
= &s
->gb
;
3722 /* select codingmode used for VLC tables selection */
3723 switch(v
->y_ac_table_index
){
3725 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3728 v
->codingset
= CS_HIGH_MOT_INTRA
;
3731 v
->codingset
= CS_MID_RATE_INTRA
;
3735 switch(v
->c_ac_table_index
){
3737 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3740 v
->codingset2
= CS_HIGH_MOT_INTER
;
3743 v
->codingset2
= CS_MID_RATE_INTER
;
3748 s
->mb_x
= s
->mb_y
= 0;
3750 s
->first_slice_line
= 1;
3751 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3752 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3753 ff_init_block_index(s
);
3754 ff_update_block_index(s
);
3755 s
->dsp
.clear_blocks(s
->block
[0]);
3756 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3757 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_INTRA
;
3758 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3759 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3761 // do actual MB decoding and displaying
3762 cbp
= get_vlc2(&v
->s
.gb
, ff_msmp4_mb_i_vlc
.table
, MB_INTRA_VLC_BITS
, 2);
3763 if(v
->acpred_is_raw
)
3764 v
->s
.ac_pred
= get_bits1(&v
->s
.gb
);
3766 v
->s
.ac_pred
= v
->acpred_plane
[mb_pos
];
3768 if(v
->condover
== CONDOVER_SELECT
) {
3769 if(v
->overflg_is_raw
)
3770 overlap
= get_bits1(&v
->s
.gb
);
3772 overlap
= v
->over_flags_plane
[mb_pos
];
3774 overlap
= (v
->condover
== CONDOVER_ALL
);
3778 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3779 /* Set DC scale - y and c use the same */
3780 s
->y_dc_scale
= s
->y_dc_scale_table
[mquant
];
3781 s
->c_dc_scale
= s
->c_dc_scale_table
[mquant
];
3783 for(k
= 0; k
< 6; k
++) {
3784 val
= ((cbp
>> (5 - k
)) & 1);
3787 int pred
= vc1_coded_block_pred(&v
->s
, k
, &coded_val
);
3791 cbp
|= val
<< (5 - k
);
3793 v
->a_avail
= !s
->first_slice_line
|| (k
==2 || k
==3);
3794 v
->c_avail
= !!s
->mb_x
|| (k
==1 || k
==3);
3796 vc1_decode_i_block_adv(v
, s
->block
[k
], k
, val
, (k
<4)? v
->codingset
: v
->codingset2
, mquant
);
3798 s
->dsp
.vc1_inv_trans_8x8(s
->block
[k
]);
3799 for(j
= 0; j
< 64; j
++) s
->block
[k
][j
] += 128;
3802 vc1_put_block(v
, s
->block
);
3805 s
->dsp
.vc1_h_overlap(s
->dest
[0], s
->linesize
);
3806 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3807 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3808 s
->dsp
.vc1_h_overlap(s
->dest
[1], s
->uvlinesize
);
3809 s
->dsp
.vc1_h_overlap(s
->dest
[2], s
->uvlinesize
);
3812 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8, s
->linesize
);
3813 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3814 if(!s
->first_slice_line
) {
3815 s
->dsp
.vc1_v_overlap(s
->dest
[0], s
->linesize
);
3816 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8, s
->linesize
);
3817 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3818 s
->dsp
.vc1_v_overlap(s
->dest
[1], s
->uvlinesize
);
3819 s
->dsp
.vc1_v_overlap(s
->dest
[2], s
->uvlinesize
);
3822 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3823 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3825 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, s
->current_picture
.qscale_table
[mb_pos
]);
3827 if(get_bits_count(&s
->gb
) > v
->bits
) {
3828 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3829 av_log(s
->avctx
, AV_LOG_ERROR
, "Bits overconsumption: %i > %i\n", get_bits_count(&s
->gb
), v
->bits
);
3833 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3834 s
->first_slice_line
= 0;
3836 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3839 static void vc1_decode_p_blocks(VC1Context
*v
)
3841 MpegEncContext
*s
= &v
->s
;
3843 /* select codingmode used for VLC tables selection */
3844 switch(v
->c_ac_table_index
){
3846 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3849 v
->codingset
= CS_HIGH_MOT_INTRA
;
3852 v
->codingset
= CS_MID_RATE_INTRA
;
3856 switch(v
->c_ac_table_index
){
3858 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3861 v
->codingset2
= CS_HIGH_MOT_INTER
;
3864 v
->codingset2
= CS_MID_RATE_INTER
;
3868 s
->first_slice_line
= 1;
3869 memset(v
->cbp_base
, 0, sizeof(v
->cbp_base
[0])*2*s
->mb_stride
);
3870 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3871 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3872 ff_init_block_index(s
);
3873 ff_update_block_index(s
);
3874 s
->dsp
.clear_blocks(s
->block
[0]);
3877 if(get_bits_count(&s
->gb
) > v
->bits
|| get_bits_count(&s
->gb
) < 0) {
3878 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3879 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
);
3883 memmove(v
->cbp_base
, v
->cbp
, sizeof(v
->cbp_base
[0])*s
->mb_stride
);
3884 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3885 s
->first_slice_line
= 0;
3887 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3890 static void vc1_decode_b_blocks(VC1Context
*v
)
3892 MpegEncContext
*s
= &v
->s
;
3894 /* select codingmode used for VLC tables selection */
3895 switch(v
->c_ac_table_index
){
3897 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3900 v
->codingset
= CS_HIGH_MOT_INTRA
;
3903 v
->codingset
= CS_MID_RATE_INTRA
;
3907 switch(v
->c_ac_table_index
){
3909 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3912 v
->codingset2
= CS_HIGH_MOT_INTER
;
3915 v
->codingset2
= CS_MID_RATE_INTER
;
3919 s
->first_slice_line
= 1;
3920 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3921 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3922 ff_init_block_index(s
);
3923 ff_update_block_index(s
);
3924 s
->dsp
.clear_blocks(s
->block
[0]);
3927 if(get_bits_count(&s
->gb
) > v
->bits
|| get_bits_count(&s
->gb
) < 0) {
3928 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3929 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
);
3932 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, s
->current_picture
.qscale_table
[s
->mb_x
+ s
->mb_y
*s
->mb_stride
]);
3934 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3935 s
->first_slice_line
= 0;
3937 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3940 static void vc1_decode_skip_blocks(VC1Context
*v
)
3942 MpegEncContext
*s
= &v
->s
;
3944 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3945 s
->first_slice_line
= 1;
3946 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3948 ff_init_block_index(s
);
3949 ff_update_block_index(s
);
3950 memcpy(s
->dest
[0], s
->last_picture
.data
[0] + s
->mb_y
* 16 * s
->linesize
, s
->linesize
* 16);
3951 memcpy(s
->dest
[1], s
->last_picture
.data
[1] + s
->mb_y
* 8 * s
->uvlinesize
, s
->uvlinesize
* 8);
3952 memcpy(s
->dest
[2], s
->last_picture
.data
[2] + s
->mb_y
* 8 * s
->uvlinesize
, s
->uvlinesize
* 8);
3953 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3954 s
->first_slice_line
= 0;
3956 s
->pict_type
= FF_P_TYPE
;
3959 static void vc1_decode_blocks(VC1Context
*v
)
3962 v
->s
.esc3_level_length
= 0;
3964 ff_intrax8_decode_picture(&v
->x8
, 2*v
->pq
+v
->halfpq
, v
->pq
*(!v
->pquantizer
) );
3967 switch(v
->s
.pict_type
) {
3969 if(v
->profile
== PROFILE_ADVANCED
)
3970 vc1_decode_i_blocks_adv(v
);
3972 vc1_decode_i_blocks(v
);
3975 if(v
->p_frame_skipped
)
3976 vc1_decode_skip_blocks(v
);
3978 vc1_decode_p_blocks(v
);
3982 if(v
->profile
== PROFILE_ADVANCED
)
3983 vc1_decode_i_blocks_adv(v
);
3985 vc1_decode_i_blocks(v
);
3987 vc1_decode_b_blocks(v
);
3993 /** Find VC-1 marker in buffer
3994 * @return position where next marker starts or end of buffer if no marker found
3996 static av_always_inline
const uint8_t* find_next_marker(const uint8_t *src
, const uint8_t *end
)
3998 uint32_t mrk
= 0xFFFFFFFF;
4000 if(end
-src
< 4) return end
;
4002 mrk
= (mrk
<< 8) | *src
++;
4009 static av_always_inline
int vc1_unescape_buffer(const uint8_t *src
, int size
, uint8_t *dst
)
4014 for(dsize
= 0; dsize
< size
; dsize
++) *dst
++ = *src
++;
4017 for(i
= 0; i
< size
; i
++, src
++) {
4018 if(src
[0] == 3 && i
>= 2 && !src
[-1] && !src
[-2] && i
< size
-1 && src
[1] < 4) {
4019 dst
[dsize
++] = src
[1];
4023 dst
[dsize
++] = *src
;
4028 /** Initialize a VC1/WMV3 decoder
4029 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4030 * @todo TODO: Decypher remaining bits in extra_data
4032 static av_cold
int vc1_decode_init(AVCodecContext
*avctx
)
4034 VC1Context
*v
= avctx
->priv_data
;
4035 MpegEncContext
*s
= &v
->s
;
4038 if (!avctx
->extradata_size
|| !avctx
->extradata
) return -1;
4039 if (!(avctx
->flags
& CODEC_FLAG_GRAY
))
4040 avctx
->pix_fmt
= PIX_FMT_YUV420P
;
4042 avctx
->pix_fmt
= PIX_FMT_GRAY8
;
4044 avctx
->flags
|= CODEC_FLAG_EMU_EDGE
;
4045 v
->s
.flags
|= CODEC_FLAG_EMU_EDGE
;
4047 if(avctx
->idct_algo
==FF_IDCT_AUTO
){
4048 avctx
->idct_algo
=FF_IDCT_WMV2
;
4051 if(ff_h263_decode_init(avctx
) < 0)
4053 if (vc1_init_common(v
) < 0) return -1;
4055 avctx
->coded_width
= avctx
->width
;
4056 avctx
->coded_height
= avctx
->height
;
4057 if ((avctx
->codec_id
== CODEC_ID_WMV3
) || (avctx
->codec_id
== CODEC_ID_WMV3_VDPAU
))
4061 // looks like WMV3 has a sequence header stored in the extradata
4062 // advanced sequence header may be before the first frame
4063 // the last byte of the extradata is a version number, 1 for the
4064 // samples we can decode
4066 init_get_bits(&gb
, avctx
->extradata
, avctx
->extradata_size
*8);
4068 if (decode_sequence_header(avctx
, &gb
) < 0)
4071 count
= avctx
->extradata_size
*8 - get_bits_count(&gb
);
4074 av_log(avctx
, AV_LOG_INFO
, "Extra data: %i bits left, value: %X\n",
4075 count
, get_bits(&gb
, count
));
4079 av_log(avctx
, AV_LOG_INFO
, "Read %i bits in overflow\n", -count
);
4081 } else { // VC1/WVC1
4082 const uint8_t *start
= avctx
->extradata
;
4083 uint8_t *end
= avctx
->extradata
+ avctx
->extradata_size
;
4084 const uint8_t *next
;
4085 int size
, buf2_size
;
4086 uint8_t *buf2
= NULL
;
4087 int seq_initialized
= 0, ep_initialized
= 0;
4089 if(avctx
->extradata_size
< 16) {
4090 av_log(avctx
, AV_LOG_ERROR
, "Extradata size too small: %i\n", avctx
->extradata_size
);
4094 buf2
= av_mallocz(avctx
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
4095 if(start
[0]) start
++; // in WVC1 extradata first byte is its size
4097 for(; next
< end
; start
= next
){
4098 next
= find_next_marker(start
+ 4, end
);
4099 size
= next
- start
- 4;
4100 if(size
<= 0) continue;
4101 buf2_size
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4102 init_get_bits(&gb
, buf2
, buf2_size
* 8);
4103 switch(AV_RB32(start
)){
4104 case VC1_CODE_SEQHDR
:
4105 if(decode_sequence_header(avctx
, &gb
) < 0){
4109 seq_initialized
= 1;
4111 case VC1_CODE_ENTRYPOINT
:
4112 if(decode_entry_point(avctx
, &gb
) < 0){
4121 if(!seq_initialized
|| !ep_initialized
){
4122 av_log(avctx
, AV_LOG_ERROR
, "Incomplete extradata\n");
4126 avctx
->has_b_frames
= !!(avctx
->max_b_frames
);
4127 s
->low_delay
= !avctx
->has_b_frames
;
4129 s
->mb_width
= (avctx
->coded_width
+15)>>4;
4130 s
->mb_height
= (avctx
->coded_height
+15)>>4;
4132 /* Allocate mb bitplanes */
4133 v
->mv_type_mb_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4134 v
->direct_mb_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4135 v
->acpred_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4136 v
->over_flags_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4138 v
->cbp_base
= av_malloc(sizeof(v
->cbp_base
[0]) * 2 * s
->mb_stride
);
4139 v
->cbp
= v
->cbp_base
+ s
->mb_stride
;
4141 /* allocate block type info in that way so it could be used with s->block_index[] */
4142 v
->mb_type_base
= av_malloc(s
->b8_stride
* (s
->mb_height
* 2 + 1) + s
->mb_stride
* (s
->mb_height
+ 1) * 2);
4143 v
->mb_type
[0] = v
->mb_type_base
+ s
->b8_stride
+ 1;
4144 v
->mb_type
[1] = v
->mb_type_base
+ s
->b8_stride
* (s
->mb_height
* 2 + 1) + s
->mb_stride
+ 1;
4145 v
->mb_type
[2] = v
->mb_type
[1] + s
->mb_stride
* (s
->mb_height
+ 1);
4147 /* Init coded blocks info */
4148 if (v
->profile
== PROFILE_ADVANCED
)
4150 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
4152 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
4156 ff_intrax8_common_init(&v
->x8
,s
);
4161 /** Decode a VC1/WMV3 frame
4162 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4164 static int vc1_decode_frame(AVCodecContext
*avctx
,
4165 void *data
, int *data_size
,
4166 const uint8_t *buf
, int buf_size
)
4168 VC1Context
*v
= avctx
->priv_data
;
4169 MpegEncContext
*s
= &v
->s
;
4170 AVFrame
*pict
= data
;
4171 uint8_t *buf2
= NULL
;
4173 const uint8_t *buf_vdpau
= buf
;
4176 /* no supplementary picture */
4177 if (buf_size
== 0) {
4178 /* special case for last picture */
4179 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
4180 *pict
= *(AVFrame
*)s
->next_picture_ptr
;
4181 s
->next_picture_ptr
= NULL
;
4183 *data_size
= sizeof(AVFrame
);
4189 /* We need to set current_picture_ptr before reading the header,
4190 * otherwise we cannot store anything in there. */
4191 if(s
->current_picture_ptr
==NULL
|| s
->current_picture_ptr
->data
[0]){
4192 int i
= ff_find_unused_picture(s
, 0);
4193 s
->current_picture_ptr
= &s
->picture
[i
];
4197 // pxt_fmt calculation for VDPAU.
4198 if (decode_postinit(v
, avctx
) < 0)
4202 //for advanced profile we may need to parse and unescape data
4203 if ((avctx
->codec_id
== CODEC_ID_VC1
) || (avctx
->codec_id
== CODEC_ID_VC1_VDPAU
)) {
4205 buf2
= av_mallocz(buf_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
4207 if(IS_MARKER(AV_RB32(buf
))){ /* frame starts with marker and needs to be parsed */
4208 const uint8_t *start
, *end
, *next
;
4212 for(start
= buf
, end
= buf
+ buf_size
; next
< end
; start
= next
){
4213 next
= find_next_marker(start
+ 4, end
);
4214 size
= next
- start
- 4;
4215 if(size
<= 0) continue;
4216 switch(AV_RB32(start
)){
4217 case VC1_CODE_FRAME
:
4221 buf_size2
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4223 case VC1_CODE_ENTRYPOINT
: /* it should be before frame data */
4224 buf_size2
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4225 init_get_bits(&s
->gb
, buf2
, buf_size2
*8);
4226 decode_entry_point(avctx
, &s
->gb
);
4228 case VC1_CODE_SLICE
:
4229 av_log(avctx
, AV_LOG_ERROR
, "Sliced decoding is not implemented (yet)\n");
4234 }else if(v
->interlace
&& ((buf
[0] & 0xC0) == 0xC0)){ /* WVC1 interlaced stores both fields divided by marker */
4235 const uint8_t *divider
;
4237 divider
= find_next_marker(buf
, buf
+ buf_size
);
4238 if((divider
== (buf
+ buf_size
)) || AV_RB32(divider
) != VC1_CODE_FIELD
){
4239 av_log(avctx
, AV_LOG_ERROR
, "Error in WVC1 interlaced frame\n");
4244 buf_size2
= vc1_unescape_buffer(buf
, divider
- buf
, buf2
);
4246 av_free(buf2
);return -1;
4248 buf_size2
= vc1_unescape_buffer(buf
, buf_size
, buf2
);
4250 init_get_bits(&s
->gb
, buf2
, buf_size2
*8);
4252 init_get_bits(&s
->gb
, buf
, buf_size
*8);
4253 // do parse frame header
4254 if(v
->profile
< PROFILE_ADVANCED
) {
4255 if(vc1_parse_frame_header(v
, &s
->gb
) == -1) {
4260 if(vc1_parse_frame_header_adv(v
, &s
->gb
) == -1) {
4266 if(s
->pict_type
!= FF_I_TYPE
&& !v
->res_rtm_flag
){
4272 s
->current_picture
.pict_type
= s
->pict_type
;
4273 s
->current_picture
.key_frame
= s
->pict_type
== FF_I_TYPE
;
4275 /* skip B-frames if we don't have reference frames */
4276 if(s
->last_picture_ptr
==NULL
&& (s
->pict_type
==FF_B_TYPE
|| s
->dropable
)){
4278 return -1;//buf_size;
4280 /* skip b frames if we are in a hurry */
4281 if(avctx
->hurry_up
&& s
->pict_type
==FF_B_TYPE
) return -1;//buf_size;
4282 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& s
->pict_type
==FF_B_TYPE
)
4283 || (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& s
->pict_type
!=FF_I_TYPE
)
4284 || avctx
->skip_frame
>= AVDISCARD_ALL
) {
4288 /* skip everything if we are in a hurry>=5 */
4289 if(avctx
->hurry_up
>=5) {
4291 return -1;//buf_size;
4294 if(s
->next_p_frame_damaged
){
4295 if(s
->pict_type
==FF_B_TYPE
)
4298 s
->next_p_frame_damaged
=0;
4301 if(MPV_frame_start(s
, avctx
) < 0) {
4307 // MPV_frame_start() calls to get_buffer/videoSurfaces. Now we call
4308 // VDPAU_vc1_field_start where picture-parameters are filled.
4309 // VDPAU_vc1_picture_complete calls to vdpau_decoder_render.
4311 if (avctx
->vdpau_acceleration
) {
4312 if (ff_VDPAU_vc1_decode_picture(s
, avctx
, v
, buf_vdpau
, (buf
+ buf_size
) - buf_vdpau
) < 0) {
4319 s
->me
.qpel_put
= s
->dsp
.put_qpel_pixels_tab
;
4320 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
4323 if (!avctx
->vdpau_acceleration
) {
4325 ff_er_frame_start(s
);
4327 v
->bits
= buf_size
* 8;
4328 vc1_decode_blocks(v
);
4329 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
4330 // if(get_bits_count(&s->gb) > buf_size * 8)
4339 assert(s
->current_picture
.pict_type
== s
->current_picture_ptr
->pict_type
);
4340 assert(s
->current_picture
.pict_type
== s
->pict_type
);
4341 if (s
->pict_type
== FF_B_TYPE
|| s
->low_delay
) {
4342 *pict
= *(AVFrame
*)s
->current_picture_ptr
;
4343 } else if (s
->last_picture_ptr
!= NULL
) {
4344 *pict
= *(AVFrame
*)s
->last_picture_ptr
;
4347 if(s
->last_picture_ptr
|| s
->low_delay
){
4348 *data_size
= sizeof(AVFrame
);
4349 ff_print_debug_info(s
, pict
);
4352 /* Return the Picture timestamp as the frame number */
4353 /* we subtract 1 because it is added on utils.c */
4354 avctx
->frame_number
= s
->picture_number
- 1;
4361 /** Close a VC1/WMV3 decoder
4362 * @warning Initial try at using MpegEncContext stuff
4364 static av_cold
int vc1_decode_end(AVCodecContext
*avctx
)
4366 VC1Context
*v
= avctx
->priv_data
;
4368 av_freep(&v
->hrd_rate
);
4369 av_freep(&v
->hrd_buffer
);
4370 MPV_common_end(&v
->s
);
4371 av_freep(&v
->mv_type_mb_plane
);
4372 av_freep(&v
->direct_mb_plane
);
4373 av_freep(&v
->acpred_plane
);
4374 av_freep(&v
->over_flags_plane
);
4375 av_freep(&v
->mb_type_base
);
4376 av_freep(&v
->cbp_base
);
4377 ff_intrax8_common_end(&v
->x8
);
4382 AVCodec vc1_decoder
= {
4393 .long_name
= NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
4396 AVCodec wmv3_decoder
= {
4407 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
4411 static av_cold
int vc1_vdpau_decode_init(AVCodecContext
*avctx
){
4412 if( avctx
->thread_count
> 1)
4414 if( !(avctx
->slice_flags
& SLICE_FLAG_CODED_ORDER
) )
4416 if( !(avctx
->slice_flags
& SLICE_FLAG_ALLOW_FIELD
) ){
4417 dprintf(avctx
, "vc1.c: VDPAU decoder does not set SLICE_FLAG_ALLOW_FIELD\n");
4419 avctx
->vdpau_acceleration
= 1;
4420 vc1_decode_init(avctx
);
4421 avctx
->pix_fmt
= PIX_FMT_NONE
;
4426 AVCodec wmv3_vdpau_decoder
= {
4429 CODEC_ID_WMV3_VDPAU
,
4431 vc1_vdpau_decode_init
,
4435 CODEC_CAP_DR1
| CODEC_CAP_DELAY
| CODEC_CAP_HWACCEL_VDPAU
,
4437 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
4440 AVCodec vc1_vdpau_decoder
= {
4445 vc1_vdpau_decode_init
,
4449 CODEC_CAP_DR1
| CODEC_CAP_DELAY
| CODEC_CAP_HWACCEL_VDPAU
,
4451 .long_name
= NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),