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
44 static const uint16_t table_mb_intra
[64][2];
48 * Init VC-1 specific tables and VC1Context members
49 * @param v The VC1Context to initialize
52 static int vc1_init_common(VC1Context
*v
)
57 v
->hrd_rate
= v
->hrd_buffer
= NULL
;
63 init_vlc(&ff_vc1_bfraction_vlc
, VC1_BFRACTION_VLC_BITS
, 23,
64 ff_vc1_bfraction_bits
, 1, 1,
65 ff_vc1_bfraction_codes
, 1, 1, 1);
66 init_vlc(&ff_vc1_norm2_vlc
, VC1_NORM2_VLC_BITS
, 4,
67 ff_vc1_norm2_bits
, 1, 1,
68 ff_vc1_norm2_codes
, 1, 1, 1);
69 init_vlc(&ff_vc1_norm6_vlc
, VC1_NORM6_VLC_BITS
, 64,
70 ff_vc1_norm6_bits
, 1, 1,
71 ff_vc1_norm6_codes
, 2, 2, 1);
72 init_vlc(&ff_vc1_imode_vlc
, VC1_IMODE_VLC_BITS
, 7,
73 ff_vc1_imode_bits
, 1, 1,
74 ff_vc1_imode_codes
, 1, 1, 1);
77 init_vlc(&ff_vc1_ttmb_vlc
[i
], VC1_TTMB_VLC_BITS
, 16,
78 ff_vc1_ttmb_bits
[i
], 1, 1,
79 ff_vc1_ttmb_codes
[i
], 2, 2, 1);
80 init_vlc(&ff_vc1_ttblk_vlc
[i
], VC1_TTBLK_VLC_BITS
, 8,
81 ff_vc1_ttblk_bits
[i
], 1, 1,
82 ff_vc1_ttblk_codes
[i
], 1, 1, 1);
83 init_vlc(&ff_vc1_subblkpat_vlc
[i
], VC1_SUBBLKPAT_VLC_BITS
, 15,
84 ff_vc1_subblkpat_bits
[i
], 1, 1,
85 ff_vc1_subblkpat_codes
[i
], 1, 1, 1);
89 init_vlc(&ff_vc1_4mv_block_pattern_vlc
[i
], VC1_4MV_BLOCK_PATTERN_VLC_BITS
, 16,
90 ff_vc1_4mv_block_pattern_bits
[i
], 1, 1,
91 ff_vc1_4mv_block_pattern_codes
[i
], 1, 1, 1);
92 init_vlc(&ff_vc1_cbpcy_p_vlc
[i
], VC1_CBPCY_P_VLC_BITS
, 64,
93 ff_vc1_cbpcy_p_bits
[i
], 1, 1,
94 ff_vc1_cbpcy_p_codes
[i
], 2, 2, 1);
95 init_vlc(&ff_vc1_mv_diff_vlc
[i
], VC1_MV_DIFF_VLC_BITS
, 73,
96 ff_vc1_mv_diff_bits
[i
], 1, 1,
97 ff_vc1_mv_diff_codes
[i
], 2, 2, 1);
100 init_vlc(&ff_vc1_ac_coeff_table
[i
], AC_VLC_BITS
, vc1_ac_sizes
[i
],
101 &vc1_ac_tables
[i
][0][1], 8, 4,
102 &vc1_ac_tables
[i
][0][0], 8, 4, 1);
103 init_vlc(&ff_msmp4_mb_i_vlc
, MB_INTRA_VLC_BITS
, 64,
104 &ff_msmp4_mb_i_table
[0][1], 4, 2,
105 &ff_msmp4_mb_i_table
[0][0], 4, 2, 1);
110 v
->mvrange
= 0; /* 7.1.1.18, p80 */
115 /***********************************************************************/
117 * @defgroup bitplane VC9 Bitplane decoding
122 /** @addtogroup bitplane
135 /** @} */ //imode defines
137 /** Decode rows by checking if they are skipped
138 * @param plane Buffer to store decoded bits
139 * @param[in] width Width of this buffer
140 * @param[in] height Height of this buffer
141 * @param[in] stride of this buffer
143 static void decode_rowskip(uint8_t* plane
, int width
, int height
, int stride
, GetBitContext
*gb
){
146 for (y
=0; y
<height
; y
++){
147 if (!get_bits1(gb
)) //rowskip
148 memset(plane
, 0, width
);
150 for (x
=0; x
<width
; x
++)
151 plane
[x
] = get_bits1(gb
);
156 /** Decode columns by checking if they are skipped
157 * @param plane Buffer to store decoded bits
158 * @param[in] width Width of this buffer
159 * @param[in] height Height of this buffer
160 * @param[in] stride of this buffer
161 * @todo FIXME: Optimize
163 static void decode_colskip(uint8_t* plane
, int width
, int height
, int stride
, GetBitContext
*gb
){
166 for (x
=0; x
<width
; x
++){
167 if (!get_bits1(gb
)) //colskip
168 for (y
=0; y
<height
; y
++)
171 for (y
=0; y
<height
; y
++)
172 plane
[y
*stride
] = get_bits1(gb
);
177 /** Decode a bitplane's bits
178 * @param bp Bitplane where to store the decode bits
179 * @param v VC-1 context for bit reading and logging
181 * @todo FIXME: Optimize
183 static int bitplane_decoding(uint8_t* data
, int *raw_flag
, VC1Context
*v
)
185 GetBitContext
*gb
= &v
->s
.gb
;
187 int imode
, x
, y
, code
, offset
;
188 uint8_t invert
, *planep
= data
;
189 int width
, height
, stride
;
191 width
= v
->s
.mb_width
;
192 height
= v
->s
.mb_height
;
193 stride
= v
->s
.mb_stride
;
194 invert
= get_bits1(gb
);
195 imode
= get_vlc2(gb
, ff_vc1_imode_vlc
.table
, VC1_IMODE_VLC_BITS
, 1);
201 //Data is actually read in the MB layer (same for all tests == "raw")
202 *raw_flag
= 1; //invert ignored
206 if ((height
* width
) & 1)
208 *planep
++ = get_bits1(gb
);
212 // decode bitplane as one long line
213 for (y
= offset
; y
< height
* width
; y
+= 2) {
214 code
= get_vlc2(gb
, ff_vc1_norm2_vlc
.table
, VC1_NORM2_VLC_BITS
, 1);
215 *planep
++ = code
& 1;
217 if(offset
== width
) {
219 planep
+= stride
- width
;
221 *planep
++ = code
>> 1;
223 if(offset
== width
) {
225 planep
+= stride
- width
;
231 if(!(height
% 3) && (width
% 3)) { // use 2x3 decoding
232 for(y
= 0; y
< height
; y
+= 3) {
233 for(x
= width
& 1; x
< width
; x
+= 2) {
234 code
= get_vlc2(gb
, ff_vc1_norm6_vlc
.table
, VC1_NORM6_VLC_BITS
, 2);
236 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "invalid NORM-6 VLC\n");
239 planep
[x
+ 0] = (code
>> 0) & 1;
240 planep
[x
+ 1] = (code
>> 1) & 1;
241 planep
[x
+ 0 + stride
] = (code
>> 2) & 1;
242 planep
[x
+ 1 + stride
] = (code
>> 3) & 1;
243 planep
[x
+ 0 + stride
* 2] = (code
>> 4) & 1;
244 planep
[x
+ 1 + stride
* 2] = (code
>> 5) & 1;
246 planep
+= stride
* 3;
248 if(width
& 1) decode_colskip(data
, 1, height
, stride
, &v
->s
.gb
);
250 planep
+= (height
& 1) * stride
;
251 for(y
= height
& 1; y
< height
; y
+= 2) {
252 for(x
= width
% 3; x
< width
; x
+= 3) {
253 code
= get_vlc2(gb
, ff_vc1_norm6_vlc
.table
, VC1_NORM6_VLC_BITS
, 2);
255 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "invalid NORM-6 VLC\n");
258 planep
[x
+ 0] = (code
>> 0) & 1;
259 planep
[x
+ 1] = (code
>> 1) & 1;
260 planep
[x
+ 2] = (code
>> 2) & 1;
261 planep
[x
+ 0 + stride
] = (code
>> 3) & 1;
262 planep
[x
+ 1 + stride
] = (code
>> 4) & 1;
263 planep
[x
+ 2 + stride
] = (code
>> 5) & 1;
265 planep
+= stride
* 2;
268 if(x
) decode_colskip(data
, x
, height
, stride
, &v
->s
.gb
);
269 if(height
& 1) decode_rowskip(data
+x
, width
- x
, 1, stride
, &v
->s
.gb
);
273 decode_rowskip(data
, width
, height
, stride
, &v
->s
.gb
);
276 decode_colskip(data
, width
, height
, stride
, &v
->s
.gb
);
281 /* Applying diff operator */
282 if (imode
== IMODE_DIFF2
|| imode
== IMODE_DIFF6
)
286 for (x
=1; x
<width
; x
++)
287 planep
[x
] ^= planep
[x
-1];
288 for (y
=1; y
<height
; y
++)
291 planep
[0] ^= planep
[-stride
];
292 for (x
=1; x
<width
; x
++)
294 if (planep
[x
-1] != planep
[x
-stride
]) planep
[x
] ^= invert
;
295 else planep
[x
] ^= planep
[x
-1];
302 for (x
=0; x
<stride
*height
; x
++) planep
[x
] = !planep
[x
]; //FIXME stride
304 return (imode
<<1) + invert
;
307 /** @} */ //Bitplane group
309 #define FILTSIGN(a) ((a) >= 0 ? 1 : -1)
311 * VC-1 in-loop deblocking filter for one line
312 * @param src source block type
313 * @param pq block quantizer
314 * @return whether other 3 pairs should be filtered or not
317 static int vc1_filter_line(uint8_t* src
, int stride
, int pq
){
318 int a0
, a1
, a2
, a3
, d
, clip
, filt3
= 0;
319 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
321 a0
= (2*(src
[-2*stride
] - src
[ 1*stride
]) - 5*(src
[-1*stride
] - src
[ 0*stride
]) + 4) >> 3;
323 a1
= (2*(src
[-4*stride
] - src
[-1*stride
]) - 5*(src
[-3*stride
] - src
[-2*stride
]) + 4) >> 3;
324 a2
= (2*(src
[ 0*stride
] - src
[ 3*stride
]) - 5*(src
[ 1*stride
] - src
[ 2*stride
]) + 4) >> 3;
325 a3
= FFMIN(FFABS(a1
), FFABS(a2
));
327 d
= 5 * ((a0
>=0 ? a3
: -a3
) - a0
) / 8;
328 clip
= (src
[-1*stride
] - src
[ 0*stride
])/2;
332 d
= av_clip(d
, 0, clip
);
334 d
= av_clip(d
, clip
, 0);
335 src
[-1*stride
] = cm
[src
[-1*stride
] - d
];
336 src
[ 0*stride
] = cm
[src
[ 0*stride
] + d
];
344 * VC-1 in-loop deblocking filter
345 * @param src source block type
346 * @param len edge length to filter (4 or 8 pixels)
347 * @param pq block quantizer
350 static void vc1_loop_filter(uint8_t* src
, int step
, int stride
, int len
, int pq
)
355 for(i
= 0; i
< len
; i
+= 4){
356 filt3
= vc1_filter_line(src
+ 2*step
, stride
, pq
);
358 vc1_filter_line(src
+ 0*step
, stride
, pq
);
359 vc1_filter_line(src
+ 1*step
, stride
, pq
);
360 vc1_filter_line(src
+ 3*step
, stride
, pq
);
366 static void vc1_loop_filter_iblk(MpegEncContext
*s
, int pq
)
369 if(!s
->first_slice_line
)
370 vc1_loop_filter(s
->dest
[0], 1, s
->linesize
, 16, pq
);
371 vc1_loop_filter(s
->dest
[0] + 8*s
->linesize
, 1, s
->linesize
, 16, pq
);
372 for(i
= !s
->mb_x
*8; i
< 16; i
+= 8)
373 vc1_loop_filter(s
->dest
[0] + i
, s
->linesize
, 1, 16, pq
);
374 for(j
= 0; j
< 2; j
++){
375 if(!s
->first_slice_line
)
376 vc1_loop_filter(s
->dest
[j
+1], 1, s
->uvlinesize
, 8, pq
);
378 vc1_loop_filter(s
->dest
[j
+1], s
->uvlinesize
, 1, 8, pq
);
382 /***********************************************************************/
383 /** VOP Dquant decoding
384 * @param v VC-1 Context
386 static int vop_dquant_decoding(VC1Context
*v
)
388 GetBitContext
*gb
= &v
->s
.gb
;
394 pqdiff
= get_bits(gb
, 3);
395 if (pqdiff
== 7) v
->altpq
= get_bits(gb
, 5);
396 else v
->altpq
= v
->pq
+ pqdiff
+ 1;
400 v
->dquantfrm
= get_bits1(gb
);
403 v
->dqprofile
= get_bits(gb
, 2);
404 switch (v
->dqprofile
)
406 case DQPROFILE_SINGLE_EDGE
:
407 case DQPROFILE_DOUBLE_EDGES
:
408 v
->dqsbedge
= get_bits(gb
, 2);
410 case DQPROFILE_ALL_MBS
:
411 v
->dqbilevel
= get_bits1(gb
);
414 default: break; //Forbidden ?
416 if (v
->dqbilevel
|| v
->dqprofile
!= DQPROFILE_ALL_MBS
)
418 pqdiff
= get_bits(gb
, 3);
419 if (pqdiff
== 7) v
->altpq
= get_bits(gb
, 5);
420 else v
->altpq
= v
->pq
+ pqdiff
+ 1;
427 /** Put block onto picture
429 static void vc1_put_block(VC1Context
*v
, DCTELEM block
[6][64])
433 DSPContext
*dsp
= &v
->s
.dsp
;
437 for(k
= 0; k
< 6; k
++)
438 for(j
= 0; j
< 8; j
++)
439 for(i
= 0; i
< 8; i
++)
440 block
[k
][i
+ j
*8] = ((block
[k
][i
+ j
*8] - 128) << 1) + 128;
443 ys
= v
->s
.current_picture
.linesize
[0];
444 us
= v
->s
.current_picture
.linesize
[1];
445 vs
= v
->s
.current_picture
.linesize
[2];
448 dsp
->put_pixels_clamped(block
[0], Y
, ys
);
449 dsp
->put_pixels_clamped(block
[1], Y
+ 8, ys
);
451 dsp
->put_pixels_clamped(block
[2], Y
, ys
);
452 dsp
->put_pixels_clamped(block
[3], Y
+ 8, ys
);
454 if(!(v
->s
.flags
& CODEC_FLAG_GRAY
)) {
455 dsp
->put_pixels_clamped(block
[4], v
->s
.dest
[1], us
);
456 dsp
->put_pixels_clamped(block
[5], v
->s
.dest
[2], vs
);
460 /** Do motion compensation over 1 macroblock
461 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
463 static void vc1_mc_1mv(VC1Context
*v
, int dir
)
465 MpegEncContext
*s
= &v
->s
;
466 DSPContext
*dsp
= &v
->s
.dsp
;
467 uint8_t *srcY
, *srcU
, *srcV
;
468 int dxy
, uvdxy
, mx
, my
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
470 if(!v
->s
.last_picture
.data
[0])return;
472 mx
= s
->mv
[dir
][0][0];
473 my
= s
->mv
[dir
][0][1];
475 // store motion vectors for further use in B frames
476 if(s
->pict_type
== FF_P_TYPE
) {
477 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = mx
;
478 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = my
;
480 uvmx
= (mx
+ ((mx
& 3) == 3)) >> 1;
481 uvmy
= (my
+ ((my
& 3) == 3)) >> 1;
483 uvmx
= uvmx
+ ((uvmx
<0)?(uvmx
&1):-(uvmx
&1));
484 uvmy
= uvmy
+ ((uvmy
<0)?(uvmy
&1):-(uvmy
&1));
487 srcY
= s
->last_picture
.data
[0];
488 srcU
= s
->last_picture
.data
[1];
489 srcV
= s
->last_picture
.data
[2];
491 srcY
= s
->next_picture
.data
[0];
492 srcU
= s
->next_picture
.data
[1];
493 srcV
= s
->next_picture
.data
[2];
496 src_x
= s
->mb_x
* 16 + (mx
>> 2);
497 src_y
= s
->mb_y
* 16 + (my
>> 2);
498 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
499 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
501 if(v
->profile
!= PROFILE_ADVANCED
){
502 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
503 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
504 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
505 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
507 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
508 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
509 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
510 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
513 srcY
+= src_y
* s
->linesize
+ src_x
;
514 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
515 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
517 /* for grayscale we should not try to read from unknown area */
518 if(s
->flags
& CODEC_FLAG_GRAY
) {
519 srcU
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
520 srcV
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
523 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
524 || (unsigned)(src_x
- s
->mspel
) > s
->h_edge_pos
- (mx
&3) - 16 - s
->mspel
*3
525 || (unsigned)(src_y
- s
->mspel
) > s
->v_edge_pos
- (my
&3) - 16 - s
->mspel
*3){
526 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 19 * s
->linesize
;
528 srcY
-= s
->mspel
* (1 + s
->linesize
);
529 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 17+s
->mspel
*2, 17+s
->mspel
*2,
530 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
531 srcY
= s
->edge_emu_buffer
;
532 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, 8+1, 8+1,
533 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
534 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
535 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
538 /* if we deal with range reduction we need to scale source blocks */
544 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
545 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
548 src
= srcU
; src2
= srcV
;
549 for(j
= 0; j
< 9; j
++) {
550 for(i
= 0; i
< 9; i
++) {
551 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
552 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
554 src
+= s
->uvlinesize
;
555 src2
+= s
->uvlinesize
;
558 /* if we deal with intensity compensation we need to scale source blocks */
559 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
564 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
565 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = v
->luty
[src
[i
]];
568 src
= srcU
; src2
= srcV
;
569 for(j
= 0; j
< 9; j
++) {
570 for(i
= 0; i
< 9; i
++) {
571 src
[i
] = v
->lutuv
[src
[i
]];
572 src2
[i
] = v
->lutuv
[src2
[i
]];
574 src
+= s
->uvlinesize
;
575 src2
+= s
->uvlinesize
;
578 srcY
+= s
->mspel
* (1 + s
->linesize
);
582 dxy
= ((my
& 3) << 2) | (mx
& 3);
583 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] , srcY
, s
->linesize
, v
->rnd
);
584 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8, srcY
+ 8, s
->linesize
, v
->rnd
);
585 srcY
+= s
->linesize
* 8;
586 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8 * s
->linesize
, srcY
, s
->linesize
, v
->rnd
);
587 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8 * s
->linesize
+ 8, srcY
+ 8, s
->linesize
, v
->rnd
);
588 } else { // hpel mc - always used for luma
589 dxy
= (my
& 2) | ((mx
& 2) >> 1);
592 dsp
->put_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
594 dsp
->put_no_rnd_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
597 if(s
->flags
& CODEC_FLAG_GRAY
) return;
598 /* Chroma MC always uses qpel bilinear */
599 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
603 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
604 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
606 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
607 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
611 /** Do motion compensation for 4-MV macroblock - luminance block
613 static void vc1_mc_4mv_luma(VC1Context
*v
, int n
)
615 MpegEncContext
*s
= &v
->s
;
616 DSPContext
*dsp
= &v
->s
.dsp
;
618 int dxy
, mx
, my
, src_x
, src_y
;
621 if(!v
->s
.last_picture
.data
[0])return;
624 srcY
= s
->last_picture
.data
[0];
626 off
= s
->linesize
* 4 * (n
&2) + (n
&1) * 8;
628 src_x
= s
->mb_x
* 16 + (n
&1) * 8 + (mx
>> 2);
629 src_y
= s
->mb_y
* 16 + (n
&2) * 4 + (my
>> 2);
631 if(v
->profile
!= PROFILE_ADVANCED
){
632 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
633 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
635 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
636 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
639 srcY
+= src_y
* s
->linesize
+ src_x
;
641 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
642 || (unsigned)(src_x
- s
->mspel
) > s
->h_edge_pos
- (mx
&3) - 8 - s
->mspel
*2
643 || (unsigned)(src_y
- s
->mspel
) > s
->v_edge_pos
- (my
&3) - 8 - s
->mspel
*2){
644 srcY
-= s
->mspel
* (1 + s
->linesize
);
645 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 9+s
->mspel
*2, 9+s
->mspel
*2,
646 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
647 srcY
= s
->edge_emu_buffer
;
648 /* if we deal with range reduction we need to scale source blocks */
654 for(j
= 0; j
< 9 + s
->mspel
*2; j
++) {
655 for(i
= 0; i
< 9 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
659 /* if we deal with intensity compensation we need to scale source blocks */
660 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
665 for(j
= 0; j
< 9 + s
->mspel
*2; j
++) {
666 for(i
= 0; i
< 9 + s
->mspel
*2; i
++) src
[i
] = v
->luty
[src
[i
]];
670 srcY
+= s
->mspel
* (1 + s
->linesize
);
674 dxy
= ((my
& 3) << 2) | (mx
& 3);
675 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, v
->rnd
);
676 } else { // hpel mc - always used for luma
677 dxy
= (my
& 2) | ((mx
& 2) >> 1);
679 dsp
->put_pixels_tab
[1][dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, 8);
681 dsp
->put_no_rnd_pixels_tab
[1][dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, 8);
685 static inline int median4(int a
, int b
, int c
, int d
)
688 if(c
< d
) return (FFMIN(b
, d
) + FFMAX(a
, c
)) / 2;
689 else return (FFMIN(b
, c
) + FFMAX(a
, d
)) / 2;
691 if(c
< d
) return (FFMIN(a
, d
) + FFMAX(b
, c
)) / 2;
692 else return (FFMIN(a
, c
) + FFMAX(b
, d
)) / 2;
697 /** Do motion compensation for 4-MV macroblock - both chroma blocks
699 static void vc1_mc_4mv_chroma(VC1Context
*v
)
701 MpegEncContext
*s
= &v
->s
;
702 DSPContext
*dsp
= &v
->s
.dsp
;
703 uint8_t *srcU
, *srcV
;
704 int uvdxy
, uvmx
, uvmy
, uvsrc_x
, uvsrc_y
;
705 int i
, idx
, tx
= 0, ty
= 0;
706 int mvx
[4], mvy
[4], intra
[4];
707 static const int count
[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
709 if(!v
->s
.last_picture
.data
[0])return;
710 if(s
->flags
& CODEC_FLAG_GRAY
) return;
712 for(i
= 0; i
< 4; i
++) {
713 mvx
[i
] = s
->mv
[0][i
][0];
714 mvy
[i
] = s
->mv
[0][i
][1];
715 intra
[i
] = v
->mb_type
[0][s
->block_index
[i
]];
718 /* calculate chroma MV vector from four luma MVs */
719 idx
= (intra
[3] << 3) | (intra
[2] << 2) | (intra
[1] << 1) | intra
[0];
720 if(!idx
) { // all blocks are inter
721 tx
= median4(mvx
[0], mvx
[1], mvx
[2], mvx
[3]);
722 ty
= median4(mvy
[0], mvy
[1], mvy
[2], mvy
[3]);
723 } else if(count
[idx
] == 1) { // 3 inter blocks
726 tx
= mid_pred(mvx
[1], mvx
[2], mvx
[3]);
727 ty
= mid_pred(mvy
[1], mvy
[2], mvy
[3]);
730 tx
= mid_pred(mvx
[0], mvx
[2], mvx
[3]);
731 ty
= mid_pred(mvy
[0], mvy
[2], mvy
[3]);
734 tx
= mid_pred(mvx
[0], mvx
[1], mvx
[3]);
735 ty
= mid_pred(mvy
[0], mvy
[1], mvy
[3]);
738 tx
= mid_pred(mvx
[0], mvx
[1], mvx
[2]);
739 ty
= mid_pred(mvy
[0], mvy
[1], mvy
[2]);
742 } else if(count
[idx
] == 2) {
744 for(i
=0; i
<3;i
++) if(!intra
[i
]) {t1
= i
; break;}
745 for(i
= t1
+1; i
<4; i
++)if(!intra
[i
]) {t2
= i
; break;}
746 tx
= (mvx
[t1
] + mvx
[t2
]) / 2;
747 ty
= (mvy
[t1
] + mvy
[t2
]) / 2;
749 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
750 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
751 return; //no need to do MC for inter blocks
754 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = tx
;
755 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = ty
;
756 uvmx
= (tx
+ ((tx
&3) == 3)) >> 1;
757 uvmy
= (ty
+ ((ty
&3) == 3)) >> 1;
759 uvmx
= uvmx
+ ((uvmx
<0)?(uvmx
&1):-(uvmx
&1));
760 uvmy
= uvmy
+ ((uvmy
<0)?(uvmy
&1):-(uvmy
&1));
763 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
764 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
766 if(v
->profile
!= PROFILE_ADVANCED
){
767 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
768 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
770 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
771 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
774 srcU
= s
->last_picture
.data
[1] + uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
775 srcV
= s
->last_picture
.data
[2] + uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
776 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
777 || (unsigned)uvsrc_x
> (s
->h_edge_pos
>> 1) - 9
778 || (unsigned)uvsrc_y
> (s
->v_edge_pos
>> 1) - 9){
779 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcU
, s
->uvlinesize
, 8+1, 8+1,
780 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
781 ff_emulated_edge_mc(s
->edge_emu_buffer
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
782 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
783 srcU
= s
->edge_emu_buffer
;
784 srcV
= s
->edge_emu_buffer
+ 16;
786 /* if we deal with range reduction we need to scale source blocks */
791 src
= srcU
; src2
= srcV
;
792 for(j
= 0; j
< 9; j
++) {
793 for(i
= 0; i
< 9; i
++) {
794 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
795 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
797 src
+= s
->uvlinesize
;
798 src2
+= s
->uvlinesize
;
801 /* if we deal with intensity compensation we need to scale source blocks */
802 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
806 src
= srcU
; src2
= srcV
;
807 for(j
= 0; j
< 9; j
++) {
808 for(i
= 0; i
< 9; i
++) {
809 src
[i
] = v
->lutuv
[src
[i
]];
810 src2
[i
] = v
->lutuv
[src2
[i
]];
812 src
+= s
->uvlinesize
;
813 src2
+= s
->uvlinesize
;
818 /* Chroma MC always uses qpel bilinear */
819 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
823 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
824 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
826 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
827 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
831 static int decode_sequence_header_adv(VC1Context
*v
, GetBitContext
*gb
);
834 * Decode Simple/Main Profiles sequence header
835 * @see Figure 7-8, p16-17
836 * @param avctx Codec context
837 * @param gb GetBit context initialized from Codec context extra_data
840 static int decode_sequence_header(AVCodecContext
*avctx
, GetBitContext
*gb
)
842 VC1Context
*v
= avctx
->priv_data
;
844 av_log(avctx
, AV_LOG_DEBUG
, "Header: %0X\n", show_bits(gb
, 32));
845 v
->profile
= get_bits(gb
, 2);
846 if (v
->profile
== PROFILE_COMPLEX
)
848 av_log(avctx
, AV_LOG_ERROR
, "WMV3 Complex Profile is not fully supported\n");
851 if (v
->profile
== PROFILE_ADVANCED
)
853 v
->zz_8x4
= ff_vc1_adv_progressive_8x4_zz
;
854 v
->zz_4x8
= ff_vc1_adv_progressive_4x8_zz
;
855 return decode_sequence_header_adv(v
, gb
);
859 v
->zz_8x4
= wmv2_scantableA
;
860 v
->zz_4x8
= wmv2_scantableB
;
861 v
->res_sm
= get_bits(gb
, 2); //reserved
864 av_log(avctx
, AV_LOG_ERROR
,
865 "Reserved RES_SM=%i is forbidden\n", v
->res_sm
);
871 v
->frmrtq_postproc
= get_bits(gb
, 3); //common
872 // (bitrate-32kbps)/64kbps
873 v
->bitrtq_postproc
= get_bits(gb
, 5); //common
874 v
->s
.loop_filter
= get_bits1(gb
); //common
875 if(v
->s
.loop_filter
== 1 && v
->profile
== PROFILE_SIMPLE
)
877 av_log(avctx
, AV_LOG_ERROR
,
878 "LOOPFILTER shell not be enabled in simple profile\n");
880 if(v
->s
.avctx
->skip_loop_filter
>= AVDISCARD_ALL
)
881 v
->s
.loop_filter
= 0;
883 v
->res_x8
= get_bits1(gb
); //reserved
884 v
->multires
= get_bits1(gb
);
885 v
->res_fasttx
= get_bits1(gb
);
888 v
->s
.dsp
.vc1_inv_trans_8x8
= ff_simple_idct
;
889 v
->s
.dsp
.vc1_inv_trans_8x4
= ff_simple_idct84_add
;
890 v
->s
.dsp
.vc1_inv_trans_4x8
= ff_simple_idct48_add
;
891 v
->s
.dsp
.vc1_inv_trans_4x4
= ff_simple_idct44_add
;
894 v
->fastuvmc
= get_bits1(gb
); //common
895 if (!v
->profile
&& !v
->fastuvmc
)
897 av_log(avctx
, AV_LOG_ERROR
,
898 "FASTUVMC unavailable in Simple Profile\n");
901 v
->extended_mv
= get_bits1(gb
); //common
902 if (!v
->profile
&& v
->extended_mv
)
904 av_log(avctx
, AV_LOG_ERROR
,
905 "Extended MVs unavailable in Simple Profile\n");
908 v
->dquant
= get_bits(gb
, 2); //common
909 v
->vstransform
= get_bits1(gb
); //common
911 v
->res_transtab
= get_bits1(gb
);
914 av_log(avctx
, AV_LOG_ERROR
,
915 "1 for reserved RES_TRANSTAB is forbidden\n");
919 v
->overlap
= get_bits1(gb
); //common
921 v
->s
.resync_marker
= get_bits1(gb
);
922 v
->rangered
= get_bits1(gb
);
923 if (v
->rangered
&& v
->profile
== PROFILE_SIMPLE
)
925 av_log(avctx
, AV_LOG_INFO
,
926 "RANGERED should be set to 0 in simple profile\n");
929 v
->s
.max_b_frames
= avctx
->max_b_frames
= get_bits(gb
, 3); //common
930 v
->quantizer_mode
= get_bits(gb
, 2); //common
932 v
->finterpflag
= get_bits1(gb
); //common
933 v
->res_rtm_flag
= get_bits1(gb
); //reserved
934 if (!v
->res_rtm_flag
)
936 // av_log(avctx, AV_LOG_ERROR,
937 // "0 for reserved RES_RTM_FLAG is forbidden\n");
938 av_log(avctx
, AV_LOG_ERROR
,
939 "Old WMV3 version detected, only I-frames will be decoded\n");
942 //TODO: figure out what they mean (always 0x402F)
943 if(!v
->res_fasttx
) skip_bits(gb
, 16);
944 av_log(avctx
, AV_LOG_DEBUG
,
945 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
946 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
947 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
948 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
949 v
->profile
, v
->frmrtq_postproc
, v
->bitrtq_postproc
,
950 v
->s
.loop_filter
, v
->multires
, v
->fastuvmc
, v
->extended_mv
,
951 v
->rangered
, v
->vstransform
, v
->overlap
, v
->s
.resync_marker
,
952 v
->dquant
, v
->quantizer_mode
, avctx
->max_b_frames
957 static int decode_sequence_header_adv(VC1Context
*v
, GetBitContext
*gb
)
960 v
->level
= get_bits(gb
, 3);
963 av_log(v
->s
.avctx
, AV_LOG_ERROR
, "Reserved LEVEL %i\n",v
->level
);
965 v
->chromaformat
= get_bits(gb
, 2);
966 if (v
->chromaformat
!= 1)
968 av_log(v
->s
.avctx
, AV_LOG_ERROR
,
969 "Only 4:2:0 chroma format supported\n");
974 v
->frmrtq_postproc
= get_bits(gb
, 3); //common
975 // (bitrate-32kbps)/64kbps
976 v
->bitrtq_postproc
= get_bits(gb
, 5); //common
977 v
->postprocflag
= get_bits1(gb
); //common
979 v
->s
.avctx
->coded_width
= (get_bits(gb
, 12) + 1) << 1;
980 v
->s
.avctx
->coded_height
= (get_bits(gb
, 12) + 1) << 1;
981 v
->s
.avctx
->width
= v
->s
.avctx
->coded_width
;
982 v
->s
.avctx
->height
= v
->s
.avctx
->coded_height
;
983 v
->broadcast
= get_bits1(gb
);
984 v
->interlace
= get_bits1(gb
);
985 v
->tfcntrflag
= get_bits1(gb
);
986 v
->finterpflag
= get_bits1(gb
);
987 skip_bits1(gb
); // reserved
989 v
->s
.h_edge_pos
= v
->s
.avctx
->coded_width
;
990 v
->s
.v_edge_pos
= v
->s
.avctx
->coded_height
;
992 av_log(v
->s
.avctx
, AV_LOG_DEBUG
,
993 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
994 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
995 "TFCTRflag=%i, FINTERPflag=%i\n",
996 v
->level
, v
->frmrtq_postproc
, v
->bitrtq_postproc
,
997 v
->s
.loop_filter
, v
->chromaformat
, v
->broadcast
, v
->interlace
,
998 v
->tfcntrflag
, v
->finterpflag
1001 v
->psf
= get_bits1(gb
);
1002 if(v
->psf
) { //PsF, 6.1.13
1003 av_log(v
->s
.avctx
, AV_LOG_ERROR
, "Progressive Segmented Frame mode: not supported (yet)\n");
1006 v
->s
.max_b_frames
= v
->s
.avctx
->max_b_frames
= 7;
1007 if(get_bits1(gb
)) { //Display Info - decoding is not affected by it
1009 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "Display extended info:\n");
1010 v
->s
.avctx
->width
= v
->s
.width
= w
= get_bits(gb
, 14) + 1;
1011 v
->s
.avctx
->height
= v
->s
.height
= h
= get_bits(gb
, 14) + 1;
1012 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "Display dimensions: %ix%i\n", w
, h
);
1014 ar
= get_bits(gb
, 4);
1016 v
->s
.avctx
->sample_aspect_ratio
= ff_vc1_pixel_aspect
[ar
];
1018 w
= get_bits(gb
, 8);
1019 h
= get_bits(gb
, 8);
1020 v
->s
.avctx
->sample_aspect_ratio
= (AVRational
){w
, h
};
1023 if(get_bits1(gb
)){ //framerate stuff
1025 v
->s
.avctx
->time_base
.num
= 32;
1026 v
->s
.avctx
->time_base
.den
= get_bits(gb
, 16) + 1;
1029 nr
= get_bits(gb
, 8);
1030 dr
= get_bits(gb
, 4);
1031 if(nr
&& nr
< 8 && dr
&& dr
< 3){
1032 v
->s
.avctx
->time_base
.num
= ff_vc1_fps_dr
[dr
- 1];
1033 v
->s
.avctx
->time_base
.den
= ff_vc1_fps_nr
[nr
- 1] * 1000;
1039 v
->color_prim
= get_bits(gb
, 8);
1040 v
->transfer_char
= get_bits(gb
, 8);
1041 v
->matrix_coef
= get_bits(gb
, 8);
1045 v
->hrd_param_flag
= get_bits1(gb
);
1046 if(v
->hrd_param_flag
) {
1048 v
->hrd_num_leaky_buckets
= get_bits(gb
, 5);
1049 skip_bits(gb
, 4); //bitrate exponent
1050 skip_bits(gb
, 4); //buffer size exponent
1051 for(i
= 0; i
< v
->hrd_num_leaky_buckets
; i
++) {
1052 skip_bits(gb
, 16); //hrd_rate[n]
1053 skip_bits(gb
, 16); //hrd_buffer[n]
1059 static int decode_entry_point(AVCodecContext
*avctx
, GetBitContext
*gb
)
1061 VC1Context
*v
= avctx
->priv_data
;
1062 int i
, blink
, clentry
, refdist
;
1064 av_log(avctx
, AV_LOG_DEBUG
, "Entry point: %08X\n", show_bits_long(gb
, 32));
1065 blink
= get_bits1(gb
); // broken link
1066 clentry
= get_bits1(gb
); // closed entry
1067 v
->panscanflag
= get_bits1(gb
);
1068 refdist
= get_bits1(gb
); // refdist flag
1069 v
->s
.loop_filter
= get_bits1(gb
);
1070 v
->fastuvmc
= get_bits1(gb
);
1071 v
->extended_mv
= get_bits1(gb
);
1072 v
->dquant
= get_bits(gb
, 2);
1073 v
->vstransform
= get_bits1(gb
);
1074 v
->overlap
= get_bits1(gb
);
1075 v
->quantizer_mode
= get_bits(gb
, 2);
1077 if(v
->hrd_param_flag
){
1078 for(i
= 0; i
< v
->hrd_num_leaky_buckets
; i
++) {
1079 skip_bits(gb
, 8); //hrd_full[n]
1084 avctx
->coded_width
= (get_bits(gb
, 12)+1)<<1;
1085 avctx
->coded_height
= (get_bits(gb
, 12)+1)<<1;
1088 v
->extended_dmv
= get_bits1(gb
);
1090 av_log(avctx
, AV_LOG_ERROR
, "Luma scaling is not supported, expect wrong picture\n");
1091 skip_bits(gb
, 3); // Y range, ignored for now
1094 av_log(avctx
, AV_LOG_ERROR
, "Chroma scaling is not supported, expect wrong picture\n");
1095 skip_bits(gb
, 3); // UV range, ignored for now
1098 av_log(avctx
, AV_LOG_DEBUG
, "Entry point info:\n"
1099 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1100 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1101 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1102 blink
, clentry
, v
->panscanflag
, refdist
, v
->s
.loop_filter
,
1103 v
->fastuvmc
, v
->extended_mv
, v
->dquant
, v
->vstransform
, v
->overlap
, v
->quantizer_mode
);
1108 static int vc1_parse_frame_header(VC1Context
*v
, GetBitContext
* gb
)
1110 int pqindex
, lowquant
, status
;
1112 if(v
->finterpflag
) v
->interpfrm
= get_bits1(gb
);
1113 skip_bits(gb
, 2); //framecnt unused
1115 if (v
->rangered
) v
->rangeredfrm
= get_bits1(gb
);
1116 v
->s
.pict_type
= get_bits1(gb
);
1117 if (v
->s
.avctx
->max_b_frames
) {
1118 if (!v
->s
.pict_type
) {
1119 if (get_bits1(gb
)) v
->s
.pict_type
= FF_I_TYPE
;
1120 else v
->s
.pict_type
= FF_B_TYPE
;
1121 } else v
->s
.pict_type
= FF_P_TYPE
;
1122 } else v
->s
.pict_type
= v
->s
.pict_type
? FF_P_TYPE
: FF_I_TYPE
;
1125 if(v
->s
.pict_type
== FF_B_TYPE
) {
1126 v
->bfraction
= get_vlc2(gb
, ff_vc1_bfraction_vlc
.table
, VC1_BFRACTION_VLC_BITS
, 1);
1127 v
->bfraction
= ff_vc1_bfraction_lut
[v
->bfraction
];
1128 if(v
->bfraction
== 0) {
1129 v
->s
.pict_type
= FF_BI_TYPE
;
1132 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1133 skip_bits(gb
, 7); // skip buffer fullness
1136 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1138 if(v
->s
.pict_type
== FF_P_TYPE
)
1141 /* Quantizer stuff */
1142 pqindex
= get_bits(gb
, 5);
1143 if(!pqindex
) return -1;
1144 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1145 v
->pq
= ff_vc1_pquant_table
[0][pqindex
];
1147 v
->pq
= ff_vc1_pquant_table
[1][pqindex
];
1150 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1151 v
->pquantizer
= pqindex
< 9;
1152 if (v
->quantizer_mode
== QUANT_NON_UNIFORM
)
1154 v
->pqindex
= pqindex
;
1155 if (pqindex
< 9) v
->halfpq
= get_bits1(gb
);
1157 if (v
->quantizer_mode
== QUANT_FRAME_EXPLICIT
)
1158 v
->pquantizer
= get_bits1(gb
);
1160 if (v
->extended_mv
== 1) v
->mvrange
= get_unary(gb
, 0, 3);
1161 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1162 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1163 v
->range_x
= 1 << (v
->k_x
- 1);
1164 v
->range_y
= 1 << (v
->k_y
- 1);
1165 if (v
->profile
== PROFILE_ADVANCED
)
1167 if (v
->postprocflag
) v
->postproc
= get_bits1(gb
);
1170 if (v
->multires
&& v
->s
.pict_type
!= FF_B_TYPE
) v
->respic
= get_bits(gb
, 2);
1172 if(v
->res_x8
&& (v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)){
1173 v
->x8_type
= get_bits1(gb
);
1174 }else v
->x8_type
= 0;
1175 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1176 // (v->s.pict_type == FF_P_TYPE) ? 'P' : ((v->s.pict_type == FF_I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1178 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_P_TYPE
) v
->use_ic
= 0;
1180 switch(v
->s
.pict_type
) {
1182 if (v
->pq
< 5) v
->tt_index
= 0;
1183 else if(v
->pq
< 13) v
->tt_index
= 1;
1184 else v
->tt_index
= 2;
1186 lowquant
= (v
->pq
> 12) ? 0 : 1;
1187 v
->mv_mode
= ff_vc1_mv_pmode_table
[lowquant
][get_unary(gb
, 1, 4)];
1188 if (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
1190 int scale
, shift
, i
;
1191 v
->mv_mode2
= ff_vc1_mv_pmode_table2
[lowquant
][get_unary(gb
, 1, 3)];
1192 v
->lumscale
= get_bits(gb
, 6);
1193 v
->lumshift
= get_bits(gb
, 6);
1195 /* fill lookup tables for intensity compensation */
1198 shift
= (255 - v
->lumshift
* 2) << 6;
1199 if(v
->lumshift
> 31)
1202 scale
= v
->lumscale
+ 32;
1203 if(v
->lumshift
> 31)
1204 shift
= (v
->lumshift
- 64) << 6;
1206 shift
= v
->lumshift
<< 6;
1208 for(i
= 0; i
< 256; i
++) {
1209 v
->luty
[i
] = av_clip_uint8((scale
* i
+ shift
+ 32) >> 6);
1210 v
->lutuv
[i
] = av_clip_uint8((scale
* (i
- 128) + 128*64 + 32) >> 6);
1213 if(v
->mv_mode
== MV_PMODE_1MV_HPEL
|| v
->mv_mode
== MV_PMODE_1MV_HPEL_BILIN
)
1214 v
->s
.quarter_sample
= 0;
1215 else if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
1216 if(v
->mv_mode2
== MV_PMODE_1MV_HPEL
|| v
->mv_mode2
== MV_PMODE_1MV_HPEL_BILIN
)
1217 v
->s
.quarter_sample
= 0;
1219 v
->s
.quarter_sample
= 1;
1221 v
->s
.quarter_sample
= 1;
1222 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
));
1224 if ((v
->mv_mode
== MV_PMODE_INTENSITY_COMP
&&
1225 v
->mv_mode2
== MV_PMODE_MIXED_MV
)
1226 || v
->mv_mode
== MV_PMODE_MIXED_MV
)
1228 status
= bitplane_decoding(v
->mv_type_mb_plane
, &v
->mv_type_is_raw
, v
);
1229 if (status
< 0) return -1;
1230 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB MV Type plane encoding: "
1231 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1233 v
->mv_type_is_raw
= 0;
1234 memset(v
->mv_type_mb_plane
, 0, v
->s
.mb_stride
* v
->s
.mb_height
);
1236 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1237 if (status
< 0) return -1;
1238 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1239 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1241 /* Hopefully this is correct for P frames */
1242 v
->s
.mv_table_index
= get_bits(gb
, 2); //but using ff_vc1_ tables
1243 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1247 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1248 vop_dquant_decoding(v
);
1251 v
->ttfrm
= 0; //FIXME Is that so ?
1254 v
->ttmbf
= get_bits1(gb
);
1257 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1265 if (v
->pq
< 5) v
->tt_index
= 0;
1266 else if(v
->pq
< 13) v
->tt_index
= 1;
1267 else v
->tt_index
= 2;
1269 lowquant
= (v
->pq
> 12) ? 0 : 1;
1270 v
->mv_mode
= get_bits1(gb
) ? MV_PMODE_1MV
: MV_PMODE_1MV_HPEL_BILIN
;
1271 v
->s
.quarter_sample
= (v
->mv_mode
== MV_PMODE_1MV
);
1272 v
->s
.mspel
= v
->s
.quarter_sample
;
1274 status
= bitplane_decoding(v
->direct_mb_plane
, &v
->dmb_is_raw
, v
);
1275 if (status
< 0) return -1;
1276 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Direct Type plane encoding: "
1277 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1278 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1279 if (status
< 0) return -1;
1280 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1281 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1283 v
->s
.mv_table_index
= get_bits(gb
, 2);
1284 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1288 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1289 vop_dquant_decoding(v
);
1295 v
->ttmbf
= get_bits1(gb
);
1298 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1310 v
->c_ac_table_index
= decode012(gb
);
1311 if (v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1313 v
->y_ac_table_index
= decode012(gb
);
1316 v
->s
.dc_table_index
= get_bits1(gb
);
1319 if(v
->s
.pict_type
== FF_BI_TYPE
) {
1320 v
->s
.pict_type
= FF_B_TYPE
;
1326 static int vc1_parse_frame_header_adv(VC1Context
*v
, GetBitContext
* gb
)
1328 int pqindex
, lowquant
;
1331 v
->p_frame_skipped
= 0;
1334 v
->fcm
= decode012(gb
);
1335 if(v
->fcm
) return -1; // interlaced frames/fields are not implemented
1337 switch(get_unary(gb
, 0, 4)) {
1339 v
->s
.pict_type
= FF_P_TYPE
;
1342 v
->s
.pict_type
= FF_B_TYPE
;
1345 v
->s
.pict_type
= FF_I_TYPE
;
1348 v
->s
.pict_type
= FF_BI_TYPE
;
1351 v
->s
.pict_type
= FF_P_TYPE
; // skipped pic
1352 v
->p_frame_skipped
= 1;
1358 if(!v
->interlace
|| v
->psf
) {
1359 v
->rptfrm
= get_bits(gb
, 2);
1361 v
->tff
= get_bits1(gb
);
1362 v
->rptfrm
= get_bits1(gb
);
1365 if(v
->panscanflag
) {
1368 v
->rnd
= get_bits1(gb
);
1370 v
->uvsamp
= get_bits1(gb
);
1371 if(v
->finterpflag
) v
->interpfrm
= get_bits1(gb
);
1372 if(v
->s
.pict_type
== FF_B_TYPE
) {
1373 v
->bfraction
= get_vlc2(gb
, ff_vc1_bfraction_vlc
.table
, VC1_BFRACTION_VLC_BITS
, 1);
1374 v
->bfraction
= ff_vc1_bfraction_lut
[v
->bfraction
];
1375 if(v
->bfraction
== 0) {
1376 v
->s
.pict_type
= FF_BI_TYPE
; /* XXX: should not happen here */
1379 pqindex
= get_bits(gb
, 5);
1380 if(!pqindex
) return -1;
1381 v
->pqindex
= pqindex
;
1382 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1383 v
->pq
= ff_vc1_pquant_table
[0][pqindex
];
1385 v
->pq
= ff_vc1_pquant_table
[1][pqindex
];
1388 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1389 v
->pquantizer
= pqindex
< 9;
1390 if (v
->quantizer_mode
== QUANT_NON_UNIFORM
)
1392 v
->pqindex
= pqindex
;
1393 if (pqindex
< 9) v
->halfpq
= get_bits1(gb
);
1395 if (v
->quantizer_mode
== QUANT_FRAME_EXPLICIT
)
1396 v
->pquantizer
= get_bits1(gb
);
1398 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_P_TYPE
) v
->use_ic
= 0;
1400 switch(v
->s
.pict_type
) {
1403 status
= bitplane_decoding(v
->acpred_plane
, &v
->acpred_is_raw
, v
);
1404 if (status
< 0) return -1;
1405 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "ACPRED plane encoding: "
1406 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1407 v
->condover
= CONDOVER_NONE
;
1408 if(v
->overlap
&& v
->pq
<= 8) {
1409 v
->condover
= decode012(gb
);
1410 if(v
->condover
== CONDOVER_SELECT
) {
1411 status
= bitplane_decoding(v
->over_flags_plane
, &v
->overflg_is_raw
, v
);
1412 if (status
< 0) return -1;
1413 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "CONDOVER plane encoding: "
1414 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1420 v
->postproc
= get_bits1(gb
);
1421 if (v
->extended_mv
) v
->mvrange
= get_unary(gb
, 0, 3);
1422 else v
->mvrange
= 0;
1423 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1424 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1425 v
->range_x
= 1 << (v
->k_x
- 1);
1426 v
->range_y
= 1 << (v
->k_y
- 1);
1428 if (v
->pq
< 5) v
->tt_index
= 0;
1429 else if(v
->pq
< 13) v
->tt_index
= 1;
1430 else v
->tt_index
= 2;
1432 lowquant
= (v
->pq
> 12) ? 0 : 1;
1433 v
->mv_mode
= ff_vc1_mv_pmode_table
[lowquant
][get_unary(gb
, 1, 4)];
1434 if (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
1436 int scale
, shift
, i
;
1437 v
->mv_mode2
= ff_vc1_mv_pmode_table2
[lowquant
][get_unary(gb
, 1, 3)];
1438 v
->lumscale
= get_bits(gb
, 6);
1439 v
->lumshift
= get_bits(gb
, 6);
1440 /* fill lookup tables for intensity compensation */
1443 shift
= (255 - v
->lumshift
* 2) << 6;
1444 if(v
->lumshift
> 31)
1447 scale
= v
->lumscale
+ 32;
1448 if(v
->lumshift
> 31)
1449 shift
= (v
->lumshift
- 64) << 6;
1451 shift
= v
->lumshift
<< 6;
1453 for(i
= 0; i
< 256; i
++) {
1454 v
->luty
[i
] = av_clip_uint8((scale
* i
+ shift
+ 32) >> 6);
1455 v
->lutuv
[i
] = av_clip_uint8((scale
* (i
- 128) + 128*64 + 32) >> 6);
1459 if(v
->mv_mode
== MV_PMODE_1MV_HPEL
|| v
->mv_mode
== MV_PMODE_1MV_HPEL_BILIN
)
1460 v
->s
.quarter_sample
= 0;
1461 else if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
1462 if(v
->mv_mode2
== MV_PMODE_1MV_HPEL
|| v
->mv_mode2
== MV_PMODE_1MV_HPEL_BILIN
)
1463 v
->s
.quarter_sample
= 0;
1465 v
->s
.quarter_sample
= 1;
1467 v
->s
.quarter_sample
= 1;
1468 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
));
1470 if ((v
->mv_mode
== MV_PMODE_INTENSITY_COMP
&&
1471 v
->mv_mode2
== MV_PMODE_MIXED_MV
)
1472 || v
->mv_mode
== MV_PMODE_MIXED_MV
)
1474 status
= bitplane_decoding(v
->mv_type_mb_plane
, &v
->mv_type_is_raw
, v
);
1475 if (status
< 0) return -1;
1476 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB MV Type plane encoding: "
1477 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1479 v
->mv_type_is_raw
= 0;
1480 memset(v
->mv_type_mb_plane
, 0, v
->s
.mb_stride
* v
->s
.mb_height
);
1482 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1483 if (status
< 0) return -1;
1484 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1485 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1487 /* Hopefully this is correct for P frames */
1488 v
->s
.mv_table_index
= get_bits(gb
, 2); //but using ff_vc1_ tables
1489 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1492 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1493 vop_dquant_decoding(v
);
1496 v
->ttfrm
= 0; //FIXME Is that so ?
1499 v
->ttmbf
= get_bits1(gb
);
1502 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1511 v
->postproc
= get_bits1(gb
);
1512 if (v
->extended_mv
) v
->mvrange
= get_unary(gb
, 0, 3);
1513 else v
->mvrange
= 0;
1514 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1515 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1516 v
->range_x
= 1 << (v
->k_x
- 1);
1517 v
->range_y
= 1 << (v
->k_y
- 1);
1519 if (v
->pq
< 5) v
->tt_index
= 0;
1520 else if(v
->pq
< 13) v
->tt_index
= 1;
1521 else v
->tt_index
= 2;
1523 lowquant
= (v
->pq
> 12) ? 0 : 1;
1524 v
->mv_mode
= get_bits1(gb
) ? MV_PMODE_1MV
: MV_PMODE_1MV_HPEL_BILIN
;
1525 v
->s
.quarter_sample
= (v
->mv_mode
== MV_PMODE_1MV
);
1526 v
->s
.mspel
= v
->s
.quarter_sample
;
1528 status
= bitplane_decoding(v
->direct_mb_plane
, &v
->dmb_is_raw
, v
);
1529 if (status
< 0) return -1;
1530 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Direct Type plane encoding: "
1531 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1532 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1533 if (status
< 0) return -1;
1534 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1535 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1537 v
->s
.mv_table_index
= get_bits(gb
, 2);
1538 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1542 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1543 vop_dquant_decoding(v
);
1549 v
->ttmbf
= get_bits1(gb
);
1552 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1562 v
->c_ac_table_index
= decode012(gb
);
1563 if (v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1565 v
->y_ac_table_index
= decode012(gb
);
1568 v
->s
.dc_table_index
= get_bits1(gb
);
1569 if ((v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
) && v
->dquant
) {
1570 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1571 vop_dquant_decoding(v
);
1575 if(v
->s
.pict_type
== FF_BI_TYPE
) {
1576 v
->s
.pict_type
= FF_B_TYPE
;
1582 /***********************************************************************/
1584 * @defgroup block VC-1 Block-level functions
1585 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1591 * @brief Get macroblock-level quantizer scale
1593 #define GET_MQUANT() \
1597 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1601 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1605 mqdiff = get_bits(gb, 3); \
1606 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1607 else mquant = get_bits(gb, 5); \
1610 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1611 edges = 1 << v->dqsbedge; \
1612 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1613 edges = (3 << v->dqsbedge) % 15; \
1614 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
1616 if((edges&1) && !s->mb_x) \
1617 mquant = v->altpq; \
1618 if((edges&2) && s->first_slice_line) \
1619 mquant = v->altpq; \
1620 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
1621 mquant = v->altpq; \
1622 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
1623 mquant = v->altpq; \
1627 * @def GET_MVDATA(_dmv_x, _dmv_y)
1628 * @brief Get MV differentials
1629 * @see MVDATA decoding from 8.3.5.2, p(1)20
1630 * @param _dmv_x Horizontal differential for decoded MV
1631 * @param _dmv_y Vertical differential for decoded MV
1633 #define GET_MVDATA(_dmv_x, _dmv_y) \
1634 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table,\
1635 VC1_MV_DIFF_VLC_BITS, 2); \
1638 mb_has_coeffs = 1; \
1641 else mb_has_coeffs = 0; \
1643 if (!index) { _dmv_x = _dmv_y = 0; } \
1644 else if (index == 35) \
1646 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1647 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1649 else if (index == 36) \
1658 if (!s->quarter_sample && index1 == 5) val = 1; \
1660 if(size_table[index1] - val > 0) \
1661 val = get_bits(gb, size_table[index1] - val); \
1663 sign = 0 - (val&1); \
1664 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1667 if (!s->quarter_sample && index1 == 5) val = 1; \
1669 if(size_table[index1] - val > 0) \
1670 val = get_bits(gb, size_table[index1] - val); \
1672 sign = 0 - (val&1); \
1673 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1676 /** Predict and set motion vector
1678 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
)
1680 int xy
, wrap
, off
= 0;
1685 /* scale MV difference to be quad-pel */
1686 dmv_x
<<= 1 - s
->quarter_sample
;
1687 dmv_y
<<= 1 - s
->quarter_sample
;
1689 wrap
= s
->b8_stride
;
1690 xy
= s
->block_index
[n
];
1693 s
->mv
[0][n
][0] = s
->current_picture
.motion_val
[0][xy
][0] = 0;
1694 s
->mv
[0][n
][1] = s
->current_picture
.motion_val
[0][xy
][1] = 0;
1695 s
->current_picture
.motion_val
[1][xy
][0] = 0;
1696 s
->current_picture
.motion_val
[1][xy
][1] = 0;
1697 if(mv1
) { /* duplicate motion data for 1-MV block */
1698 s
->current_picture
.motion_val
[0][xy
+ 1][0] = 0;
1699 s
->current_picture
.motion_val
[0][xy
+ 1][1] = 0;
1700 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = 0;
1701 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = 0;
1702 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][0] = 0;
1703 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][1] = 0;
1704 s
->current_picture
.motion_val
[1][xy
+ 1][0] = 0;
1705 s
->current_picture
.motion_val
[1][xy
+ 1][1] = 0;
1706 s
->current_picture
.motion_val
[1][xy
+ wrap
][0] = 0;
1707 s
->current_picture
.motion_val
[1][xy
+ wrap
][1] = 0;
1708 s
->current_picture
.motion_val
[1][xy
+ wrap
+ 1][0] = 0;
1709 s
->current_picture
.motion_val
[1][xy
+ wrap
+ 1][1] = 0;
1714 C
= s
->current_picture
.motion_val
[0][xy
- 1];
1715 A
= s
->current_picture
.motion_val
[0][xy
- wrap
];
1717 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -1 : 2;
1719 //in 4-MV mode different blocks have different B predictor position
1722 off
= (s
->mb_x
> 0) ? -1 : 1;
1725 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -1 : 1;
1734 B
= s
->current_picture
.motion_val
[0][xy
- wrap
+ off
];
1736 if(!s
->first_slice_line
|| (n
==2 || n
==3)) { // predictor A is not out of bounds
1737 if(s
->mb_width
== 1) {
1741 px
= mid_pred(A
[0], B
[0], C
[0]);
1742 py
= mid_pred(A
[1], B
[1], C
[1]);
1744 } else if(s
->mb_x
|| (n
==1 || n
==3)) { // predictor C is not out of bounds
1750 /* Pullback MV as specified in 8.3.5.3.4 */
1753 qx
= (s
->mb_x
<< 6) + ((n
==1 || n
==3) ? 32 : 0);
1754 qy
= (s
->mb_y
<< 6) + ((n
==2 || n
==3) ? 32 : 0);
1755 X
= (s
->mb_width
<< 6) - 4;
1756 Y
= (s
->mb_height
<< 6) - 4;
1758 if(qx
+ px
< -60) px
= -60 - qx
;
1759 if(qy
+ py
< -60) py
= -60 - qy
;
1761 if(qx
+ px
< -28) px
= -28 - qx
;
1762 if(qy
+ py
< -28) py
= -28 - qy
;
1764 if(qx
+ px
> X
) px
= X
- qx
;
1765 if(qy
+ py
> Y
) py
= Y
- qy
;
1767 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1768 if((!s
->first_slice_line
|| (n
==2 || n
==3)) && (s
->mb_x
|| (n
==1 || n
==3))) {
1769 if(is_intra
[xy
- wrap
])
1770 sum
= FFABS(px
) + FFABS(py
);
1772 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
1774 if(get_bits1(&s
->gb
)) {
1782 if(is_intra
[xy
- 1])
1783 sum
= FFABS(px
) + FFABS(py
);
1785 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
1787 if(get_bits1(&s
->gb
)) {
1797 /* store MV using signed modulus of MV range defined in 4.11 */
1798 s
->mv
[0][n
][0] = s
->current_picture
.motion_val
[0][xy
][0] = ((px
+ dmv_x
+ r_x
) & ((r_x
<< 1) - 1)) - r_x
;
1799 s
->mv
[0][n
][1] = s
->current_picture
.motion_val
[0][xy
][1] = ((py
+ dmv_y
+ r_y
) & ((r_y
<< 1) - 1)) - r_y
;
1800 if(mv1
) { /* duplicate motion data for 1-MV block */
1801 s
->current_picture
.motion_val
[0][xy
+ 1][0] = s
->current_picture
.motion_val
[0][xy
][0];
1802 s
->current_picture
.motion_val
[0][xy
+ 1][1] = s
->current_picture
.motion_val
[0][xy
][1];
1803 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = s
->current_picture
.motion_val
[0][xy
][0];
1804 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = s
->current_picture
.motion_val
[0][xy
][1];
1805 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][0] = s
->current_picture
.motion_val
[0][xy
][0];
1806 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][1] = s
->current_picture
.motion_val
[0][xy
][1];
1810 /** Motion compensation for direct or interpolated blocks in B-frames
1812 static void vc1_interp_mc(VC1Context
*v
)
1814 MpegEncContext
*s
= &v
->s
;
1815 DSPContext
*dsp
= &v
->s
.dsp
;
1816 uint8_t *srcY
, *srcU
, *srcV
;
1817 int dxy
, uvdxy
, mx
, my
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
1819 if(!v
->s
.next_picture
.data
[0])return;
1821 mx
= s
->mv
[1][0][0];
1822 my
= s
->mv
[1][0][1];
1823 uvmx
= (mx
+ ((mx
& 3) == 3)) >> 1;
1824 uvmy
= (my
+ ((my
& 3) == 3)) >> 1;
1826 uvmx
= uvmx
+ ((uvmx
<0)?-(uvmx
&1):(uvmx
&1));
1827 uvmy
= uvmy
+ ((uvmy
<0)?-(uvmy
&1):(uvmy
&1));
1829 srcY
= s
->next_picture
.data
[0];
1830 srcU
= s
->next_picture
.data
[1];
1831 srcV
= s
->next_picture
.data
[2];
1833 src_x
= s
->mb_x
* 16 + (mx
>> 2);
1834 src_y
= s
->mb_y
* 16 + (my
>> 2);
1835 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
1836 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
1838 if(v
->profile
!= PROFILE_ADVANCED
){
1839 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
1840 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
1841 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
1842 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
1844 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
1845 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
1846 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
1847 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
1850 srcY
+= src_y
* s
->linesize
+ src_x
;
1851 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
1852 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
1854 /* for grayscale we should not try to read from unknown area */
1855 if(s
->flags
& CODEC_FLAG_GRAY
) {
1856 srcU
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
1857 srcV
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
1861 || (unsigned)src_x
> s
->h_edge_pos
- (mx
&3) - 16
1862 || (unsigned)src_y
> s
->v_edge_pos
- (my
&3) - 16){
1863 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 19 * s
->linesize
;
1865 srcY
-= s
->mspel
* (1 + s
->linesize
);
1866 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 17+s
->mspel
*2, 17+s
->mspel
*2,
1867 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
1868 srcY
= s
->edge_emu_buffer
;
1869 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, 8+1, 8+1,
1870 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
1871 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
1872 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
1875 /* if we deal with range reduction we need to scale source blocks */
1876 if(v
->rangeredfrm
) {
1878 uint8_t *src
, *src2
;
1881 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
1882 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
1885 src
= srcU
; src2
= srcV
;
1886 for(j
= 0; j
< 9; j
++) {
1887 for(i
= 0; i
< 9; i
++) {
1888 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
1889 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
1891 src
+= s
->uvlinesize
;
1892 src2
+= s
->uvlinesize
;
1895 srcY
+= s
->mspel
* (1 + s
->linesize
);
1900 dxy
= ((my
& 1) << 1) | (mx
& 1);
1902 dsp
->avg_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
1904 if(s
->flags
& CODEC_FLAG_GRAY
) return;
1905 /* Chroma MC always uses qpel blilinear */
1906 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
1909 dsp
->avg_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1910 dsp
->avg_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1913 static av_always_inline
int scale_mv(int value
, int bfrac
, int inv
, int qs
)
1917 #if B_FRACTION_DEN==256
1921 return 2 * ((value
* n
+ 255) >> 9);
1922 return (value
* n
+ 128) >> 8;
1925 n
-= B_FRACTION_DEN
;
1927 return 2 * ((value
* n
+ B_FRACTION_DEN
- 1) / (2 * B_FRACTION_DEN
));
1928 return (value
* n
+ B_FRACTION_DEN
/2) / B_FRACTION_DEN
;
1932 /** Reconstruct motion vector for B-frame and do motion compensation
1934 static inline void vc1_b_mc(VC1Context
*v
, int dmv_x
[2], int dmv_y
[2], int direct
, int mode
)
1937 v
->mv_mode2
= v
->mv_mode
;
1938 v
->mv_mode
= MV_PMODE_INTENSITY_COMP
;
1943 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1946 if(mode
== BMV_TYPE_INTERPOLATED
) {
1949 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1953 if(v
->use_ic
&& (mode
== BMV_TYPE_BACKWARD
)) v
->mv_mode
= v
->mv_mode2
;
1954 vc1_mc_1mv(v
, (mode
== BMV_TYPE_BACKWARD
));
1955 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1958 static inline void vc1_pred_b_mv(VC1Context
*v
, int dmv_x
[2], int dmv_y
[2], int direct
, int mvtype
)
1960 MpegEncContext
*s
= &v
->s
;
1961 int xy
, wrap
, off
= 0;
1966 const uint8_t *is_intra
= v
->mb_type
[0];
1970 /* scale MV difference to be quad-pel */
1971 dmv_x
[0] <<= 1 - s
->quarter_sample
;
1972 dmv_y
[0] <<= 1 - s
->quarter_sample
;
1973 dmv_x
[1] <<= 1 - s
->quarter_sample
;
1974 dmv_y
[1] <<= 1 - s
->quarter_sample
;
1976 wrap
= s
->b8_stride
;
1977 xy
= s
->block_index
[0];
1980 s
->current_picture
.motion_val
[0][xy
][0] =
1981 s
->current_picture
.motion_val
[0][xy
][1] =
1982 s
->current_picture
.motion_val
[1][xy
][0] =
1983 s
->current_picture
.motion_val
[1][xy
][1] = 0;
1986 s
->mv
[0][0][0] = scale_mv(s
->next_picture
.motion_val
[1][xy
][0], v
->bfraction
, 0, s
->quarter_sample
);
1987 s
->mv
[0][0][1] = scale_mv(s
->next_picture
.motion_val
[1][xy
][1], v
->bfraction
, 0, s
->quarter_sample
);
1988 s
->mv
[1][0][0] = scale_mv(s
->next_picture
.motion_val
[1][xy
][0], v
->bfraction
, 1, s
->quarter_sample
);
1989 s
->mv
[1][0][1] = scale_mv(s
->next_picture
.motion_val
[1][xy
][1], v
->bfraction
, 1, s
->quarter_sample
);
1991 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
1992 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));
1993 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));
1994 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));
1995 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));
1997 s
->current_picture
.motion_val
[0][xy
][0] = s
->mv
[0][0][0];
1998 s
->current_picture
.motion_val
[0][xy
][1] = s
->mv
[0][0][1];
1999 s
->current_picture
.motion_val
[1][xy
][0] = s
->mv
[1][0][0];
2000 s
->current_picture
.motion_val
[1][xy
][1] = s
->mv
[1][0][1];
2004 if((mvtype
== BMV_TYPE_FORWARD
) || (mvtype
== BMV_TYPE_INTERPOLATED
)) {
2005 C
= s
->current_picture
.motion_val
[0][xy
- 2];
2006 A
= s
->current_picture
.motion_val
[0][xy
- wrap
*2];
2007 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -2 : 2;
2008 B
= s
->current_picture
.motion_val
[0][xy
- wrap
*2 + off
];
2010 if(!s
->mb_x
) C
[0] = C
[1] = 0;
2011 if(!s
->first_slice_line
) { // predictor A is not out of bounds
2012 if(s
->mb_width
== 1) {
2016 px
= mid_pred(A
[0], B
[0], C
[0]);
2017 py
= mid_pred(A
[1], B
[1], C
[1]);
2019 } else if(s
->mb_x
) { // predictor C is not out of bounds
2025 /* Pullback MV as specified in 8.3.5.3.4 */
2028 if(v
->profile
< PROFILE_ADVANCED
) {
2029 qx
= (s
->mb_x
<< 5);
2030 qy
= (s
->mb_y
<< 5);
2031 X
= (s
->mb_width
<< 5) - 4;
2032 Y
= (s
->mb_height
<< 5) - 4;
2033 if(qx
+ px
< -28) px
= -28 - qx
;
2034 if(qy
+ py
< -28) py
= -28 - qy
;
2035 if(qx
+ px
> X
) px
= X
- qx
;
2036 if(qy
+ py
> Y
) py
= Y
- qy
;
2038 qx
= (s
->mb_x
<< 6);
2039 qy
= (s
->mb_y
<< 6);
2040 X
= (s
->mb_width
<< 6) - 4;
2041 Y
= (s
->mb_height
<< 6) - 4;
2042 if(qx
+ px
< -60) px
= -60 - qx
;
2043 if(qy
+ py
< -60) py
= -60 - qy
;
2044 if(qx
+ px
> X
) px
= X
- qx
;
2045 if(qy
+ py
> Y
) py
= Y
- qy
;
2048 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2049 if(0 && !s
->first_slice_line
&& s
->mb_x
) {
2050 if(is_intra
[xy
- wrap
])
2051 sum
= FFABS(px
) + FFABS(py
);
2053 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
2055 if(get_bits1(&s
->gb
)) {
2063 if(is_intra
[xy
- 2])
2064 sum
= FFABS(px
) + FFABS(py
);
2066 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
2068 if(get_bits1(&s
->gb
)) {
2078 /* store MV using signed modulus of MV range defined in 4.11 */
2079 s
->mv
[0][0][0] = ((px
+ dmv_x
[0] + r_x
) & ((r_x
<< 1) - 1)) - r_x
;
2080 s
->mv
[0][0][1] = ((py
+ dmv_y
[0] + r_y
) & ((r_y
<< 1) - 1)) - r_y
;
2082 if((mvtype
== BMV_TYPE_BACKWARD
) || (mvtype
== BMV_TYPE_INTERPOLATED
)) {
2083 C
= s
->current_picture
.motion_val
[1][xy
- 2];
2084 A
= s
->current_picture
.motion_val
[1][xy
- wrap
*2];
2085 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -2 : 2;
2086 B
= s
->current_picture
.motion_val
[1][xy
- wrap
*2 + off
];
2088 if(!s
->mb_x
) C
[0] = C
[1] = 0;
2089 if(!s
->first_slice_line
) { // predictor A is not out of bounds
2090 if(s
->mb_width
== 1) {
2094 px
= mid_pred(A
[0], B
[0], C
[0]);
2095 py
= mid_pred(A
[1], B
[1], C
[1]);
2097 } else if(s
->mb_x
) { // predictor C is not out of bounds
2103 /* Pullback MV as specified in 8.3.5.3.4 */
2106 if(v
->profile
< PROFILE_ADVANCED
) {
2107 qx
= (s
->mb_x
<< 5);
2108 qy
= (s
->mb_y
<< 5);
2109 X
= (s
->mb_width
<< 5) - 4;
2110 Y
= (s
->mb_height
<< 5) - 4;
2111 if(qx
+ px
< -28) px
= -28 - qx
;
2112 if(qy
+ py
< -28) py
= -28 - qy
;
2113 if(qx
+ px
> X
) px
= X
- qx
;
2114 if(qy
+ py
> Y
) py
= Y
- qy
;
2116 qx
= (s
->mb_x
<< 6);
2117 qy
= (s
->mb_y
<< 6);
2118 X
= (s
->mb_width
<< 6) - 4;
2119 Y
= (s
->mb_height
<< 6) - 4;
2120 if(qx
+ px
< -60) px
= -60 - qx
;
2121 if(qy
+ py
< -60) py
= -60 - qy
;
2122 if(qx
+ px
> X
) px
= X
- qx
;
2123 if(qy
+ py
> Y
) py
= Y
- qy
;
2126 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2127 if(0 && !s
->first_slice_line
&& s
->mb_x
) {
2128 if(is_intra
[xy
- wrap
])
2129 sum
= FFABS(px
) + FFABS(py
);
2131 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
2133 if(get_bits1(&s
->gb
)) {
2141 if(is_intra
[xy
- 2])
2142 sum
= FFABS(px
) + FFABS(py
);
2144 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
2146 if(get_bits1(&s
->gb
)) {
2156 /* store MV using signed modulus of MV range defined in 4.11 */
2158 s
->mv
[1][0][0] = ((px
+ dmv_x
[1] + r_x
) & ((r_x
<< 1) - 1)) - r_x
;
2159 s
->mv
[1][0][1] = ((py
+ dmv_y
[1] + r_y
) & ((r_y
<< 1) - 1)) - r_y
;
2161 s
->current_picture
.motion_val
[0][xy
][0] = s
->mv
[0][0][0];
2162 s
->current_picture
.motion_val
[0][xy
][1] = s
->mv
[0][0][1];
2163 s
->current_picture
.motion_val
[1][xy
][0] = s
->mv
[1][0][0];
2164 s
->current_picture
.motion_val
[1][xy
][1] = s
->mv
[1][0][1];
2167 /** Get predicted DC value for I-frames only
2168 * prediction dir: left=0, top=1
2169 * @param s MpegEncContext
2170 * @param[in] n block index in the current MB
2171 * @param dc_val_ptr Pointer to DC predictor
2172 * @param dir_ptr Prediction direction for use in AC prediction
2174 static inline int vc1_i_pred_dc(MpegEncContext
*s
, int overlap
, int pq
, int n
,
2175 int16_t **dc_val_ptr
, int *dir_ptr
)
2177 int a
, b
, c
, wrap
, pred
, scale
;
2179 static const uint16_t dcpred
[32] = {
2180 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2181 114, 102, 93, 85, 79, 73, 68, 64,
2182 60, 57, 54, 51, 49, 47, 45, 43,
2183 41, 39, 38, 37, 35, 34, 33
2186 /* find prediction - wmv3_dc_scale always used here in fact */
2187 if (n
< 4) scale
= s
->y_dc_scale
;
2188 else scale
= s
->c_dc_scale
;
2190 wrap
= s
->block_wrap
[n
];
2191 dc_val
= s
->dc_val
[0] + s
->block_index
[n
];
2197 b
= dc_val
[ - 1 - wrap
];
2198 a
= dc_val
[ - wrap
];
2200 if (pq
< 9 || !overlap
)
2202 /* Set outer values */
2203 if (s
->first_slice_line
&& (n
!=2 && n
!=3)) b
=a
=dcpred
[scale
];
2204 if (s
->mb_x
== 0 && (n
!=1 && n
!=3)) b
=c
=dcpred
[scale
];
2208 /* Set outer values */
2209 if (s
->first_slice_line
&& (n
!=2 && n
!=3)) b
=a
=0;
2210 if (s
->mb_x
== 0 && (n
!=1 && n
!=3)) b
=c
=0;
2213 if (abs(a
- b
) <= abs(b
- c
)) {
2221 /* update predictor */
2222 *dc_val_ptr
= &dc_val
[0];
2227 /** Get predicted DC value
2228 * prediction dir: left=0, top=1
2229 * @param s MpegEncContext
2230 * @param[in] n block index in the current MB
2231 * @param dc_val_ptr Pointer to DC predictor
2232 * @param dir_ptr Prediction direction for use in AC prediction
2234 static inline int vc1_pred_dc(MpegEncContext
*s
, int overlap
, int pq
, int n
,
2235 int a_avail
, int c_avail
,
2236 int16_t **dc_val_ptr
, int *dir_ptr
)
2238 int a
, b
, c
, wrap
, pred
, scale
;
2240 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2243 /* find prediction - wmv3_dc_scale always used here in fact */
2244 if (n
< 4) scale
= s
->y_dc_scale
;
2245 else scale
= s
->c_dc_scale
;
2247 wrap
= s
->block_wrap
[n
];
2248 dc_val
= s
->dc_val
[0] + s
->block_index
[n
];
2254 b
= dc_val
[ - 1 - wrap
];
2255 a
= dc_val
[ - wrap
];
2256 /* scale predictors if needed */
2257 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2258 if(c_avail
&& (n
!= 1 && n
!=3)) {
2259 q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2261 c
= (c
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2263 if(a_avail
&& (n
!= 2 && n
!=3)) {
2264 q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2266 a
= (a
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2268 if(a_avail
&& c_avail
&& (n
!=3)) {
2271 if(n
!= 2) off
-= s
->mb_stride
;
2272 q2
= s
->current_picture
.qscale_table
[off
];
2274 b
= (b
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2277 if(a_avail
&& c_avail
) {
2278 if(abs(a
- b
) <= abs(b
- c
)) {
2285 } else if(a_avail
) {
2288 } else if(c_avail
) {
2296 /* update predictor */
2297 *dc_val_ptr
= &dc_val
[0];
2303 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2304 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2308 static inline int vc1_coded_block_pred(MpegEncContext
* s
, int n
, uint8_t **coded_block_ptr
)
2310 int xy
, wrap
, pred
, a
, b
, c
;
2312 xy
= s
->block_index
[n
];
2313 wrap
= s
->b8_stride
;
2318 a
= s
->coded_block
[xy
- 1 ];
2319 b
= s
->coded_block
[xy
- 1 - wrap
];
2320 c
= s
->coded_block
[xy
- wrap
];
2329 *coded_block_ptr
= &s
->coded_block
[xy
];
2335 * Decode one AC coefficient
2336 * @param v The VC1 context
2337 * @param last Last coefficient
2338 * @param skip How much zero coefficients to skip
2339 * @param value Decoded AC coefficient value
2342 static void vc1_decode_ac_coeff(VC1Context
*v
, int *last
, int *skip
, int *value
, int codingset
)
2344 GetBitContext
*gb
= &v
->s
.gb
;
2345 int index
, escape
, run
= 0, level
= 0, lst
= 0;
2347 index
= get_vlc2(gb
, ff_vc1_ac_coeff_table
[codingset
].table
, AC_VLC_BITS
, 3);
2348 if (index
!= vc1_ac_sizes
[codingset
] - 1) {
2349 run
= vc1_index_decode_table
[codingset
][index
][0];
2350 level
= vc1_index_decode_table
[codingset
][index
][1];
2351 lst
= index
>= vc1_last_decode_table
[codingset
];
2355 escape
= decode210(gb
);
2357 index
= get_vlc2(gb
, ff_vc1_ac_coeff_table
[codingset
].table
, AC_VLC_BITS
, 3);
2358 run
= vc1_index_decode_table
[codingset
][index
][0];
2359 level
= vc1_index_decode_table
[codingset
][index
][1];
2360 lst
= index
>= vc1_last_decode_table
[codingset
];
2363 level
+= vc1_last_delta_level_table
[codingset
][run
];
2365 level
+= vc1_delta_level_table
[codingset
][run
];
2368 run
+= vc1_last_delta_run_table
[codingset
][level
] + 1;
2370 run
+= vc1_delta_run_table
[codingset
][level
] + 1;
2376 lst
= get_bits1(gb
);
2377 if(v
->s
.esc3_level_length
== 0) {
2378 if(v
->pq
< 8 || v
->dquantfrm
) { // table 59
2379 v
->s
.esc3_level_length
= get_bits(gb
, 3);
2380 if(!v
->s
.esc3_level_length
)
2381 v
->s
.esc3_level_length
= get_bits(gb
, 2) + 8;
2383 v
->s
.esc3_level_length
= get_unary(gb
, 1, 6) + 2;
2385 v
->s
.esc3_run_length
= 3 + get_bits(gb
, 2);
2387 run
= get_bits(gb
, v
->s
.esc3_run_length
);
2388 sign
= get_bits1(gb
);
2389 level
= get_bits(gb
, v
->s
.esc3_level_length
);
2400 /** Decode intra block in intra frames - should be faster than decode_intra_block
2401 * @param v VC1Context
2402 * @param block block to decode
2403 * @param coded are AC coeffs present or not
2404 * @param codingset set of VLC to decode data
2406 static int vc1_decode_i_block(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int codingset
)
2408 GetBitContext
*gb
= &v
->s
.gb
;
2409 MpegEncContext
*s
= &v
->s
;
2410 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2413 int16_t *ac_val
, *ac_val2
;
2416 /* Get DC differential */
2418 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2420 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2423 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2428 if (dcdiff
== 119 /* ESC index value */)
2430 /* TODO: Optimize */
2431 if (v
->pq
== 1) dcdiff
= get_bits(gb
, 10);
2432 else if (v
->pq
== 2) dcdiff
= get_bits(gb
, 9);
2433 else dcdiff
= get_bits(gb
, 8);
2438 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2439 else if (v
->pq
== 2)
2440 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2447 dcdiff
+= vc1_i_pred_dc(&v
->s
, v
->overlap
, v
->pq
, n
, &dc_val
, &dc_pred_dir
);
2450 /* Store the quantized DC coeff, used for prediction */
2452 block
[0] = dcdiff
* s
->y_dc_scale
;
2454 block
[0] = dcdiff
* s
->c_dc_scale
;
2467 int last
= 0, skip
, value
;
2468 const int8_t *zz_table
;
2472 scale
= v
->pq
* 2 + v
->halfpq
;
2476 zz_table
= wmv1_scantable
[2];
2478 zz_table
= wmv1_scantable
[3];
2480 zz_table
= wmv1_scantable
[1];
2482 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2484 if(dc_pred_dir
) //left
2487 ac_val
-= 16 * s
->block_wrap
[n
];
2490 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2494 block
[zz_table
[i
++]] = value
;
2497 /* apply AC prediction if needed */
2499 if(dc_pred_dir
) { //left
2500 for(k
= 1; k
< 8; k
++)
2501 block
[k
<< 3] += ac_val
[k
];
2503 for(k
= 1; k
< 8; k
++)
2504 block
[k
] += ac_val
[k
+ 8];
2507 /* save AC coeffs for further prediction */
2508 for(k
= 1; k
< 8; k
++) {
2509 ac_val2
[k
] = block
[k
<< 3];
2510 ac_val2
[k
+ 8] = block
[k
];
2513 /* scale AC coeffs */
2514 for(k
= 1; k
< 64; k
++)
2518 block
[k
] += (block
[k
] < 0) ? -v
->pq
: v
->pq
;
2521 if(s
->ac_pred
) i
= 63;
2527 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2530 scale
= v
->pq
* 2 + v
->halfpq
;
2531 memset(ac_val2
, 0, 16 * 2);
2532 if(dc_pred_dir
) {//left
2535 memcpy(ac_val2
, ac_val
, 8 * 2);
2537 ac_val
-= 16 * s
->block_wrap
[n
];
2539 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2542 /* apply AC prediction if needed */
2544 if(dc_pred_dir
) { //left
2545 for(k
= 1; k
< 8; k
++) {
2546 block
[k
<< 3] = ac_val
[k
] * scale
;
2547 if(!v
->pquantizer
&& block
[k
<< 3])
2548 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -v
->pq
: v
->pq
;
2551 for(k
= 1; k
< 8; k
++) {
2552 block
[k
] = ac_val
[k
+ 8] * scale
;
2553 if(!v
->pquantizer
&& block
[k
])
2554 block
[k
] += (block
[k
] < 0) ? -v
->pq
: v
->pq
;
2560 s
->block_last_index
[n
] = i
;
2565 /** Decode intra block in intra frames - should be faster than decode_intra_block
2566 * @param v VC1Context
2567 * @param block block to decode
2568 * @param coded are AC coeffs present or not
2569 * @param codingset set of VLC to decode data
2571 static int vc1_decode_i_block_adv(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int codingset
, int mquant
)
2573 GetBitContext
*gb
= &v
->s
.gb
;
2574 MpegEncContext
*s
= &v
->s
;
2575 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2578 int16_t *ac_val
, *ac_val2
;
2580 int a_avail
= v
->a_avail
, c_avail
= v
->c_avail
;
2581 int use_pred
= s
->ac_pred
;
2584 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2586 /* Get DC differential */
2588 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2590 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2593 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2598 if (dcdiff
== 119 /* ESC index value */)
2600 /* TODO: Optimize */
2601 if (mquant
== 1) dcdiff
= get_bits(gb
, 10);
2602 else if (mquant
== 2) dcdiff
= get_bits(gb
, 9);
2603 else dcdiff
= get_bits(gb
, 8);
2608 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2609 else if (mquant
== 2)
2610 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2617 dcdiff
+= vc1_pred_dc(&v
->s
, v
->overlap
, mquant
, n
, v
->a_avail
, v
->c_avail
, &dc_val
, &dc_pred_dir
);
2620 /* Store the quantized DC coeff, used for prediction */
2622 block
[0] = dcdiff
* s
->y_dc_scale
;
2624 block
[0] = dcdiff
* s
->c_dc_scale
;
2633 /* check if AC is needed at all */
2634 if(!a_avail
&& !c_avail
) use_pred
= 0;
2635 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2638 scale
= mquant
* 2 + ((mquant
== v
->pq
) ? v
->halfpq
: 0);
2640 if(dc_pred_dir
) //left
2643 ac_val
-= 16 * s
->block_wrap
[n
];
2645 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2646 if(dc_pred_dir
&& c_avail
&& mb_pos
) q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2647 if(!dc_pred_dir
&& a_avail
&& mb_pos
>= s
->mb_stride
) q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2648 if(dc_pred_dir
&& n
==1) q2
= q1
;
2649 if(!dc_pred_dir
&& n
==2) q2
= q1
;
2653 int last
= 0, skip
, value
;
2654 const int8_t *zz_table
;
2659 zz_table
= wmv1_scantable
[2];
2661 zz_table
= wmv1_scantable
[3];
2663 zz_table
= wmv1_scantable
[1];
2666 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2670 block
[zz_table
[i
++]] = value
;
2673 /* apply AC prediction if needed */
2675 /* scale predictors if needed*/
2677 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2678 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2680 if(dc_pred_dir
) { //left
2681 for(k
= 1; k
< 8; k
++)
2682 block
[k
<< 3] += (ac_val
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2684 for(k
= 1; k
< 8; k
++)
2685 block
[k
] += (ac_val
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2688 if(dc_pred_dir
) { //left
2689 for(k
= 1; k
< 8; k
++)
2690 block
[k
<< 3] += ac_val
[k
];
2692 for(k
= 1; k
< 8; k
++)
2693 block
[k
] += ac_val
[k
+ 8];
2697 /* save AC coeffs for further prediction */
2698 for(k
= 1; k
< 8; k
++) {
2699 ac_val2
[k
] = block
[k
<< 3];
2700 ac_val2
[k
+ 8] = block
[k
];
2703 /* scale AC coeffs */
2704 for(k
= 1; k
< 64; k
++)
2708 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2711 if(use_pred
) i
= 63;
2712 } else { // no AC coeffs
2715 memset(ac_val2
, 0, 16 * 2);
2716 if(dc_pred_dir
) {//left
2718 memcpy(ac_val2
, ac_val
, 8 * 2);
2720 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2721 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2722 for(k
= 1; k
< 8; k
++)
2723 ac_val2
[k
] = (ac_val2
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2728 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2730 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2731 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2732 for(k
= 1; k
< 8; k
++)
2733 ac_val2
[k
+ 8] = (ac_val2
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2738 /* apply AC prediction if needed */
2740 if(dc_pred_dir
) { //left
2741 for(k
= 1; k
< 8; k
++) {
2742 block
[k
<< 3] = ac_val2
[k
] * scale
;
2743 if(!v
->pquantizer
&& block
[k
<< 3])
2744 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -mquant
: mquant
;
2747 for(k
= 1; k
< 8; k
++) {
2748 block
[k
] = ac_val2
[k
+ 8] * scale
;
2749 if(!v
->pquantizer
&& block
[k
])
2750 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2756 s
->block_last_index
[n
] = i
;
2761 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2762 * @param v VC1Context
2763 * @param block block to decode
2764 * @param coded are AC coeffs present or not
2765 * @param mquant block quantizer
2766 * @param codingset set of VLC to decode data
2768 static int vc1_decode_intra_block(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int mquant
, int codingset
)
2770 GetBitContext
*gb
= &v
->s
.gb
;
2771 MpegEncContext
*s
= &v
->s
;
2772 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2775 int16_t *ac_val
, *ac_val2
;
2777 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2778 int a_avail
= v
->a_avail
, c_avail
= v
->c_avail
;
2779 int use_pred
= s
->ac_pred
;
2783 /* XXX: Guard against dumb values of mquant */
2784 mquant
= (mquant
< 1) ? 0 : ( (mquant
>31) ? 31 : mquant
);
2786 /* Set DC scale - y and c use the same */
2787 s
->y_dc_scale
= s
->y_dc_scale_table
[mquant
];
2788 s
->c_dc_scale
= s
->c_dc_scale_table
[mquant
];
2790 /* Get DC differential */
2792 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2794 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2797 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2802 if (dcdiff
== 119 /* ESC index value */)
2804 /* TODO: Optimize */
2805 if (mquant
== 1) dcdiff
= get_bits(gb
, 10);
2806 else if (mquant
== 2) dcdiff
= get_bits(gb
, 9);
2807 else dcdiff
= get_bits(gb
, 8);
2812 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2813 else if (mquant
== 2)
2814 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2821 dcdiff
+= vc1_pred_dc(&v
->s
, v
->overlap
, mquant
, n
, a_avail
, c_avail
, &dc_val
, &dc_pred_dir
);
2824 /* Store the quantized DC coeff, used for prediction */
2827 block
[0] = dcdiff
* s
->y_dc_scale
;
2829 block
[0] = dcdiff
* s
->c_dc_scale
;
2838 /* check if AC is needed at all and adjust direction if needed */
2839 if(!a_avail
) dc_pred_dir
= 1;
2840 if(!c_avail
) dc_pred_dir
= 0;
2841 if(!a_avail
&& !c_avail
) use_pred
= 0;
2842 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2845 scale
= mquant
* 2 + v
->halfpq
;
2847 if(dc_pred_dir
) //left
2850 ac_val
-= 16 * s
->block_wrap
[n
];
2852 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2853 if(dc_pred_dir
&& c_avail
&& mb_pos
) q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2854 if(!dc_pred_dir
&& a_avail
&& mb_pos
>= s
->mb_stride
) q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2855 if(dc_pred_dir
&& n
==1) q2
= q1
;
2856 if(!dc_pred_dir
&& n
==2) q2
= q1
;
2860 int last
= 0, skip
, value
;
2861 const int8_t *zz_table
;
2864 zz_table
= wmv1_scantable
[0];
2867 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2871 block
[zz_table
[i
++]] = value
;
2874 /* apply AC prediction if needed */
2876 /* scale predictors if needed*/
2878 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2879 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2881 if(dc_pred_dir
) { //left
2882 for(k
= 1; k
< 8; k
++)
2883 block
[k
<< 3] += (ac_val
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2885 for(k
= 1; k
< 8; k
++)
2886 block
[k
] += (ac_val
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2889 if(dc_pred_dir
) { //left
2890 for(k
= 1; k
< 8; k
++)
2891 block
[k
<< 3] += ac_val
[k
];
2893 for(k
= 1; k
< 8; k
++)
2894 block
[k
] += ac_val
[k
+ 8];
2898 /* save AC coeffs for further prediction */
2899 for(k
= 1; k
< 8; k
++) {
2900 ac_val2
[k
] = block
[k
<< 3];
2901 ac_val2
[k
+ 8] = block
[k
];
2904 /* scale AC coeffs */
2905 for(k
= 1; k
< 64; k
++)
2909 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2912 if(use_pred
) i
= 63;
2913 } else { // no AC coeffs
2916 memset(ac_val2
, 0, 16 * 2);
2917 if(dc_pred_dir
) {//left
2919 memcpy(ac_val2
, ac_val
, 8 * 2);
2921 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2922 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2923 for(k
= 1; k
< 8; k
++)
2924 ac_val2
[k
] = (ac_val2
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2929 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2931 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2932 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2933 for(k
= 1; k
< 8; k
++)
2934 ac_val2
[k
+ 8] = (ac_val2
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2939 /* apply AC prediction if needed */
2941 if(dc_pred_dir
) { //left
2942 for(k
= 1; k
< 8; k
++) {
2943 block
[k
<< 3] = ac_val2
[k
] * scale
;
2944 if(!v
->pquantizer
&& block
[k
<< 3])
2945 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -mquant
: mquant
;
2948 for(k
= 1; k
< 8; k
++) {
2949 block
[k
] = ac_val2
[k
+ 8] * scale
;
2950 if(!v
->pquantizer
&& block
[k
])
2951 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2957 s
->block_last_index
[n
] = i
;
2964 static int vc1_decode_p_block(VC1Context
*v
, DCTELEM block
[64], int n
, int mquant
, int ttmb
, int first_block
,
2965 uint8_t *dst
, int linesize
, int skip_block
, int apply_filter
, int cbp_top
, int cbp_left
)
2967 MpegEncContext
*s
= &v
->s
;
2968 GetBitContext
*gb
= &s
->gb
;
2971 int scale
, off
, idx
, last
, skip
, value
;
2972 int ttblk
= ttmb
& 7;
2976 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)];
2978 if(ttblk
== TT_4X4
) {
2979 subblkpat
= ~(get_vlc2(gb
, ff_vc1_subblkpat_vlc
[v
->tt_index
].table
, VC1_SUBBLKPAT_VLC_BITS
, 1) + 1);
2981 if((ttblk
!= TT_8X8
&& ttblk
!= TT_4X4
) && (v
->ttmbf
|| (ttmb
!= -1 && (ttmb
& 8) && !first_block
))) {
2982 subblkpat
= decode012(gb
);
2983 if(subblkpat
) subblkpat
^= 3; //swap decoded pattern bits
2984 if(ttblk
== TT_8X4_TOP
|| ttblk
== TT_8X4_BOTTOM
) ttblk
= TT_8X4
;
2985 if(ttblk
== TT_4X8_RIGHT
|| ttblk
== TT_4X8_LEFT
) ttblk
= TT_4X8
;
2987 scale
= 2 * mquant
+ ((v
->pq
== mquant
) ? v
->halfpq
: 0);
2989 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2990 if(ttblk
== TT_8X4_TOP
|| ttblk
== TT_8X4_BOTTOM
) {
2991 subblkpat
= 2 - (ttblk
== TT_8X4_TOP
);
2994 if(ttblk
== TT_4X8_RIGHT
|| ttblk
== TT_4X8_LEFT
) {
2995 subblkpat
= 2 - (ttblk
== TT_4X8_LEFT
);
3004 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3008 idx
= wmv1_scantable
[0][i
++];
3009 block
[idx
] = value
* scale
;
3011 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3014 s
->dsp
.vc1_inv_trans_8x8(block
);
3015 s
->dsp
.add_pixels_clamped(block
, dst
, linesize
);
3016 if(apply_filter
&& cbp_top
& 0xC)
3017 vc1_loop_filter(dst
, 1, linesize
, 8, mquant
);
3018 if(apply_filter
&& cbp_left
& 0xA)
3019 vc1_loop_filter(dst
, linesize
, 1, 8, mquant
);
3023 pat
= ~subblkpat
& 0xF;
3024 for(j
= 0; j
< 4; j
++) {
3025 last
= subblkpat
& (1 << (3 - j
));
3027 off
= (j
& 1) * 4 + (j
& 2) * 16;
3029 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3033 idx
= ff_vc1_simple_progressive_4x4_zz
[i
++];
3034 block
[idx
+ off
] = value
* scale
;
3036 block
[idx
+ off
] += (block
[idx
+ off
] < 0) ? -mquant
: mquant
;
3038 if(!(subblkpat
& (1 << (3 - j
))) && !skip_block
){
3039 s
->dsp
.vc1_inv_trans_4x4(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, linesize
, block
+ off
);
3040 if(apply_filter
&& (j
&2 ? pat
& (1<<(j
-2)) : (cbp_top
& (1 << (j
+ 2)))))
3041 vc1_loop_filter(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, 1, linesize
, 4, mquant
);
3042 if(apply_filter
&& (j
&1 ? pat
& (1<<(j
-1)) : (cbp_left
& (1 << (j
+ 1)))))
3043 vc1_loop_filter(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, linesize
, 1, 4, mquant
);
3048 pat
= ~((subblkpat
& 2)*6 + (subblkpat
& 1)*3) & 0xF;
3049 for(j
= 0; j
< 2; j
++) {
3050 last
= subblkpat
& (1 << (1 - j
));
3054 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3058 idx
= v
->zz_8x4
[i
++]+off
;
3059 block
[idx
] = value
* scale
;
3061 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3063 if(!(subblkpat
& (1 << (1 - j
))) && !skip_block
){
3064 s
->dsp
.vc1_inv_trans_8x4(dst
+ j
*4*linesize
, linesize
, block
+ off
);
3065 if(apply_filter
&& j
? pat
& 0x3 : (cbp_top
& 0xC))
3066 vc1_loop_filter(dst
+ j
*4*linesize
, 1, linesize
, 8, mquant
);
3067 if(apply_filter
&& cbp_left
& (2 << j
))
3068 vc1_loop_filter(dst
+ j
*4*linesize
, linesize
, 1, 4, mquant
);
3073 pat
= ~(subblkpat
*5) & 0xF;
3074 for(j
= 0; j
< 2; j
++) {
3075 last
= subblkpat
& (1 << (1 - j
));
3079 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3083 idx
= v
->zz_4x8
[i
++]+off
;
3084 block
[idx
] = value
* scale
;
3086 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3088 if(!(subblkpat
& (1 << (1 - j
))) && !skip_block
){
3089 s
->dsp
.vc1_inv_trans_4x8(dst
+ j
*4, linesize
, block
+ off
);
3090 if(apply_filter
&& cbp_top
& (2 << j
))
3091 vc1_loop_filter(dst
+ j
*4, 1, linesize
, 4, mquant
);
3092 if(apply_filter
&& j
? pat
& 0x5 : (cbp_left
& 0xA))
3093 vc1_loop_filter(dst
+ j
*4, linesize
, 1, 8, mquant
);
3102 /** Decode one P-frame MB (in Simple/Main profile)
3104 static int vc1_decode_p_mb(VC1Context
*v
)
3106 MpegEncContext
*s
= &v
->s
;
3107 GetBitContext
*gb
= &s
->gb
;
3109 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3110 int cbp
; /* cbp decoding stuff */
3111 int mqdiff
, mquant
; /* MB quantization */
3112 int ttmb
= v
->ttfrm
; /* MB Transform type */
3114 static const int size_table
[6] = { 0, 2, 3, 4, 5, 8 },
3115 offset_table
[6] = { 0, 1, 3, 7, 15, 31 };
3116 int mb_has_coeffs
= 1; /* last_flag */
3117 int dmv_x
, dmv_y
; /* Differential MV components */
3118 int index
, index1
; /* LUT indexes */
3119 int val
, sign
; /* temp values */
3120 int first_block
= 1;
3122 int skipped
, fourmv
;
3123 int block_cbp
= 0, pat
;
3124 int apply_loop_filter
;
3126 mquant
= v
->pq
; /* Loosy initialization */
3128 if (v
->mv_type_is_raw
)
3129 fourmv
= get_bits1(gb
);
3131 fourmv
= v
->mv_type_mb_plane
[mb_pos
];
3133 skipped
= get_bits1(gb
);
3135 skipped
= v
->s
.mbskip_table
[mb_pos
];
3137 s
->dsp
.clear_blocks(s
->block
[0]);
3139 apply_loop_filter
= s
->loop_filter
&& !(s
->avctx
->skip_loop_filter
>= AVDISCARD_NONKEY
);
3140 if (!fourmv
) /* 1MV mode */
3144 GET_MVDATA(dmv_x
, dmv_y
);
3147 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3148 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3150 s
->current_picture
.mb_type
[mb_pos
] = s
->mb_intra
? MB_TYPE_INTRA
: MB_TYPE_16x16
;
3151 vc1_pred_mv(s
, 0, dmv_x
, dmv_y
, 1, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3153 /* FIXME Set DC val for inter block ? */
3154 if (s
->mb_intra
&& !mb_has_coeffs
)
3157 s
->ac_pred
= get_bits1(gb
);
3160 else if (mb_has_coeffs
)
3162 if (s
->mb_intra
) s
->ac_pred
= get_bits1(gb
);
3163 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3171 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3173 if (!v
->ttmbf
&& !s
->mb_intra
&& mb_has_coeffs
)
3174 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
,
3175 VC1_TTMB_VLC_BITS
, 2);
3176 if(!s
->mb_intra
) vc1_mc_1mv(v
, 0);
3180 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3182 val
= ((cbp
>> (5 - i
)) & 1);
3183 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3184 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3186 /* check if prediction blocks A and C are available */
3187 v
->a_avail
= v
->c_avail
= 0;
3188 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3189 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3190 if(i
== 1 || i
== 3 || s
->mb_x
)
3191 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3193 vc1_decode_intra_block(v
, s
->block
[i
], i
, val
, mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3194 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3195 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3196 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3197 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3198 if(v
->pq
>= 9 && v
->overlap
) {
3200 s
->dsp
.vc1_h_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3202 s
->dsp
.vc1_v_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3204 if(apply_loop_filter
&& s
->mb_x
&& s
->mb_x
!= (s
->mb_width
- 1) && s
->mb_y
&& s
->mb_y
!= (s
->mb_height
- 1)){
3205 int left_cbp
, top_cbp
;
3207 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3208 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3210 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3211 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3214 vc1_loop_filter(s
->dest
[dst_idx
] + off
, 1, i
& 4 ? s
->uvlinesize
: s
->linesize
, 8, mquant
);
3216 vc1_loop_filter(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, 1, 8, mquant
);
3218 block_cbp
|= 0xF << (i
<< 2);
3220 int left_cbp
= 0, top_cbp
= 0, filter
= 0;
3221 if(apply_loop_filter
&& s
->mb_x
&& s
->mb_x
!= (s
->mb_width
- 1) && s
->mb_y
&& s
->mb_y
!= (s
->mb_height
- 1)){
3224 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3225 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3227 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3228 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3231 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
);
3232 block_cbp
|= pat
<< (i
<< 2);
3233 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3241 for(i
= 0; i
< 6; i
++) {
3242 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3243 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3245 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_SKIP
;
3246 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3247 vc1_pred_mv(s
, 0, 0, 0, 1, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3254 if (!skipped
/* unskipped MB */)
3256 int intra_count
= 0, coded_inter
= 0;
3257 int is_intra
[6], is_coded
[6];
3259 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3262 val
= ((cbp
>> (5 - i
)) & 1);
3263 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3270 GET_MVDATA(dmv_x
, dmv_y
);
3272 vc1_pred_mv(s
, i
, dmv_x
, dmv_y
, 0, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3273 if(!s
->mb_intra
) vc1_mc_4mv_luma(v
, i
);
3274 intra_count
+= s
->mb_intra
;
3275 is_intra
[i
] = s
->mb_intra
;
3276 is_coded
[i
] = mb_has_coeffs
;
3279 is_intra
[i
] = (intra_count
>= 3);
3282 if(i
== 4) vc1_mc_4mv_chroma(v
);
3283 v
->mb_type
[0][s
->block_index
[i
]] = is_intra
[i
];
3284 if(!coded_inter
) coded_inter
= !is_intra
[i
] & is_coded
[i
];
3286 // if there are no coded blocks then don't do anything more
3287 if(!intra_count
&& !coded_inter
) return 0;
3290 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3291 /* test if block is intra and has pred */
3296 if(((!s
->first_slice_line
|| (i
==2 || i
==3)) && v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]])
3297 || ((s
->mb_x
|| (i
==1 || i
==3)) && v
->mb_type
[0][s
->block_index
[i
] - 1])) {
3302 if(intrapred
)s
->ac_pred
= get_bits1(gb
);
3303 else s
->ac_pred
= 0;
3305 if (!v
->ttmbf
&& coded_inter
)
3306 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3310 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3311 s
->mb_intra
= is_intra
[i
];
3313 /* check if prediction blocks A and C are available */
3314 v
->a_avail
= v
->c_avail
= 0;
3315 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3316 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3317 if(i
== 1 || i
== 3 || s
->mb_x
)
3318 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3320 vc1_decode_intra_block(v
, s
->block
[i
], i
, is_coded
[i
], mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3321 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3322 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3323 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3324 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, (i
&4)?s
->uvlinesize
:s
->linesize
);
3325 if(v
->pq
>= 9 && v
->overlap
) {
3327 s
->dsp
.vc1_h_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3329 s
->dsp
.vc1_v_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3331 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)){
3332 int left_cbp
, top_cbp
;
3334 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3335 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3337 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3338 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3341 vc1_loop_filter(s
->dest
[dst_idx
] + off
, 1, i
& 4 ? s
->uvlinesize
: s
->linesize
, 8, mquant
);
3343 vc1_loop_filter(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, 1, 8, mquant
);
3345 block_cbp
|= 0xF << (i
<< 2);
3346 } else if(is_coded
[i
]) {
3347 int left_cbp
= 0, top_cbp
= 0, filter
= 0;
3348 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)){
3351 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3352 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3354 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3355 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3358 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
);
3359 block_cbp
|= pat
<< (i
<< 2);
3360 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3369 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3370 for (i
=0; i
<6; i
++) {
3371 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3372 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3376 vc1_pred_mv(s
, i
, 0, 0, 0, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3377 vc1_mc_4mv_luma(v
, i
);
3379 vc1_mc_4mv_chroma(v
);
3380 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3384 v
->cbp
[s
->mb_x
] = block_cbp
;
3386 /* Should never happen */
3390 /** Decode one B-frame MB (in Main profile)
3392 static void vc1_decode_b_mb(VC1Context
*v
)
3394 MpegEncContext
*s
= &v
->s
;
3395 GetBitContext
*gb
= &s
->gb
;
3397 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3398 int cbp
= 0; /* cbp decoding stuff */
3399 int mqdiff
, mquant
; /* MB quantization */
3400 int ttmb
= v
->ttfrm
; /* MB Transform type */
3402 static const int size_table
[6] = { 0, 2, 3, 4, 5, 8 },
3403 offset_table
[6] = { 0, 1, 3, 7, 15, 31 };
3404 int mb_has_coeffs
= 0; /* last_flag */
3405 int index
, index1
; /* LUT indexes */
3406 int val
, sign
; /* temp values */
3407 int first_block
= 1;
3409 int skipped
, direct
;
3410 int dmv_x
[2], dmv_y
[2];
3411 int bmvtype
= BMV_TYPE_BACKWARD
;
3413 mquant
= v
->pq
; /* Loosy initialization */
3417 direct
= get_bits1(gb
);
3419 direct
= v
->direct_mb_plane
[mb_pos
];
3421 skipped
= get_bits1(gb
);
3423 skipped
= v
->s
.mbskip_table
[mb_pos
];
3425 s
->dsp
.clear_blocks(s
->block
[0]);
3426 dmv_x
[0] = dmv_x
[1] = dmv_y
[0] = dmv_y
[1] = 0;
3427 for(i
= 0; i
< 6; i
++) {
3428 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3429 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3431 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3435 GET_MVDATA(dmv_x
[0], dmv_y
[0]);
3436 dmv_x
[1] = dmv_x
[0];
3437 dmv_y
[1] = dmv_y
[0];
3439 if(skipped
|| !s
->mb_intra
) {
3440 bmvtype
= decode012(gb
);
3443 bmvtype
= (v
->bfraction
>= (B_FRACTION_DEN
/2)) ? BMV_TYPE_BACKWARD
: BMV_TYPE_FORWARD
;
3446 bmvtype
= (v
->bfraction
>= (B_FRACTION_DEN
/2)) ? BMV_TYPE_FORWARD
: BMV_TYPE_BACKWARD
;
3449 bmvtype
= BMV_TYPE_INTERPOLATED
;
3450 dmv_x
[0] = dmv_y
[0] = 0;
3454 for(i
= 0; i
< 6; i
++)
3455 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3458 if(direct
) bmvtype
= BMV_TYPE_INTERPOLATED
;
3459 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3460 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3464 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3468 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3470 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3471 dmv_x
[0] = dmv_y
[0] = dmv_x
[1] = dmv_y
[1] = 0;
3472 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3473 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3475 if(!mb_has_coeffs
&& !s
->mb_intra
) {
3476 /* no coded blocks - effectively skipped */
3477 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3478 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3481 if(s
->mb_intra
&& !mb_has_coeffs
) {
3483 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3484 s
->ac_pred
= get_bits1(gb
);
3486 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3488 if(bmvtype
== BMV_TYPE_INTERPOLATED
) {
3489 GET_MVDATA(dmv_x
[0], dmv_y
[0]);
3490 if(!mb_has_coeffs
) {
3491 /* interpolated skipped block */
3492 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3493 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3497 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3499 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3502 s
->ac_pred
= get_bits1(gb
);
3503 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3505 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3506 if(!v
->ttmbf
&& !s
->mb_intra
&& mb_has_coeffs
)
3507 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3513 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3515 val
= ((cbp
>> (5 - i
)) & 1);
3516 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3517 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3519 /* check if prediction blocks A and C are available */
3520 v
->a_avail
= v
->c_avail
= 0;
3521 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3522 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3523 if(i
== 1 || i
== 3 || s
->mb_x
)
3524 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3526 vc1_decode_intra_block(v
, s
->block
[i
], i
, val
, mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3527 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3528 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3529 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3530 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3532 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);
3533 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3539 /** Decode blocks of I-frame
3541 static void vc1_decode_i_blocks(VC1Context
*v
)
3544 MpegEncContext
*s
= &v
->s
;
3549 /* select codingmode used for VLC tables selection */
3550 switch(v
->y_ac_table_index
){
3552 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3555 v
->codingset
= CS_HIGH_MOT_INTRA
;
3558 v
->codingset
= CS_MID_RATE_INTRA
;
3562 switch(v
->c_ac_table_index
){
3564 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3567 v
->codingset2
= CS_HIGH_MOT_INTER
;
3570 v
->codingset2
= CS_MID_RATE_INTER
;
3574 /* Set DC scale - y and c use the same */
3575 s
->y_dc_scale
= s
->y_dc_scale_table
[v
->pq
];
3576 s
->c_dc_scale
= s
->c_dc_scale_table
[v
->pq
];
3579 s
->mb_x
= s
->mb_y
= 0;
3581 s
->first_slice_line
= 1;
3582 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3583 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3584 ff_init_block_index(s
);
3585 ff_update_block_index(s
);
3586 s
->dsp
.clear_blocks(s
->block
[0]);
3587 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_width
;
3588 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_INTRA
;
3589 s
->current_picture
.qscale_table
[mb_pos
] = v
->pq
;
3590 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3591 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3593 // do actual MB decoding and displaying
3594 cbp
= get_vlc2(&v
->s
.gb
, ff_msmp4_mb_i_vlc
.table
, MB_INTRA_VLC_BITS
, 2);
3595 v
->s
.ac_pred
= get_bits1(&v
->s
.gb
);
3597 for(k
= 0; k
< 6; k
++) {
3598 val
= ((cbp
>> (5 - k
)) & 1);
3601 int pred
= vc1_coded_block_pred(&v
->s
, k
, &coded_val
);
3605 cbp
|= val
<< (5 - k
);
3607 vc1_decode_i_block(v
, s
->block
[k
], k
, val
, (k
<4)? v
->codingset
: v
->codingset2
);
3609 s
->dsp
.vc1_inv_trans_8x8(s
->block
[k
]);
3610 if(v
->pq
>= 9 && v
->overlap
) {
3611 for(j
= 0; j
< 64; j
++) s
->block
[k
][j
] += 128;
3615 vc1_put_block(v
, s
->block
);
3616 if(v
->pq
>= 9 && v
->overlap
) {
3618 s
->dsp
.vc1_h_overlap(s
->dest
[0], s
->linesize
);
3619 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3620 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3621 s
->dsp
.vc1_h_overlap(s
->dest
[1], s
->uvlinesize
);
3622 s
->dsp
.vc1_h_overlap(s
->dest
[2], s
->uvlinesize
);
3625 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8, s
->linesize
);
3626 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3627 if(!s
->first_slice_line
) {
3628 s
->dsp
.vc1_v_overlap(s
->dest
[0], s
->linesize
);
3629 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8, s
->linesize
);
3630 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3631 s
->dsp
.vc1_v_overlap(s
->dest
[1], s
->uvlinesize
);
3632 s
->dsp
.vc1_v_overlap(s
->dest
[2], s
->uvlinesize
);
3635 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3636 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3638 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, s
->current_picture
.qscale_table
[mb_pos
]);
3640 if(get_bits_count(&s
->gb
) > v
->bits
) {
3641 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3642 av_log(s
->avctx
, AV_LOG_ERROR
, "Bits overconsumption: %i > %i\n", get_bits_count(&s
->gb
), v
->bits
);
3646 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3647 s
->first_slice_line
= 0;
3649 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3652 /** Decode blocks of I-frame for advanced profile
3654 static void vc1_decode_i_blocks_adv(VC1Context
*v
)
3657 MpegEncContext
*s
= &v
->s
;
3664 GetBitContext
*gb
= &s
->gb
;
3666 /* select codingmode used for VLC tables selection */
3667 switch(v
->y_ac_table_index
){
3669 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3672 v
->codingset
= CS_HIGH_MOT_INTRA
;
3675 v
->codingset
= CS_MID_RATE_INTRA
;
3679 switch(v
->c_ac_table_index
){
3681 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3684 v
->codingset2
= CS_HIGH_MOT_INTER
;
3687 v
->codingset2
= CS_MID_RATE_INTER
;
3692 s
->mb_x
= s
->mb_y
= 0;
3694 s
->first_slice_line
= 1;
3695 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3696 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3697 ff_init_block_index(s
);
3698 ff_update_block_index(s
);
3699 s
->dsp
.clear_blocks(s
->block
[0]);
3700 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3701 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_INTRA
;
3702 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3703 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3705 // do actual MB decoding and displaying
3706 cbp
= get_vlc2(&v
->s
.gb
, ff_msmp4_mb_i_vlc
.table
, MB_INTRA_VLC_BITS
, 2);
3707 if(v
->acpred_is_raw
)
3708 v
->s
.ac_pred
= get_bits1(&v
->s
.gb
);
3710 v
->s
.ac_pred
= v
->acpred_plane
[mb_pos
];
3712 if(v
->condover
== CONDOVER_SELECT
) {
3713 if(v
->overflg_is_raw
)
3714 overlap
= get_bits1(&v
->s
.gb
);
3716 overlap
= v
->over_flags_plane
[mb_pos
];
3718 overlap
= (v
->condover
== CONDOVER_ALL
);
3722 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3723 /* Set DC scale - y and c use the same */
3724 s
->y_dc_scale
= s
->y_dc_scale_table
[mquant
];
3725 s
->c_dc_scale
= s
->c_dc_scale_table
[mquant
];
3727 for(k
= 0; k
< 6; k
++) {
3728 val
= ((cbp
>> (5 - k
)) & 1);
3731 int pred
= vc1_coded_block_pred(&v
->s
, k
, &coded_val
);
3735 cbp
|= val
<< (5 - k
);
3737 v
->a_avail
= !s
->first_slice_line
|| (k
==2 || k
==3);
3738 v
->c_avail
= !!s
->mb_x
|| (k
==1 || k
==3);
3740 vc1_decode_i_block_adv(v
, s
->block
[k
], k
, val
, (k
<4)? v
->codingset
: v
->codingset2
, mquant
);
3742 s
->dsp
.vc1_inv_trans_8x8(s
->block
[k
]);
3743 for(j
= 0; j
< 64; j
++) s
->block
[k
][j
] += 128;
3746 vc1_put_block(v
, s
->block
);
3749 s
->dsp
.vc1_h_overlap(s
->dest
[0], s
->linesize
);
3750 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3751 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3752 s
->dsp
.vc1_h_overlap(s
->dest
[1], s
->uvlinesize
);
3753 s
->dsp
.vc1_h_overlap(s
->dest
[2], s
->uvlinesize
);
3756 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8, s
->linesize
);
3757 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3758 if(!s
->first_slice_line
) {
3759 s
->dsp
.vc1_v_overlap(s
->dest
[0], s
->linesize
);
3760 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8, s
->linesize
);
3761 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3762 s
->dsp
.vc1_v_overlap(s
->dest
[1], s
->uvlinesize
);
3763 s
->dsp
.vc1_v_overlap(s
->dest
[2], s
->uvlinesize
);
3766 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3767 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3769 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, s
->current_picture
.qscale_table
[mb_pos
]);
3771 if(get_bits_count(&s
->gb
) > v
->bits
) {
3772 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3773 av_log(s
->avctx
, AV_LOG_ERROR
, "Bits overconsumption: %i > %i\n", get_bits_count(&s
->gb
), v
->bits
);
3777 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3778 s
->first_slice_line
= 0;
3780 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3783 static void vc1_decode_p_blocks(VC1Context
*v
)
3785 MpegEncContext
*s
= &v
->s
;
3787 /* select codingmode used for VLC tables selection */
3788 switch(v
->c_ac_table_index
){
3790 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3793 v
->codingset
= CS_HIGH_MOT_INTRA
;
3796 v
->codingset
= CS_MID_RATE_INTRA
;
3800 switch(v
->c_ac_table_index
){
3802 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3805 v
->codingset2
= CS_HIGH_MOT_INTER
;
3808 v
->codingset2
= CS_MID_RATE_INTER
;
3812 s
->first_slice_line
= 1;
3813 memset(v
->cbp_base
, 0, sizeof(v
->cbp_base
[0])*2*s
->mb_stride
);
3814 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3815 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3816 ff_init_block_index(s
);
3817 ff_update_block_index(s
);
3818 s
->dsp
.clear_blocks(s
->block
[0]);
3821 if(get_bits_count(&s
->gb
) > v
->bits
|| get_bits_count(&s
->gb
) < 0) {
3822 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3823 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
);
3827 memmove(v
->cbp_base
, v
->cbp
, sizeof(v
->cbp_base
[0])*s
->mb_stride
);
3828 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3829 s
->first_slice_line
= 0;
3831 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3834 static void vc1_decode_b_blocks(VC1Context
*v
)
3836 MpegEncContext
*s
= &v
->s
;
3838 /* select codingmode used for VLC tables selection */
3839 switch(v
->c_ac_table_index
){
3841 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3844 v
->codingset
= CS_HIGH_MOT_INTRA
;
3847 v
->codingset
= CS_MID_RATE_INTRA
;
3851 switch(v
->c_ac_table_index
){
3853 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3856 v
->codingset2
= CS_HIGH_MOT_INTER
;
3859 v
->codingset2
= CS_MID_RATE_INTER
;
3863 s
->first_slice_line
= 1;
3864 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3865 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3866 ff_init_block_index(s
);
3867 ff_update_block_index(s
);
3868 s
->dsp
.clear_blocks(s
->block
[0]);
3871 if(get_bits_count(&s
->gb
) > v
->bits
|| get_bits_count(&s
->gb
) < 0) {
3872 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3873 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
);
3876 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, s
->current_picture
.qscale_table
[s
->mb_x
+ s
->mb_y
*s
->mb_stride
]);
3878 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3879 s
->first_slice_line
= 0;
3881 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3884 static void vc1_decode_skip_blocks(VC1Context
*v
)
3886 MpegEncContext
*s
= &v
->s
;
3888 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3889 s
->first_slice_line
= 1;
3890 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3892 ff_init_block_index(s
);
3893 ff_update_block_index(s
);
3894 memcpy(s
->dest
[0], s
->last_picture
.data
[0] + s
->mb_y
* 16 * s
->linesize
, s
->linesize
* 16);
3895 memcpy(s
->dest
[1], s
->last_picture
.data
[1] + s
->mb_y
* 8 * s
->uvlinesize
, s
->uvlinesize
* 8);
3896 memcpy(s
->dest
[2], s
->last_picture
.data
[2] + s
->mb_y
* 8 * s
->uvlinesize
, s
->uvlinesize
* 8);
3897 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3898 s
->first_slice_line
= 0;
3900 s
->pict_type
= FF_P_TYPE
;
3903 static void vc1_decode_blocks(VC1Context
*v
)
3906 v
->s
.esc3_level_length
= 0;
3908 ff_intrax8_decode_picture(&v
->x8
, 2*v
->pq
+v
->halfpq
, v
->pq
*(!v
->pquantizer
) );
3911 switch(v
->s
.pict_type
) {
3913 if(v
->profile
== PROFILE_ADVANCED
)
3914 vc1_decode_i_blocks_adv(v
);
3916 vc1_decode_i_blocks(v
);
3919 if(v
->p_frame_skipped
)
3920 vc1_decode_skip_blocks(v
);
3922 vc1_decode_p_blocks(v
);
3926 if(v
->profile
== PROFILE_ADVANCED
)
3927 vc1_decode_i_blocks_adv(v
);
3929 vc1_decode_i_blocks(v
);
3931 vc1_decode_b_blocks(v
);
3937 /** Find VC-1 marker in buffer
3938 * @return position where next marker starts or end of buffer if no marker found
3940 static av_always_inline
const uint8_t* find_next_marker(const uint8_t *src
, const uint8_t *end
)
3942 uint32_t mrk
= 0xFFFFFFFF;
3944 if(end
-src
< 4) return end
;
3946 mrk
= (mrk
<< 8) | *src
++;
3953 static av_always_inline
int vc1_unescape_buffer(const uint8_t *src
, int size
, uint8_t *dst
)
3958 for(dsize
= 0; dsize
< size
; dsize
++) *dst
++ = *src
++;
3961 for(i
= 0; i
< size
; i
++, src
++) {
3962 if(src
[0] == 3 && i
>= 2 && !src
[-1] && !src
[-2] && i
< size
-1 && src
[1] < 4) {
3963 dst
[dsize
++] = src
[1];
3967 dst
[dsize
++] = *src
;
3972 /** Initialize a VC1/WMV3 decoder
3973 * @todo TODO: Handle VC-1 IDUs (Transport level?)
3974 * @todo TODO: Decypher remaining bits in extra_data
3976 static av_cold
int vc1_decode_init(AVCodecContext
*avctx
)
3978 VC1Context
*v
= avctx
->priv_data
;
3979 MpegEncContext
*s
= &v
->s
;
3982 if (!avctx
->extradata_size
|| !avctx
->extradata
) return -1;
3983 if (!(avctx
->flags
& CODEC_FLAG_GRAY
))
3984 avctx
->pix_fmt
= PIX_FMT_YUV420P
;
3986 avctx
->pix_fmt
= PIX_FMT_GRAY8
;
3988 avctx
->flags
|= CODEC_FLAG_EMU_EDGE
;
3989 v
->s
.flags
|= CODEC_FLAG_EMU_EDGE
;
3991 if(avctx
->idct_algo
==FF_IDCT_AUTO
){
3992 avctx
->idct_algo
=FF_IDCT_WMV2
;
3995 if(ff_h263_decode_init(avctx
) < 0)
3997 if (vc1_init_common(v
) < 0) return -1;
3999 avctx
->coded_width
= avctx
->width
;
4000 avctx
->coded_height
= avctx
->height
;
4001 if (avctx
->codec_id
== CODEC_ID_WMV3
)
4005 // looks like WMV3 has a sequence header stored in the extradata
4006 // advanced sequence header may be before the first frame
4007 // the last byte of the extradata is a version number, 1 for the
4008 // samples we can decode
4010 init_get_bits(&gb
, avctx
->extradata
, avctx
->extradata_size
*8);
4012 if (decode_sequence_header(avctx
, &gb
) < 0)
4015 count
= avctx
->extradata_size
*8 - get_bits_count(&gb
);
4018 av_log(avctx
, AV_LOG_INFO
, "Extra data: %i bits left, value: %X\n",
4019 count
, get_bits(&gb
, count
));
4023 av_log(avctx
, AV_LOG_INFO
, "Read %i bits in overflow\n", -count
);
4025 } else { // VC1/WVC1
4026 const uint8_t *start
= avctx
->extradata
;
4027 uint8_t *end
= avctx
->extradata
+ avctx
->extradata_size
;
4028 const uint8_t *next
;
4029 int size
, buf2_size
;
4030 uint8_t *buf2
= NULL
;
4031 int seq_initialized
= 0, ep_initialized
= 0;
4033 if(avctx
->extradata_size
< 16) {
4034 av_log(avctx
, AV_LOG_ERROR
, "Extradata size too small: %i\n", avctx
->extradata_size
);
4038 buf2
= av_mallocz(avctx
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
4039 if(start
[0]) start
++; // in WVC1 extradata first byte is its size
4041 for(; next
< end
; start
= next
){
4042 next
= find_next_marker(start
+ 4, end
);
4043 size
= next
- start
- 4;
4044 if(size
<= 0) continue;
4045 buf2_size
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4046 init_get_bits(&gb
, buf2
, buf2_size
* 8);
4047 switch(AV_RB32(start
)){
4048 case VC1_CODE_SEQHDR
:
4049 if(decode_sequence_header(avctx
, &gb
) < 0){
4053 seq_initialized
= 1;
4055 case VC1_CODE_ENTRYPOINT
:
4056 if(decode_entry_point(avctx
, &gb
) < 0){
4065 if(!seq_initialized
|| !ep_initialized
){
4066 av_log(avctx
, AV_LOG_ERROR
, "Incomplete extradata\n");
4070 avctx
->has_b_frames
= !!(avctx
->max_b_frames
);
4071 s
->low_delay
= !avctx
->has_b_frames
;
4073 s
->mb_width
= (avctx
->coded_width
+15)>>4;
4074 s
->mb_height
= (avctx
->coded_height
+15)>>4;
4076 /* Allocate mb bitplanes */
4077 v
->mv_type_mb_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4078 v
->direct_mb_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4079 v
->acpred_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4080 v
->over_flags_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4082 v
->cbp_base
= av_malloc(sizeof(v
->cbp_base
[0]) * 2 * s
->mb_stride
);
4083 v
->cbp
= v
->cbp_base
+ s
->mb_stride
;
4085 /* allocate block type info in that way so it could be used with s->block_index[] */
4086 v
->mb_type_base
= av_malloc(s
->b8_stride
* (s
->mb_height
* 2 + 1) + s
->mb_stride
* (s
->mb_height
+ 1) * 2);
4087 v
->mb_type
[0] = v
->mb_type_base
+ s
->b8_stride
+ 1;
4088 v
->mb_type
[1] = v
->mb_type_base
+ s
->b8_stride
* (s
->mb_height
* 2 + 1) + s
->mb_stride
+ 1;
4089 v
->mb_type
[2] = v
->mb_type
[1] + s
->mb_stride
* (s
->mb_height
+ 1);
4091 /* Init coded blocks info */
4092 if (v
->profile
== PROFILE_ADVANCED
)
4094 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
4096 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
4100 ff_intrax8_common_init(&v
->x8
,s
);
4105 /** Decode a VC1/WMV3 frame
4106 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4108 static int vc1_decode_frame(AVCodecContext
*avctx
,
4109 void *data
, int *data_size
,
4110 const uint8_t *buf
, int buf_size
)
4112 VC1Context
*v
= avctx
->priv_data
;
4113 MpegEncContext
*s
= &v
->s
;
4114 AVFrame
*pict
= data
;
4115 uint8_t *buf2
= NULL
;
4117 /* no supplementary picture */
4118 if (buf_size
== 0) {
4119 /* special case for last picture */
4120 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
4121 *pict
= *(AVFrame
*)s
->next_picture_ptr
;
4122 s
->next_picture_ptr
= NULL
;
4124 *data_size
= sizeof(AVFrame
);
4130 /* We need to set current_picture_ptr before reading the header,
4131 * otherwise we cannot store anything in there. */
4132 if(s
->current_picture_ptr
==NULL
|| s
->current_picture_ptr
->data
[0]){
4133 int i
= ff_find_unused_picture(s
, 0);
4134 s
->current_picture_ptr
= &s
->picture
[i
];
4137 //for advanced profile we may need to parse and unescape data
4138 if (avctx
->codec_id
== CODEC_ID_VC1
) {
4140 buf2
= av_mallocz(buf_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
4142 if(IS_MARKER(AV_RB32(buf
))){ /* frame starts with marker and needs to be parsed */
4143 const uint8_t *start
, *end
, *next
;
4147 for(start
= buf
, end
= buf
+ buf_size
; next
< end
; start
= next
){
4148 next
= find_next_marker(start
+ 4, end
);
4149 size
= next
- start
- 4;
4150 if(size
<= 0) continue;
4151 switch(AV_RB32(start
)){
4152 case VC1_CODE_FRAME
:
4153 buf_size2
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4155 case VC1_CODE_ENTRYPOINT
: /* it should be before frame data */
4156 buf_size2
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4157 init_get_bits(&s
->gb
, buf2
, buf_size2
*8);
4158 decode_entry_point(avctx
, &s
->gb
);
4160 case VC1_CODE_SLICE
:
4161 av_log(avctx
, AV_LOG_ERROR
, "Sliced decoding is not implemented (yet)\n");
4166 }else if(v
->interlace
&& ((buf
[0] & 0xC0) == 0xC0)){ /* WVC1 interlaced stores both fields divided by marker */
4167 const uint8_t *divider
;
4169 divider
= find_next_marker(buf
, buf
+ buf_size
);
4170 if((divider
== (buf
+ buf_size
)) || AV_RB32(divider
) != VC1_CODE_FIELD
){
4171 av_log(avctx
, AV_LOG_ERROR
, "Error in WVC1 interlaced frame\n");
4176 buf_size2
= vc1_unescape_buffer(buf
, divider
- buf
, buf2
);
4178 av_free(buf2
);return -1;
4180 buf_size2
= vc1_unescape_buffer(buf
, buf_size
, buf2
);
4182 init_get_bits(&s
->gb
, buf2
, buf_size2
*8);
4184 init_get_bits(&s
->gb
, buf
, buf_size
*8);
4185 // do parse frame header
4186 if(v
->profile
< PROFILE_ADVANCED
) {
4187 if(vc1_parse_frame_header(v
, &s
->gb
) == -1) {
4192 if(vc1_parse_frame_header_adv(v
, &s
->gb
) == -1) {
4198 if(s
->pict_type
!= FF_I_TYPE
&& !v
->res_rtm_flag
){
4204 s
->current_picture
.pict_type
= s
->pict_type
;
4205 s
->current_picture
.key_frame
= s
->pict_type
== FF_I_TYPE
;
4207 /* skip B-frames if we don't have reference frames */
4208 if(s
->last_picture_ptr
==NULL
&& (s
->pict_type
==FF_B_TYPE
|| s
->dropable
)){
4210 return -1;//buf_size;
4212 /* skip b frames if we are in a hurry */
4213 if(avctx
->hurry_up
&& s
->pict_type
==FF_B_TYPE
) return -1;//buf_size;
4214 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& s
->pict_type
==FF_B_TYPE
)
4215 || (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& s
->pict_type
!=FF_I_TYPE
)
4216 || avctx
->skip_frame
>= AVDISCARD_ALL
) {
4220 /* skip everything if we are in a hurry>=5 */
4221 if(avctx
->hurry_up
>=5) {
4223 return -1;//buf_size;
4226 if(s
->next_p_frame_damaged
){
4227 if(s
->pict_type
==FF_B_TYPE
)
4230 s
->next_p_frame_damaged
=0;
4233 if(MPV_frame_start(s
, avctx
) < 0) {
4238 s
->me
.qpel_put
= s
->dsp
.put_qpel_pixels_tab
;
4239 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
4241 ff_er_frame_start(s
);
4243 v
->bits
= buf_size
* 8;
4244 vc1_decode_blocks(v
);
4245 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
4246 // if(get_bits_count(&s->gb) > buf_size * 8)
4252 assert(s
->current_picture
.pict_type
== s
->current_picture_ptr
->pict_type
);
4253 assert(s
->current_picture
.pict_type
== s
->pict_type
);
4254 if (s
->pict_type
== FF_B_TYPE
|| s
->low_delay
) {
4255 *pict
= *(AVFrame
*)s
->current_picture_ptr
;
4256 } else if (s
->last_picture_ptr
!= NULL
) {
4257 *pict
= *(AVFrame
*)s
->last_picture_ptr
;
4260 if(s
->last_picture_ptr
|| s
->low_delay
){
4261 *data_size
= sizeof(AVFrame
);
4262 ff_print_debug_info(s
, pict
);
4265 /* Return the Picture timestamp as the frame number */
4266 /* we subtract 1 because it is added on utils.c */
4267 avctx
->frame_number
= s
->picture_number
- 1;
4274 /** Close a VC1/WMV3 decoder
4275 * @warning Initial try at using MpegEncContext stuff
4277 static av_cold
int vc1_decode_end(AVCodecContext
*avctx
)
4279 VC1Context
*v
= avctx
->priv_data
;
4281 av_freep(&v
->hrd_rate
);
4282 av_freep(&v
->hrd_buffer
);
4283 MPV_common_end(&v
->s
);
4284 av_freep(&v
->mv_type_mb_plane
);
4285 av_freep(&v
->direct_mb_plane
);
4286 av_freep(&v
->acpred_plane
);
4287 av_freep(&v
->over_flags_plane
);
4288 av_freep(&v
->mb_type_base
);
4289 av_freep(&v
->cbp_base
);
4290 ff_intrax8_common_end(&v
->x8
);
4295 AVCodec vc1_decoder
= {
4306 .long_name
= NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
4309 AVCodec wmv3_decoder
= {
4320 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 9"),