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 v
->postproc
= get_bits1(gb
);
1400 if(v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_P_TYPE
) v
->use_ic
= 0;
1402 switch(v
->s
.pict_type
) {
1405 status
= bitplane_decoding(v
->acpred_plane
, &v
->acpred_is_raw
, v
);
1406 if (status
< 0) return -1;
1407 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "ACPRED plane encoding: "
1408 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1409 v
->condover
= CONDOVER_NONE
;
1410 if(v
->overlap
&& v
->pq
<= 8) {
1411 v
->condover
= decode012(gb
);
1412 if(v
->condover
== CONDOVER_SELECT
) {
1413 status
= bitplane_decoding(v
->over_flags_plane
, &v
->overflg_is_raw
, v
);
1414 if (status
< 0) return -1;
1415 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "CONDOVER plane encoding: "
1416 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
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)];
1510 if (v
->extended_mv
) v
->mvrange
= get_unary(gb
, 0, 3);
1511 else v
->mvrange
= 0;
1512 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1513 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1514 v
->range_x
= 1 << (v
->k_x
- 1);
1515 v
->range_y
= 1 << (v
->k_y
- 1);
1517 if (v
->pq
< 5) v
->tt_index
= 0;
1518 else if(v
->pq
< 13) v
->tt_index
= 1;
1519 else v
->tt_index
= 2;
1521 lowquant
= (v
->pq
> 12) ? 0 : 1;
1522 v
->mv_mode
= get_bits1(gb
) ? MV_PMODE_1MV
: MV_PMODE_1MV_HPEL_BILIN
;
1523 v
->s
.quarter_sample
= (v
->mv_mode
== MV_PMODE_1MV
);
1524 v
->s
.mspel
= v
->s
.quarter_sample
;
1526 status
= bitplane_decoding(v
->direct_mb_plane
, &v
->dmb_is_raw
, v
);
1527 if (status
< 0) return -1;
1528 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Direct Type plane encoding: "
1529 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1530 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1531 if (status
< 0) return -1;
1532 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1533 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1535 v
->s
.mv_table_index
= get_bits(gb
, 2);
1536 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1540 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1541 vop_dquant_decoding(v
);
1547 v
->ttmbf
= get_bits1(gb
);
1550 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1560 v
->c_ac_table_index
= decode012(gb
);
1561 if (v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
)
1563 v
->y_ac_table_index
= decode012(gb
);
1566 v
->s
.dc_table_index
= get_bits1(gb
);
1567 if ((v
->s
.pict_type
== FF_I_TYPE
|| v
->s
.pict_type
== FF_BI_TYPE
) && v
->dquant
) {
1568 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1569 vop_dquant_decoding(v
);
1573 if(v
->s
.pict_type
== FF_BI_TYPE
) {
1574 v
->s
.pict_type
= FF_B_TYPE
;
1580 /***********************************************************************/
1582 * @defgroup block VC-1 Block-level functions
1583 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1589 * @brief Get macroblock-level quantizer scale
1591 #define GET_MQUANT() \
1595 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1599 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1603 mqdiff = get_bits(gb, 3); \
1604 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1605 else mquant = get_bits(gb, 5); \
1608 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1609 edges = 1 << v->dqsbedge; \
1610 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1611 edges = (3 << v->dqsbedge) % 15; \
1612 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
1614 if((edges&1) && !s->mb_x) \
1615 mquant = v->altpq; \
1616 if((edges&2) && s->first_slice_line) \
1617 mquant = v->altpq; \
1618 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
1619 mquant = v->altpq; \
1620 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
1621 mquant = v->altpq; \
1625 * @def GET_MVDATA(_dmv_x, _dmv_y)
1626 * @brief Get MV differentials
1627 * @see MVDATA decoding from 8.3.5.2, p(1)20
1628 * @param _dmv_x Horizontal differential for decoded MV
1629 * @param _dmv_y Vertical differential for decoded MV
1631 #define GET_MVDATA(_dmv_x, _dmv_y) \
1632 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table,\
1633 VC1_MV_DIFF_VLC_BITS, 2); \
1636 mb_has_coeffs = 1; \
1639 else mb_has_coeffs = 0; \
1641 if (!index) { _dmv_x = _dmv_y = 0; } \
1642 else if (index == 35) \
1644 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1645 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1647 else if (index == 36) \
1656 if (!s->quarter_sample && index1 == 5) val = 1; \
1658 if(size_table[index1] - val > 0) \
1659 val = get_bits(gb, size_table[index1] - val); \
1661 sign = 0 - (val&1); \
1662 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1665 if (!s->quarter_sample && index1 == 5) val = 1; \
1667 if(size_table[index1] - val > 0) \
1668 val = get_bits(gb, size_table[index1] - val); \
1670 sign = 0 - (val&1); \
1671 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1674 /** Predict and set motion vector
1676 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
)
1678 int xy
, wrap
, off
= 0;
1683 /* scale MV difference to be quad-pel */
1684 dmv_x
<<= 1 - s
->quarter_sample
;
1685 dmv_y
<<= 1 - s
->quarter_sample
;
1687 wrap
= s
->b8_stride
;
1688 xy
= s
->block_index
[n
];
1691 s
->mv
[0][n
][0] = s
->current_picture
.motion_val
[0][xy
][0] = 0;
1692 s
->mv
[0][n
][1] = s
->current_picture
.motion_val
[0][xy
][1] = 0;
1693 s
->current_picture
.motion_val
[1][xy
][0] = 0;
1694 s
->current_picture
.motion_val
[1][xy
][1] = 0;
1695 if(mv1
) { /* duplicate motion data for 1-MV block */
1696 s
->current_picture
.motion_val
[0][xy
+ 1][0] = 0;
1697 s
->current_picture
.motion_val
[0][xy
+ 1][1] = 0;
1698 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = 0;
1699 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = 0;
1700 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][0] = 0;
1701 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][1] = 0;
1702 s
->current_picture
.motion_val
[1][xy
+ 1][0] = 0;
1703 s
->current_picture
.motion_val
[1][xy
+ 1][1] = 0;
1704 s
->current_picture
.motion_val
[1][xy
+ wrap
][0] = 0;
1705 s
->current_picture
.motion_val
[1][xy
+ wrap
][1] = 0;
1706 s
->current_picture
.motion_val
[1][xy
+ wrap
+ 1][0] = 0;
1707 s
->current_picture
.motion_val
[1][xy
+ wrap
+ 1][1] = 0;
1712 C
= s
->current_picture
.motion_val
[0][xy
- 1];
1713 A
= s
->current_picture
.motion_val
[0][xy
- wrap
];
1715 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -1 : 2;
1717 //in 4-MV mode different blocks have different B predictor position
1720 off
= (s
->mb_x
> 0) ? -1 : 1;
1723 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -1 : 1;
1732 B
= s
->current_picture
.motion_val
[0][xy
- wrap
+ off
];
1734 if(!s
->first_slice_line
|| (n
==2 || n
==3)) { // predictor A is not out of bounds
1735 if(s
->mb_width
== 1) {
1739 px
= mid_pred(A
[0], B
[0], C
[0]);
1740 py
= mid_pred(A
[1], B
[1], C
[1]);
1742 } else if(s
->mb_x
|| (n
==1 || n
==3)) { // predictor C is not out of bounds
1748 /* Pullback MV as specified in 8.3.5.3.4 */
1751 qx
= (s
->mb_x
<< 6) + ((n
==1 || n
==3) ? 32 : 0);
1752 qy
= (s
->mb_y
<< 6) + ((n
==2 || n
==3) ? 32 : 0);
1753 X
= (s
->mb_width
<< 6) - 4;
1754 Y
= (s
->mb_height
<< 6) - 4;
1756 if(qx
+ px
< -60) px
= -60 - qx
;
1757 if(qy
+ py
< -60) py
= -60 - qy
;
1759 if(qx
+ px
< -28) px
= -28 - qx
;
1760 if(qy
+ py
< -28) py
= -28 - qy
;
1762 if(qx
+ px
> X
) px
= X
- qx
;
1763 if(qy
+ py
> Y
) py
= Y
- qy
;
1765 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1766 if((!s
->first_slice_line
|| (n
==2 || n
==3)) && (s
->mb_x
|| (n
==1 || n
==3))) {
1767 if(is_intra
[xy
- wrap
])
1768 sum
= FFABS(px
) + FFABS(py
);
1770 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
1772 if(get_bits1(&s
->gb
)) {
1780 if(is_intra
[xy
- 1])
1781 sum
= FFABS(px
) + FFABS(py
);
1783 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
1785 if(get_bits1(&s
->gb
)) {
1795 /* store MV using signed modulus of MV range defined in 4.11 */
1796 s
->mv
[0][n
][0] = s
->current_picture
.motion_val
[0][xy
][0] = ((px
+ dmv_x
+ r_x
) & ((r_x
<< 1) - 1)) - r_x
;
1797 s
->mv
[0][n
][1] = s
->current_picture
.motion_val
[0][xy
][1] = ((py
+ dmv_y
+ r_y
) & ((r_y
<< 1) - 1)) - r_y
;
1798 if(mv1
) { /* duplicate motion data for 1-MV block */
1799 s
->current_picture
.motion_val
[0][xy
+ 1][0] = s
->current_picture
.motion_val
[0][xy
][0];
1800 s
->current_picture
.motion_val
[0][xy
+ 1][1] = s
->current_picture
.motion_val
[0][xy
][1];
1801 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = s
->current_picture
.motion_val
[0][xy
][0];
1802 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = s
->current_picture
.motion_val
[0][xy
][1];
1803 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][0] = s
->current_picture
.motion_val
[0][xy
][0];
1804 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][1] = s
->current_picture
.motion_val
[0][xy
][1];
1808 /** Motion compensation for direct or interpolated blocks in B-frames
1810 static void vc1_interp_mc(VC1Context
*v
)
1812 MpegEncContext
*s
= &v
->s
;
1813 DSPContext
*dsp
= &v
->s
.dsp
;
1814 uint8_t *srcY
, *srcU
, *srcV
;
1815 int dxy
, uvdxy
, mx
, my
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
1817 if(!v
->s
.next_picture
.data
[0])return;
1819 mx
= s
->mv
[1][0][0];
1820 my
= s
->mv
[1][0][1];
1821 uvmx
= (mx
+ ((mx
& 3) == 3)) >> 1;
1822 uvmy
= (my
+ ((my
& 3) == 3)) >> 1;
1824 uvmx
= uvmx
+ ((uvmx
<0)?-(uvmx
&1):(uvmx
&1));
1825 uvmy
= uvmy
+ ((uvmy
<0)?-(uvmy
&1):(uvmy
&1));
1827 srcY
= s
->next_picture
.data
[0];
1828 srcU
= s
->next_picture
.data
[1];
1829 srcV
= s
->next_picture
.data
[2];
1831 src_x
= s
->mb_x
* 16 + (mx
>> 2);
1832 src_y
= s
->mb_y
* 16 + (my
>> 2);
1833 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
1834 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
1836 if(v
->profile
!= PROFILE_ADVANCED
){
1837 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
1838 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
1839 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
1840 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
1842 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
1843 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
1844 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
1845 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
1848 srcY
+= src_y
* s
->linesize
+ src_x
;
1849 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
1850 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
1852 /* for grayscale we should not try to read from unknown area */
1853 if(s
->flags
& CODEC_FLAG_GRAY
) {
1854 srcU
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
1855 srcV
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
1859 || (unsigned)src_x
> s
->h_edge_pos
- (mx
&3) - 16
1860 || (unsigned)src_y
> s
->v_edge_pos
- (my
&3) - 16){
1861 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 19 * s
->linesize
;
1863 srcY
-= s
->mspel
* (1 + s
->linesize
);
1864 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 17+s
->mspel
*2, 17+s
->mspel
*2,
1865 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
1866 srcY
= s
->edge_emu_buffer
;
1867 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, 8+1, 8+1,
1868 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
1869 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
1870 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
1873 /* if we deal with range reduction we need to scale source blocks */
1874 if(v
->rangeredfrm
) {
1876 uint8_t *src
, *src2
;
1879 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
1880 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
1883 src
= srcU
; src2
= srcV
;
1884 for(j
= 0; j
< 9; j
++) {
1885 for(i
= 0; i
< 9; i
++) {
1886 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
1887 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
1889 src
+= s
->uvlinesize
;
1890 src2
+= s
->uvlinesize
;
1893 srcY
+= s
->mspel
* (1 + s
->linesize
);
1898 dxy
= ((my
& 1) << 1) | (mx
& 1);
1900 dsp
->avg_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
1902 if(s
->flags
& CODEC_FLAG_GRAY
) return;
1903 /* Chroma MC always uses qpel blilinear */
1904 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
1907 dsp
->avg_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1908 dsp
->avg_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1911 static av_always_inline
int scale_mv(int value
, int bfrac
, int inv
, int qs
)
1915 #if B_FRACTION_DEN==256
1919 return 2 * ((value
* n
+ 255) >> 9);
1920 return (value
* n
+ 128) >> 8;
1923 n
-= B_FRACTION_DEN
;
1925 return 2 * ((value
* n
+ B_FRACTION_DEN
- 1) / (2 * B_FRACTION_DEN
));
1926 return (value
* n
+ B_FRACTION_DEN
/2) / B_FRACTION_DEN
;
1930 /** Reconstruct motion vector for B-frame and do motion compensation
1932 static inline void vc1_b_mc(VC1Context
*v
, int dmv_x
[2], int dmv_y
[2], int direct
, int mode
)
1935 v
->mv_mode2
= v
->mv_mode
;
1936 v
->mv_mode
= MV_PMODE_INTENSITY_COMP
;
1941 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1944 if(mode
== BMV_TYPE_INTERPOLATED
) {
1947 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1951 if(v
->use_ic
&& (mode
== BMV_TYPE_BACKWARD
)) v
->mv_mode
= v
->mv_mode2
;
1952 vc1_mc_1mv(v
, (mode
== BMV_TYPE_BACKWARD
));
1953 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1956 static inline void vc1_pred_b_mv(VC1Context
*v
, int dmv_x
[2], int dmv_y
[2], int direct
, int mvtype
)
1958 MpegEncContext
*s
= &v
->s
;
1959 int xy
, wrap
, off
= 0;
1964 const uint8_t *is_intra
= v
->mb_type
[0];
1968 /* scale MV difference to be quad-pel */
1969 dmv_x
[0] <<= 1 - s
->quarter_sample
;
1970 dmv_y
[0] <<= 1 - s
->quarter_sample
;
1971 dmv_x
[1] <<= 1 - s
->quarter_sample
;
1972 dmv_y
[1] <<= 1 - s
->quarter_sample
;
1974 wrap
= s
->b8_stride
;
1975 xy
= s
->block_index
[0];
1978 s
->current_picture
.motion_val
[0][xy
][0] =
1979 s
->current_picture
.motion_val
[0][xy
][1] =
1980 s
->current_picture
.motion_val
[1][xy
][0] =
1981 s
->current_picture
.motion_val
[1][xy
][1] = 0;
1984 s
->mv
[0][0][0] = scale_mv(s
->next_picture
.motion_val
[1][xy
][0], v
->bfraction
, 0, s
->quarter_sample
);
1985 s
->mv
[0][0][1] = scale_mv(s
->next_picture
.motion_val
[1][xy
][1], v
->bfraction
, 0, s
->quarter_sample
);
1986 s
->mv
[1][0][0] = scale_mv(s
->next_picture
.motion_val
[1][xy
][0], v
->bfraction
, 1, s
->quarter_sample
);
1987 s
->mv
[1][0][1] = scale_mv(s
->next_picture
.motion_val
[1][xy
][1], v
->bfraction
, 1, s
->quarter_sample
);
1989 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
1990 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));
1991 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));
1992 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));
1993 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));
1995 s
->current_picture
.motion_val
[0][xy
][0] = s
->mv
[0][0][0];
1996 s
->current_picture
.motion_val
[0][xy
][1] = s
->mv
[0][0][1];
1997 s
->current_picture
.motion_val
[1][xy
][0] = s
->mv
[1][0][0];
1998 s
->current_picture
.motion_val
[1][xy
][1] = s
->mv
[1][0][1];
2002 if((mvtype
== BMV_TYPE_FORWARD
) || (mvtype
== BMV_TYPE_INTERPOLATED
)) {
2003 C
= s
->current_picture
.motion_val
[0][xy
- 2];
2004 A
= s
->current_picture
.motion_val
[0][xy
- wrap
*2];
2005 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -2 : 2;
2006 B
= s
->current_picture
.motion_val
[0][xy
- wrap
*2 + off
];
2008 if(!s
->mb_x
) C
[0] = C
[1] = 0;
2009 if(!s
->first_slice_line
) { // predictor A is not out of bounds
2010 if(s
->mb_width
== 1) {
2014 px
= mid_pred(A
[0], B
[0], C
[0]);
2015 py
= mid_pred(A
[1], B
[1], C
[1]);
2017 } else if(s
->mb_x
) { // predictor C is not out of bounds
2023 /* Pullback MV as specified in 8.3.5.3.4 */
2026 if(v
->profile
< PROFILE_ADVANCED
) {
2027 qx
= (s
->mb_x
<< 5);
2028 qy
= (s
->mb_y
<< 5);
2029 X
= (s
->mb_width
<< 5) - 4;
2030 Y
= (s
->mb_height
<< 5) - 4;
2031 if(qx
+ px
< -28) px
= -28 - qx
;
2032 if(qy
+ py
< -28) py
= -28 - qy
;
2033 if(qx
+ px
> X
) px
= X
- qx
;
2034 if(qy
+ py
> Y
) py
= Y
- qy
;
2036 qx
= (s
->mb_x
<< 6);
2037 qy
= (s
->mb_y
<< 6);
2038 X
= (s
->mb_width
<< 6) - 4;
2039 Y
= (s
->mb_height
<< 6) - 4;
2040 if(qx
+ px
< -60) px
= -60 - qx
;
2041 if(qy
+ py
< -60) py
= -60 - qy
;
2042 if(qx
+ px
> X
) px
= X
- qx
;
2043 if(qy
+ py
> Y
) py
= Y
- qy
;
2046 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2047 if(0 && !s
->first_slice_line
&& s
->mb_x
) {
2048 if(is_intra
[xy
- wrap
])
2049 sum
= FFABS(px
) + FFABS(py
);
2051 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
2053 if(get_bits1(&s
->gb
)) {
2061 if(is_intra
[xy
- 2])
2062 sum
= FFABS(px
) + FFABS(py
);
2064 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
2066 if(get_bits1(&s
->gb
)) {
2076 /* store MV using signed modulus of MV range defined in 4.11 */
2077 s
->mv
[0][0][0] = ((px
+ dmv_x
[0] + r_x
) & ((r_x
<< 1) - 1)) - r_x
;
2078 s
->mv
[0][0][1] = ((py
+ dmv_y
[0] + r_y
) & ((r_y
<< 1) - 1)) - r_y
;
2080 if((mvtype
== BMV_TYPE_BACKWARD
) || (mvtype
== BMV_TYPE_INTERPOLATED
)) {
2081 C
= s
->current_picture
.motion_val
[1][xy
- 2];
2082 A
= s
->current_picture
.motion_val
[1][xy
- wrap
*2];
2083 off
= (s
->mb_x
== (s
->mb_width
- 1)) ? -2 : 2;
2084 B
= s
->current_picture
.motion_val
[1][xy
- wrap
*2 + off
];
2086 if(!s
->mb_x
) C
[0] = C
[1] = 0;
2087 if(!s
->first_slice_line
) { // predictor A is not out of bounds
2088 if(s
->mb_width
== 1) {
2092 px
= mid_pred(A
[0], B
[0], C
[0]);
2093 py
= mid_pred(A
[1], B
[1], C
[1]);
2095 } else if(s
->mb_x
) { // predictor C is not out of bounds
2101 /* Pullback MV as specified in 8.3.5.3.4 */
2104 if(v
->profile
< PROFILE_ADVANCED
) {
2105 qx
= (s
->mb_x
<< 5);
2106 qy
= (s
->mb_y
<< 5);
2107 X
= (s
->mb_width
<< 5) - 4;
2108 Y
= (s
->mb_height
<< 5) - 4;
2109 if(qx
+ px
< -28) px
= -28 - qx
;
2110 if(qy
+ py
< -28) py
= -28 - qy
;
2111 if(qx
+ px
> X
) px
= X
- qx
;
2112 if(qy
+ py
> Y
) py
= Y
- qy
;
2114 qx
= (s
->mb_x
<< 6);
2115 qy
= (s
->mb_y
<< 6);
2116 X
= (s
->mb_width
<< 6) - 4;
2117 Y
= (s
->mb_height
<< 6) - 4;
2118 if(qx
+ px
< -60) px
= -60 - qx
;
2119 if(qy
+ py
< -60) py
= -60 - qy
;
2120 if(qx
+ px
> X
) px
= X
- qx
;
2121 if(qy
+ py
> Y
) py
= Y
- qy
;
2124 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2125 if(0 && !s
->first_slice_line
&& s
->mb_x
) {
2126 if(is_intra
[xy
- wrap
])
2127 sum
= FFABS(px
) + FFABS(py
);
2129 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
2131 if(get_bits1(&s
->gb
)) {
2139 if(is_intra
[xy
- 2])
2140 sum
= FFABS(px
) + FFABS(py
);
2142 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
2144 if(get_bits1(&s
->gb
)) {
2154 /* store MV using signed modulus of MV range defined in 4.11 */
2156 s
->mv
[1][0][0] = ((px
+ dmv_x
[1] + r_x
) & ((r_x
<< 1) - 1)) - r_x
;
2157 s
->mv
[1][0][1] = ((py
+ dmv_y
[1] + r_y
) & ((r_y
<< 1) - 1)) - r_y
;
2159 s
->current_picture
.motion_val
[0][xy
][0] = s
->mv
[0][0][0];
2160 s
->current_picture
.motion_val
[0][xy
][1] = s
->mv
[0][0][1];
2161 s
->current_picture
.motion_val
[1][xy
][0] = s
->mv
[1][0][0];
2162 s
->current_picture
.motion_val
[1][xy
][1] = s
->mv
[1][0][1];
2165 /** Get predicted DC value for I-frames only
2166 * prediction dir: left=0, top=1
2167 * @param s MpegEncContext
2168 * @param[in] n block index in the current MB
2169 * @param dc_val_ptr Pointer to DC predictor
2170 * @param dir_ptr Prediction direction for use in AC prediction
2172 static inline int vc1_i_pred_dc(MpegEncContext
*s
, int overlap
, int pq
, int n
,
2173 int16_t **dc_val_ptr
, int *dir_ptr
)
2175 int a
, b
, c
, wrap
, pred
, scale
;
2177 static const uint16_t dcpred
[32] = {
2178 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2179 114, 102, 93, 85, 79, 73, 68, 64,
2180 60, 57, 54, 51, 49, 47, 45, 43,
2181 41, 39, 38, 37, 35, 34, 33
2184 /* find prediction - wmv3_dc_scale always used here in fact */
2185 if (n
< 4) scale
= s
->y_dc_scale
;
2186 else scale
= s
->c_dc_scale
;
2188 wrap
= s
->block_wrap
[n
];
2189 dc_val
= s
->dc_val
[0] + s
->block_index
[n
];
2195 b
= dc_val
[ - 1 - wrap
];
2196 a
= dc_val
[ - wrap
];
2198 if (pq
< 9 || !overlap
)
2200 /* Set outer values */
2201 if (s
->first_slice_line
&& (n
!=2 && n
!=3)) b
=a
=dcpred
[scale
];
2202 if (s
->mb_x
== 0 && (n
!=1 && n
!=3)) b
=c
=dcpred
[scale
];
2206 /* Set outer values */
2207 if (s
->first_slice_line
&& (n
!=2 && n
!=3)) b
=a
=0;
2208 if (s
->mb_x
== 0 && (n
!=1 && n
!=3)) b
=c
=0;
2211 if (abs(a
- b
) <= abs(b
- c
)) {
2219 /* update predictor */
2220 *dc_val_ptr
= &dc_val
[0];
2225 /** Get predicted DC value
2226 * prediction dir: left=0, top=1
2227 * @param s MpegEncContext
2228 * @param[in] n block index in the current MB
2229 * @param dc_val_ptr Pointer to DC predictor
2230 * @param dir_ptr Prediction direction for use in AC prediction
2232 static inline int vc1_pred_dc(MpegEncContext
*s
, int overlap
, int pq
, int n
,
2233 int a_avail
, int c_avail
,
2234 int16_t **dc_val_ptr
, int *dir_ptr
)
2236 int a
, b
, c
, wrap
, pred
, scale
;
2238 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2241 /* find prediction - wmv3_dc_scale always used here in fact */
2242 if (n
< 4) scale
= s
->y_dc_scale
;
2243 else scale
= s
->c_dc_scale
;
2245 wrap
= s
->block_wrap
[n
];
2246 dc_val
= s
->dc_val
[0] + s
->block_index
[n
];
2252 b
= dc_val
[ - 1 - wrap
];
2253 a
= dc_val
[ - wrap
];
2254 /* scale predictors if needed */
2255 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2256 if(c_avail
&& (n
!= 1 && n
!=3)) {
2257 q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2259 c
= (c
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2261 if(a_avail
&& (n
!= 2 && n
!=3)) {
2262 q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2264 a
= (a
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2266 if(a_avail
&& c_avail
&& (n
!=3)) {
2269 if(n
!= 2) off
-= s
->mb_stride
;
2270 q2
= s
->current_picture
.qscale_table
[off
];
2272 b
= (b
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2275 if(a_avail
&& c_avail
) {
2276 if(abs(a
- b
) <= abs(b
- c
)) {
2283 } else if(a_avail
) {
2286 } else if(c_avail
) {
2294 /* update predictor */
2295 *dc_val_ptr
= &dc_val
[0];
2301 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2302 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2306 static inline int vc1_coded_block_pred(MpegEncContext
* s
, int n
, uint8_t **coded_block_ptr
)
2308 int xy
, wrap
, pred
, a
, b
, c
;
2310 xy
= s
->block_index
[n
];
2311 wrap
= s
->b8_stride
;
2316 a
= s
->coded_block
[xy
- 1 ];
2317 b
= s
->coded_block
[xy
- 1 - wrap
];
2318 c
= s
->coded_block
[xy
- wrap
];
2327 *coded_block_ptr
= &s
->coded_block
[xy
];
2333 * Decode one AC coefficient
2334 * @param v The VC1 context
2335 * @param last Last coefficient
2336 * @param skip How much zero coefficients to skip
2337 * @param value Decoded AC coefficient value
2340 static void vc1_decode_ac_coeff(VC1Context
*v
, int *last
, int *skip
, int *value
, int codingset
)
2342 GetBitContext
*gb
= &v
->s
.gb
;
2343 int index
, escape
, run
= 0, level
= 0, lst
= 0;
2345 index
= get_vlc2(gb
, ff_vc1_ac_coeff_table
[codingset
].table
, AC_VLC_BITS
, 3);
2346 if (index
!= vc1_ac_sizes
[codingset
] - 1) {
2347 run
= vc1_index_decode_table
[codingset
][index
][0];
2348 level
= vc1_index_decode_table
[codingset
][index
][1];
2349 lst
= index
>= vc1_last_decode_table
[codingset
];
2353 escape
= decode210(gb
);
2355 index
= get_vlc2(gb
, ff_vc1_ac_coeff_table
[codingset
].table
, AC_VLC_BITS
, 3);
2356 run
= vc1_index_decode_table
[codingset
][index
][0];
2357 level
= vc1_index_decode_table
[codingset
][index
][1];
2358 lst
= index
>= vc1_last_decode_table
[codingset
];
2361 level
+= vc1_last_delta_level_table
[codingset
][run
];
2363 level
+= vc1_delta_level_table
[codingset
][run
];
2366 run
+= vc1_last_delta_run_table
[codingset
][level
] + 1;
2368 run
+= vc1_delta_run_table
[codingset
][level
] + 1;
2374 lst
= get_bits1(gb
);
2375 if(v
->s
.esc3_level_length
== 0) {
2376 if(v
->pq
< 8 || v
->dquantfrm
) { // table 59
2377 v
->s
.esc3_level_length
= get_bits(gb
, 3);
2378 if(!v
->s
.esc3_level_length
)
2379 v
->s
.esc3_level_length
= get_bits(gb
, 2) + 8;
2381 v
->s
.esc3_level_length
= get_unary(gb
, 1, 6) + 2;
2383 v
->s
.esc3_run_length
= 3 + get_bits(gb
, 2);
2385 run
= get_bits(gb
, v
->s
.esc3_run_length
);
2386 sign
= get_bits1(gb
);
2387 level
= get_bits(gb
, v
->s
.esc3_level_length
);
2398 /** Decode intra block in intra frames - should be faster than decode_intra_block
2399 * @param v VC1Context
2400 * @param block block to decode
2401 * @param coded are AC coeffs present or not
2402 * @param codingset set of VLC to decode data
2404 static int vc1_decode_i_block(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int codingset
)
2406 GetBitContext
*gb
= &v
->s
.gb
;
2407 MpegEncContext
*s
= &v
->s
;
2408 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2411 int16_t *ac_val
, *ac_val2
;
2414 /* Get DC differential */
2416 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2418 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2421 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2426 if (dcdiff
== 119 /* ESC index value */)
2428 /* TODO: Optimize */
2429 if (v
->pq
== 1) dcdiff
= get_bits(gb
, 10);
2430 else if (v
->pq
== 2) dcdiff
= get_bits(gb
, 9);
2431 else dcdiff
= get_bits(gb
, 8);
2436 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2437 else if (v
->pq
== 2)
2438 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2445 dcdiff
+= vc1_i_pred_dc(&v
->s
, v
->overlap
, v
->pq
, n
, &dc_val
, &dc_pred_dir
);
2448 /* Store the quantized DC coeff, used for prediction */
2450 block
[0] = dcdiff
* s
->y_dc_scale
;
2452 block
[0] = dcdiff
* s
->c_dc_scale
;
2465 int last
= 0, skip
, value
;
2466 const int8_t *zz_table
;
2470 scale
= v
->pq
* 2 + v
->halfpq
;
2474 zz_table
= wmv1_scantable
[2];
2476 zz_table
= wmv1_scantable
[3];
2478 zz_table
= wmv1_scantable
[1];
2480 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2482 if(dc_pred_dir
) //left
2485 ac_val
-= 16 * s
->block_wrap
[n
];
2488 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2492 block
[zz_table
[i
++]] = value
;
2495 /* apply AC prediction if needed */
2497 if(dc_pred_dir
) { //left
2498 for(k
= 1; k
< 8; k
++)
2499 block
[k
<< 3] += ac_val
[k
];
2501 for(k
= 1; k
< 8; k
++)
2502 block
[k
] += ac_val
[k
+ 8];
2505 /* save AC coeffs for further prediction */
2506 for(k
= 1; k
< 8; k
++) {
2507 ac_val2
[k
] = block
[k
<< 3];
2508 ac_val2
[k
+ 8] = block
[k
];
2511 /* scale AC coeffs */
2512 for(k
= 1; k
< 64; k
++)
2516 block
[k
] += (block
[k
] < 0) ? -v
->pq
: v
->pq
;
2519 if(s
->ac_pred
) i
= 63;
2525 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2528 scale
= v
->pq
* 2 + v
->halfpq
;
2529 memset(ac_val2
, 0, 16 * 2);
2530 if(dc_pred_dir
) {//left
2533 memcpy(ac_val2
, ac_val
, 8 * 2);
2535 ac_val
-= 16 * s
->block_wrap
[n
];
2537 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2540 /* apply AC prediction if needed */
2542 if(dc_pred_dir
) { //left
2543 for(k
= 1; k
< 8; k
++) {
2544 block
[k
<< 3] = ac_val
[k
] * scale
;
2545 if(!v
->pquantizer
&& block
[k
<< 3])
2546 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -v
->pq
: v
->pq
;
2549 for(k
= 1; k
< 8; k
++) {
2550 block
[k
] = ac_val
[k
+ 8] * scale
;
2551 if(!v
->pquantizer
&& block
[k
])
2552 block
[k
] += (block
[k
] < 0) ? -v
->pq
: v
->pq
;
2558 s
->block_last_index
[n
] = i
;
2563 /** Decode intra block in intra frames - should be faster than decode_intra_block
2564 * @param v VC1Context
2565 * @param block block to decode
2566 * @param coded are AC coeffs present or not
2567 * @param codingset set of VLC to decode data
2569 static int vc1_decode_i_block_adv(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int codingset
, int mquant
)
2571 GetBitContext
*gb
= &v
->s
.gb
;
2572 MpegEncContext
*s
= &v
->s
;
2573 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2576 int16_t *ac_val
, *ac_val2
;
2578 int a_avail
= v
->a_avail
, c_avail
= v
->c_avail
;
2579 int use_pred
= s
->ac_pred
;
2582 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2584 /* Get DC differential */
2586 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2588 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2591 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2596 if (dcdiff
== 119 /* ESC index value */)
2598 /* TODO: Optimize */
2599 if (mquant
== 1) dcdiff
= get_bits(gb
, 10);
2600 else if (mquant
== 2) dcdiff
= get_bits(gb
, 9);
2601 else dcdiff
= get_bits(gb
, 8);
2606 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2607 else if (mquant
== 2)
2608 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2615 dcdiff
+= vc1_pred_dc(&v
->s
, v
->overlap
, mquant
, n
, v
->a_avail
, v
->c_avail
, &dc_val
, &dc_pred_dir
);
2618 /* Store the quantized DC coeff, used for prediction */
2620 block
[0] = dcdiff
* s
->y_dc_scale
;
2622 block
[0] = dcdiff
* s
->c_dc_scale
;
2631 /* check if AC is needed at all */
2632 if(!a_avail
&& !c_avail
) use_pred
= 0;
2633 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2636 scale
= mquant
* 2 + ((mquant
== v
->pq
) ? v
->halfpq
: 0);
2638 if(dc_pred_dir
) //left
2641 ac_val
-= 16 * s
->block_wrap
[n
];
2643 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2644 if(dc_pred_dir
&& c_avail
&& mb_pos
) q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2645 if(!dc_pred_dir
&& a_avail
&& mb_pos
>= s
->mb_stride
) q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2646 if(dc_pred_dir
&& n
==1) q2
= q1
;
2647 if(!dc_pred_dir
&& n
==2) q2
= q1
;
2651 int last
= 0, skip
, value
;
2652 const int8_t *zz_table
;
2657 zz_table
= wmv1_scantable
[2];
2659 zz_table
= wmv1_scantable
[3];
2661 zz_table
= wmv1_scantable
[1];
2664 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2668 block
[zz_table
[i
++]] = value
;
2671 /* apply AC prediction if needed */
2673 /* scale predictors if needed*/
2675 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2676 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2678 if(dc_pred_dir
) { //left
2679 for(k
= 1; k
< 8; k
++)
2680 block
[k
<< 3] += (ac_val
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2682 for(k
= 1; k
< 8; k
++)
2683 block
[k
] += (ac_val
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2686 if(dc_pred_dir
) { //left
2687 for(k
= 1; k
< 8; k
++)
2688 block
[k
<< 3] += ac_val
[k
];
2690 for(k
= 1; k
< 8; k
++)
2691 block
[k
] += ac_val
[k
+ 8];
2695 /* save AC coeffs for further prediction */
2696 for(k
= 1; k
< 8; k
++) {
2697 ac_val2
[k
] = block
[k
<< 3];
2698 ac_val2
[k
+ 8] = block
[k
];
2701 /* scale AC coeffs */
2702 for(k
= 1; k
< 64; k
++)
2706 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2709 if(use_pred
) i
= 63;
2710 } else { // no AC coeffs
2713 memset(ac_val2
, 0, 16 * 2);
2714 if(dc_pred_dir
) {//left
2716 memcpy(ac_val2
, ac_val
, 8 * 2);
2718 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2719 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2720 for(k
= 1; k
< 8; k
++)
2721 ac_val2
[k
] = (ac_val2
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2726 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2728 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2729 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2730 for(k
= 1; k
< 8; k
++)
2731 ac_val2
[k
+ 8] = (ac_val2
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2736 /* apply AC prediction if needed */
2738 if(dc_pred_dir
) { //left
2739 for(k
= 1; k
< 8; k
++) {
2740 block
[k
<< 3] = ac_val2
[k
] * scale
;
2741 if(!v
->pquantizer
&& block
[k
<< 3])
2742 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -mquant
: mquant
;
2745 for(k
= 1; k
< 8; k
++) {
2746 block
[k
] = ac_val2
[k
+ 8] * scale
;
2747 if(!v
->pquantizer
&& block
[k
])
2748 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2754 s
->block_last_index
[n
] = i
;
2759 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2760 * @param v VC1Context
2761 * @param block block to decode
2762 * @param coded are AC coeffs present or not
2763 * @param mquant block quantizer
2764 * @param codingset set of VLC to decode data
2766 static int vc1_decode_intra_block(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int mquant
, int codingset
)
2768 GetBitContext
*gb
= &v
->s
.gb
;
2769 MpegEncContext
*s
= &v
->s
;
2770 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2773 int16_t *ac_val
, *ac_val2
;
2775 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2776 int a_avail
= v
->a_avail
, c_avail
= v
->c_avail
;
2777 int use_pred
= s
->ac_pred
;
2781 /* XXX: Guard against dumb values of mquant */
2782 mquant
= (mquant
< 1) ? 0 : ( (mquant
>31) ? 31 : mquant
);
2784 /* Set DC scale - y and c use the same */
2785 s
->y_dc_scale
= s
->y_dc_scale_table
[mquant
];
2786 s
->c_dc_scale
= s
->c_dc_scale_table
[mquant
];
2788 /* Get DC differential */
2790 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2792 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2795 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2800 if (dcdiff
== 119 /* ESC index value */)
2802 /* TODO: Optimize */
2803 if (mquant
== 1) dcdiff
= get_bits(gb
, 10);
2804 else if (mquant
== 2) dcdiff
= get_bits(gb
, 9);
2805 else dcdiff
= get_bits(gb
, 8);
2810 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2811 else if (mquant
== 2)
2812 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2819 dcdiff
+= vc1_pred_dc(&v
->s
, v
->overlap
, mquant
, n
, a_avail
, c_avail
, &dc_val
, &dc_pred_dir
);
2822 /* Store the quantized DC coeff, used for prediction */
2825 block
[0] = dcdiff
* s
->y_dc_scale
;
2827 block
[0] = dcdiff
* s
->c_dc_scale
;
2836 /* check if AC is needed at all and adjust direction if needed */
2837 if(!a_avail
) dc_pred_dir
= 1;
2838 if(!c_avail
) dc_pred_dir
= 0;
2839 if(!a_avail
&& !c_avail
) use_pred
= 0;
2840 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2843 scale
= mquant
* 2 + v
->halfpq
;
2845 if(dc_pred_dir
) //left
2848 ac_val
-= 16 * s
->block_wrap
[n
];
2850 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2851 if(dc_pred_dir
&& c_avail
&& mb_pos
) q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2852 if(!dc_pred_dir
&& a_avail
&& mb_pos
>= s
->mb_stride
) q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2853 if(dc_pred_dir
&& n
==1) q2
= q1
;
2854 if(!dc_pred_dir
&& n
==2) q2
= q1
;
2858 int last
= 0, skip
, value
;
2859 const int8_t *zz_table
;
2862 zz_table
= wmv1_scantable
[0];
2865 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2869 block
[zz_table
[i
++]] = value
;
2872 /* apply AC prediction if needed */
2874 /* scale predictors if needed*/
2876 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2877 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2879 if(dc_pred_dir
) { //left
2880 for(k
= 1; k
< 8; k
++)
2881 block
[k
<< 3] += (ac_val
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2883 for(k
= 1; k
< 8; k
++)
2884 block
[k
] += (ac_val
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2887 if(dc_pred_dir
) { //left
2888 for(k
= 1; k
< 8; k
++)
2889 block
[k
<< 3] += ac_val
[k
];
2891 for(k
= 1; k
< 8; k
++)
2892 block
[k
] += ac_val
[k
+ 8];
2896 /* save AC coeffs for further prediction */
2897 for(k
= 1; k
< 8; k
++) {
2898 ac_val2
[k
] = block
[k
<< 3];
2899 ac_val2
[k
+ 8] = block
[k
];
2902 /* scale AC coeffs */
2903 for(k
= 1; k
< 64; k
++)
2907 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2910 if(use_pred
) i
= 63;
2911 } else { // no AC coeffs
2914 memset(ac_val2
, 0, 16 * 2);
2915 if(dc_pred_dir
) {//left
2917 memcpy(ac_val2
, ac_val
, 8 * 2);
2919 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2920 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2921 for(k
= 1; k
< 8; k
++)
2922 ac_val2
[k
] = (ac_val2
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2927 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2929 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2930 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2931 for(k
= 1; k
< 8; k
++)
2932 ac_val2
[k
+ 8] = (ac_val2
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2937 /* apply AC prediction if needed */
2939 if(dc_pred_dir
) { //left
2940 for(k
= 1; k
< 8; k
++) {
2941 block
[k
<< 3] = ac_val2
[k
] * scale
;
2942 if(!v
->pquantizer
&& block
[k
<< 3])
2943 block
[k
<< 3] += (block
[k
<< 3] < 0) ? -mquant
: mquant
;
2946 for(k
= 1; k
< 8; k
++) {
2947 block
[k
] = ac_val2
[k
+ 8] * scale
;
2948 if(!v
->pquantizer
&& block
[k
])
2949 block
[k
] += (block
[k
] < 0) ? -mquant
: mquant
;
2955 s
->block_last_index
[n
] = i
;
2962 static int vc1_decode_p_block(VC1Context
*v
, DCTELEM block
[64], int n
, int mquant
, int ttmb
, int first_block
,
2963 uint8_t *dst
, int linesize
, int skip_block
, int apply_filter
, int cbp_top
, int cbp_left
)
2965 MpegEncContext
*s
= &v
->s
;
2966 GetBitContext
*gb
= &s
->gb
;
2969 int scale
, off
, idx
, last
, skip
, value
;
2970 int ttblk
= ttmb
& 7;
2974 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)];
2976 if(ttblk
== TT_4X4
) {
2977 subblkpat
= ~(get_vlc2(gb
, ff_vc1_subblkpat_vlc
[v
->tt_index
].table
, VC1_SUBBLKPAT_VLC_BITS
, 1) + 1);
2979 if((ttblk
!= TT_8X8
&& ttblk
!= TT_4X4
) && (v
->ttmbf
|| (ttmb
!= -1 && (ttmb
& 8) && !first_block
))) {
2980 subblkpat
= decode012(gb
);
2981 if(subblkpat
) subblkpat
^= 3; //swap decoded pattern bits
2982 if(ttblk
== TT_8X4_TOP
|| ttblk
== TT_8X4_BOTTOM
) ttblk
= TT_8X4
;
2983 if(ttblk
== TT_4X8_RIGHT
|| ttblk
== TT_4X8_LEFT
) ttblk
= TT_4X8
;
2985 scale
= 2 * mquant
+ ((v
->pq
== mquant
) ? v
->halfpq
: 0);
2987 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2988 if(ttblk
== TT_8X4_TOP
|| ttblk
== TT_8X4_BOTTOM
) {
2989 subblkpat
= 2 - (ttblk
== TT_8X4_TOP
);
2992 if(ttblk
== TT_4X8_RIGHT
|| ttblk
== TT_4X8_LEFT
) {
2993 subblkpat
= 2 - (ttblk
== TT_4X8_LEFT
);
3002 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3006 idx
= wmv1_scantable
[0][i
++];
3007 block
[idx
] = value
* scale
;
3009 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3012 s
->dsp
.vc1_inv_trans_8x8(block
);
3013 s
->dsp
.add_pixels_clamped(block
, dst
, linesize
);
3014 if(apply_filter
&& cbp_top
& 0xC)
3015 vc1_loop_filter(dst
, 1, linesize
, 8, mquant
);
3016 if(apply_filter
&& cbp_left
& 0xA)
3017 vc1_loop_filter(dst
, linesize
, 1, 8, mquant
);
3021 pat
= ~subblkpat
& 0xF;
3022 for(j
= 0; j
< 4; j
++) {
3023 last
= subblkpat
& (1 << (3 - j
));
3025 off
= (j
& 1) * 4 + (j
& 2) * 16;
3027 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3031 idx
= ff_vc1_simple_progressive_4x4_zz
[i
++];
3032 block
[idx
+ off
] = value
* scale
;
3034 block
[idx
+ off
] += (block
[idx
+ off
] < 0) ? -mquant
: mquant
;
3036 if(!(subblkpat
& (1 << (3 - j
))) && !skip_block
){
3037 s
->dsp
.vc1_inv_trans_4x4(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, linesize
, block
+ off
);
3038 if(apply_filter
&& (j
&2 ? pat
& (1<<(j
-2)) : (cbp_top
& (1 << (j
+ 2)))))
3039 vc1_loop_filter(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, 1, linesize
, 4, mquant
);
3040 if(apply_filter
&& (j
&1 ? pat
& (1<<(j
-1)) : (cbp_left
& (1 << (j
+ 1)))))
3041 vc1_loop_filter(dst
+ (j
&1)*4 + (j
&2)*2*linesize
, linesize
, 1, 4, mquant
);
3046 pat
= ~((subblkpat
& 2)*6 + (subblkpat
& 1)*3) & 0xF;
3047 for(j
= 0; j
< 2; j
++) {
3048 last
= subblkpat
& (1 << (1 - j
));
3052 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3056 idx
= v
->zz_8x4
[i
++]+off
;
3057 block
[idx
] = value
* scale
;
3059 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3061 if(!(subblkpat
& (1 << (1 - j
))) && !skip_block
){
3062 s
->dsp
.vc1_inv_trans_8x4(dst
+ j
*4*linesize
, linesize
, block
+ off
);
3063 if(apply_filter
&& j
? pat
& 0x3 : (cbp_top
& 0xC))
3064 vc1_loop_filter(dst
+ j
*4*linesize
, 1, linesize
, 8, mquant
);
3065 if(apply_filter
&& cbp_left
& (2 << j
))
3066 vc1_loop_filter(dst
+ j
*4*linesize
, linesize
, 1, 4, mquant
);
3071 pat
= ~(subblkpat
*5) & 0xF;
3072 for(j
= 0; j
< 2; j
++) {
3073 last
= subblkpat
& (1 << (1 - j
));
3077 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, v
->codingset2
);
3081 idx
= v
->zz_4x8
[i
++]+off
;
3082 block
[idx
] = value
* scale
;
3084 block
[idx
] += (block
[idx
] < 0) ? -mquant
: mquant
;
3086 if(!(subblkpat
& (1 << (1 - j
))) && !skip_block
){
3087 s
->dsp
.vc1_inv_trans_4x8(dst
+ j
*4, linesize
, block
+ off
);
3088 if(apply_filter
&& cbp_top
& (2 << j
))
3089 vc1_loop_filter(dst
+ j
*4, 1, linesize
, 4, mquant
);
3090 if(apply_filter
&& j
? pat
& 0x5 : (cbp_left
& 0xA))
3091 vc1_loop_filter(dst
+ j
*4, linesize
, 1, 8, mquant
);
3100 /** Decode one P-frame MB (in Simple/Main profile)
3102 static int vc1_decode_p_mb(VC1Context
*v
)
3104 MpegEncContext
*s
= &v
->s
;
3105 GetBitContext
*gb
= &s
->gb
;
3107 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3108 int cbp
; /* cbp decoding stuff */
3109 int mqdiff
, mquant
; /* MB quantization */
3110 int ttmb
= v
->ttfrm
; /* MB Transform type */
3112 static const int size_table
[6] = { 0, 2, 3, 4, 5, 8 },
3113 offset_table
[6] = { 0, 1, 3, 7, 15, 31 };
3114 int mb_has_coeffs
= 1; /* last_flag */
3115 int dmv_x
, dmv_y
; /* Differential MV components */
3116 int index
, index1
; /* LUT indexes */
3117 int val
, sign
; /* temp values */
3118 int first_block
= 1;
3120 int skipped
, fourmv
;
3121 int block_cbp
= 0, pat
;
3122 int apply_loop_filter
;
3124 mquant
= v
->pq
; /* Loosy initialization */
3126 if (v
->mv_type_is_raw
)
3127 fourmv
= get_bits1(gb
);
3129 fourmv
= v
->mv_type_mb_plane
[mb_pos
];
3131 skipped
= get_bits1(gb
);
3133 skipped
= v
->s
.mbskip_table
[mb_pos
];
3135 s
->dsp
.clear_blocks(s
->block
[0]);
3137 apply_loop_filter
= s
->loop_filter
&& !(s
->avctx
->skip_loop_filter
>= AVDISCARD_NONKEY
);
3138 if (!fourmv
) /* 1MV mode */
3142 GET_MVDATA(dmv_x
, dmv_y
);
3145 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3146 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3148 s
->current_picture
.mb_type
[mb_pos
] = s
->mb_intra
? MB_TYPE_INTRA
: MB_TYPE_16x16
;
3149 vc1_pred_mv(s
, 0, dmv_x
, dmv_y
, 1, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3151 /* FIXME Set DC val for inter block ? */
3152 if (s
->mb_intra
&& !mb_has_coeffs
)
3155 s
->ac_pred
= get_bits1(gb
);
3158 else if (mb_has_coeffs
)
3160 if (s
->mb_intra
) s
->ac_pred
= get_bits1(gb
);
3161 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3169 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3171 if (!v
->ttmbf
&& !s
->mb_intra
&& mb_has_coeffs
)
3172 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
,
3173 VC1_TTMB_VLC_BITS
, 2);
3174 if(!s
->mb_intra
) vc1_mc_1mv(v
, 0);
3178 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3180 val
= ((cbp
>> (5 - i
)) & 1);
3181 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3182 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3184 /* check if prediction blocks A and C are available */
3185 v
->a_avail
= v
->c_avail
= 0;
3186 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3187 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3188 if(i
== 1 || i
== 3 || s
->mb_x
)
3189 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3191 vc1_decode_intra_block(v
, s
->block
[i
], i
, val
, mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3192 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3193 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3194 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3195 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3196 if(v
->pq
>= 9 && v
->overlap
) {
3198 s
->dsp
.vc1_h_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3200 s
->dsp
.vc1_v_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3202 if(apply_loop_filter
&& s
->mb_x
&& s
->mb_x
!= (s
->mb_width
- 1) && s
->mb_y
&& s
->mb_y
!= (s
->mb_height
- 1)){
3203 int left_cbp
, top_cbp
;
3205 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3206 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3208 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3209 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3212 vc1_loop_filter(s
->dest
[dst_idx
] + off
, 1, i
& 4 ? s
->uvlinesize
: s
->linesize
, 8, mquant
);
3214 vc1_loop_filter(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, 1, 8, mquant
);
3216 block_cbp
|= 0xF << (i
<< 2);
3218 int left_cbp
= 0, top_cbp
= 0, filter
= 0;
3219 if(apply_loop_filter
&& s
->mb_x
&& s
->mb_x
!= (s
->mb_width
- 1) && s
->mb_y
&& s
->mb_y
!= (s
->mb_height
- 1)){
3222 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3223 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3225 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3226 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3229 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
);
3230 block_cbp
|= pat
<< (i
<< 2);
3231 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3239 for(i
= 0; i
< 6; i
++) {
3240 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3241 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3243 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_SKIP
;
3244 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3245 vc1_pred_mv(s
, 0, 0, 0, 1, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3252 if (!skipped
/* unskipped MB */)
3254 int intra_count
= 0, coded_inter
= 0;
3255 int is_intra
[6], is_coded
[6];
3257 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3260 val
= ((cbp
>> (5 - i
)) & 1);
3261 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3268 GET_MVDATA(dmv_x
, dmv_y
);
3270 vc1_pred_mv(s
, i
, dmv_x
, dmv_y
, 0, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3271 if(!s
->mb_intra
) vc1_mc_4mv_luma(v
, i
);
3272 intra_count
+= s
->mb_intra
;
3273 is_intra
[i
] = s
->mb_intra
;
3274 is_coded
[i
] = mb_has_coeffs
;
3277 is_intra
[i
] = (intra_count
>= 3);
3280 if(i
== 4) vc1_mc_4mv_chroma(v
);
3281 v
->mb_type
[0][s
->block_index
[i
]] = is_intra
[i
];
3282 if(!coded_inter
) coded_inter
= !is_intra
[i
] & is_coded
[i
];
3284 // if there are no coded blocks then don't do anything more
3285 if(!intra_count
&& !coded_inter
) return 0;
3288 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3289 /* test if block is intra and has pred */
3294 if(((!s
->first_slice_line
|| (i
==2 || i
==3)) && v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]])
3295 || ((s
->mb_x
|| (i
==1 || i
==3)) && v
->mb_type
[0][s
->block_index
[i
] - 1])) {
3300 if(intrapred
)s
->ac_pred
= get_bits1(gb
);
3301 else s
->ac_pred
= 0;
3303 if (!v
->ttmbf
&& coded_inter
)
3304 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3308 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3309 s
->mb_intra
= is_intra
[i
];
3311 /* check if prediction blocks A and C are available */
3312 v
->a_avail
= v
->c_avail
= 0;
3313 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3314 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3315 if(i
== 1 || i
== 3 || s
->mb_x
)
3316 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3318 vc1_decode_intra_block(v
, s
->block
[i
], i
, is_coded
[i
], mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3319 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3320 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3321 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3322 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, (i
&4)?s
->uvlinesize
:s
->linesize
);
3323 if(v
->pq
>= 9 && v
->overlap
) {
3325 s
->dsp
.vc1_h_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3327 s
->dsp
.vc1_v_overlap(s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3329 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)){
3330 int left_cbp
, top_cbp
;
3332 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3333 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3335 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3336 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3339 vc1_loop_filter(s
->dest
[dst_idx
] + off
, 1, i
& 4 ? s
->uvlinesize
: s
->linesize
, 8, mquant
);
3341 vc1_loop_filter(s
->dest
[dst_idx
] + off
, i
& 4 ? s
->uvlinesize
: s
->linesize
, 1, 8, mquant
);
3343 block_cbp
|= 0xF << (i
<< 2);
3344 } else if(is_coded
[i
]) {
3345 int left_cbp
= 0, top_cbp
= 0, filter
= 0;
3346 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)){
3349 left_cbp
= v
->cbp
[s
->mb_x
- 1] >> (i
* 4);
3350 top_cbp
= v
->cbp
[s
->mb_x
- s
->mb_stride
] >> (i
* 4);
3352 left_cbp
= (i
& 1) ? (pat
>> ((i
-1)*4)) : (v
->cbp
[s
->mb_x
- 1] >> ((i
+1)*4));
3353 top_cbp
= (i
& 2) ? (pat
>> ((i
-2)*4)) : (v
->cbp
[s
->mb_x
- s
->mb_stride
] >> ((i
+2)*4));
3356 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
);
3357 block_cbp
|= pat
<< (i
<< 2);
3358 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3367 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3368 for (i
=0; i
<6; i
++) {
3369 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3370 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3374 vc1_pred_mv(s
, i
, 0, 0, 0, v
->range_x
, v
->range_y
, v
->mb_type
[0]);
3375 vc1_mc_4mv_luma(v
, i
);
3377 vc1_mc_4mv_chroma(v
);
3378 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3382 v
->cbp
[s
->mb_x
] = block_cbp
;
3384 /* Should never happen */
3388 /** Decode one B-frame MB (in Main profile)
3390 static void vc1_decode_b_mb(VC1Context
*v
)
3392 MpegEncContext
*s
= &v
->s
;
3393 GetBitContext
*gb
= &s
->gb
;
3395 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3396 int cbp
= 0; /* cbp decoding stuff */
3397 int mqdiff
, mquant
; /* MB quantization */
3398 int ttmb
= v
->ttfrm
; /* MB Transform type */
3400 static const int size_table
[6] = { 0, 2, 3, 4, 5, 8 },
3401 offset_table
[6] = { 0, 1, 3, 7, 15, 31 };
3402 int mb_has_coeffs
= 0; /* last_flag */
3403 int index
, index1
; /* LUT indexes */
3404 int val
, sign
; /* temp values */
3405 int first_block
= 1;
3407 int skipped
, direct
;
3408 int dmv_x
[2], dmv_y
[2];
3409 int bmvtype
= BMV_TYPE_BACKWARD
;
3411 mquant
= v
->pq
; /* Loosy initialization */
3415 direct
= get_bits1(gb
);
3417 direct
= v
->direct_mb_plane
[mb_pos
];
3419 skipped
= get_bits1(gb
);
3421 skipped
= v
->s
.mbskip_table
[mb_pos
];
3423 s
->dsp
.clear_blocks(s
->block
[0]);
3424 dmv_x
[0] = dmv_x
[1] = dmv_y
[0] = dmv_y
[1] = 0;
3425 for(i
= 0; i
< 6; i
++) {
3426 v
->mb_type
[0][s
->block_index
[i
]] = 0;
3427 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3429 s
->current_picture
.qscale_table
[mb_pos
] = 0;
3433 GET_MVDATA(dmv_x
[0], dmv_y
[0]);
3434 dmv_x
[1] = dmv_x
[0];
3435 dmv_y
[1] = dmv_y
[0];
3437 if(skipped
|| !s
->mb_intra
) {
3438 bmvtype
= decode012(gb
);
3441 bmvtype
= (v
->bfraction
>= (B_FRACTION_DEN
/2)) ? BMV_TYPE_BACKWARD
: BMV_TYPE_FORWARD
;
3444 bmvtype
= (v
->bfraction
>= (B_FRACTION_DEN
/2)) ? BMV_TYPE_FORWARD
: BMV_TYPE_BACKWARD
;
3447 bmvtype
= BMV_TYPE_INTERPOLATED
;
3448 dmv_x
[0] = dmv_y
[0] = 0;
3452 for(i
= 0; i
< 6; i
++)
3453 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3456 if(direct
) bmvtype
= BMV_TYPE_INTERPOLATED
;
3457 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3458 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3462 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3466 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3468 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3469 dmv_x
[0] = dmv_y
[0] = dmv_x
[1] = dmv_y
[1] = 0;
3470 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3471 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3473 if(!mb_has_coeffs
&& !s
->mb_intra
) {
3474 /* no coded blocks - effectively skipped */
3475 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3476 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3479 if(s
->mb_intra
&& !mb_has_coeffs
) {
3481 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3482 s
->ac_pred
= get_bits1(gb
);
3484 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3486 if(bmvtype
== BMV_TYPE_INTERPOLATED
) {
3487 GET_MVDATA(dmv_x
[0], dmv_y
[0]);
3488 if(!mb_has_coeffs
) {
3489 /* interpolated skipped block */
3490 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3491 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3495 vc1_pred_b_mv(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3497 vc1_b_mc(v
, dmv_x
, dmv_y
, direct
, bmvtype
);
3500 s
->ac_pred
= get_bits1(gb
);
3501 cbp
= get_vlc2(&v
->s
.gb
, v
->cbpcy_vlc
->table
, VC1_CBPCY_P_VLC_BITS
, 2);
3503 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3504 if(!v
->ttmbf
&& !s
->mb_intra
&& mb_has_coeffs
)
3505 ttmb
= get_vlc2(gb
, ff_vc1_ttmb_vlc
[v
->tt_index
].table
, VC1_TTMB_VLC_BITS
, 2);
3511 s
->dc_val
[0][s
->block_index
[i
]] = 0;
3513 val
= ((cbp
>> (5 - i
)) & 1);
3514 off
= (i
& 4) ? 0 : ((i
& 1) * 8 + (i
& 2) * 4 * s
->linesize
);
3515 v
->mb_type
[0][s
->block_index
[i
]] = s
->mb_intra
;
3517 /* check if prediction blocks A and C are available */
3518 v
->a_avail
= v
->c_avail
= 0;
3519 if(i
== 2 || i
== 3 || !s
->first_slice_line
)
3520 v
->a_avail
= v
->mb_type
[0][s
->block_index
[i
] - s
->block_wrap
[i
]];
3521 if(i
== 1 || i
== 3 || s
->mb_x
)
3522 v
->c_avail
= v
->mb_type
[0][s
->block_index
[i
] - 1];
3524 vc1_decode_intra_block(v
, s
->block
[i
], i
, val
, mquant
, (i
&4)?v
->codingset2
:v
->codingset
);
3525 if((i
>3) && (s
->flags
& CODEC_FLAG_GRAY
)) continue;
3526 s
->dsp
.vc1_inv_trans_8x8(s
->block
[i
]);
3527 if(v
->rangeredfrm
) for(j
= 0; j
< 64; j
++) s
->block
[i
][j
] <<= 1;
3528 s
->dsp
.put_signed_pixels_clamped(s
->block
[i
], s
->dest
[dst_idx
] + off
, s
->linesize
>> ((i
& 4) >> 2));
3530 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);
3531 if(!v
->ttmbf
&& ttmb
< 8) ttmb
= -1;
3537 /** Decode blocks of I-frame
3539 static void vc1_decode_i_blocks(VC1Context
*v
)
3542 MpegEncContext
*s
= &v
->s
;
3547 /* select codingmode used for VLC tables selection */
3548 switch(v
->y_ac_table_index
){
3550 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3553 v
->codingset
= CS_HIGH_MOT_INTRA
;
3556 v
->codingset
= CS_MID_RATE_INTRA
;
3560 switch(v
->c_ac_table_index
){
3562 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3565 v
->codingset2
= CS_HIGH_MOT_INTER
;
3568 v
->codingset2
= CS_MID_RATE_INTER
;
3572 /* Set DC scale - y and c use the same */
3573 s
->y_dc_scale
= s
->y_dc_scale_table
[v
->pq
];
3574 s
->c_dc_scale
= s
->c_dc_scale_table
[v
->pq
];
3577 s
->mb_x
= s
->mb_y
= 0;
3579 s
->first_slice_line
= 1;
3580 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3581 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3582 ff_init_block_index(s
);
3583 ff_update_block_index(s
);
3584 s
->dsp
.clear_blocks(s
->block
[0]);
3585 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_width
;
3586 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_INTRA
;
3587 s
->current_picture
.qscale_table
[mb_pos
] = v
->pq
;
3588 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3589 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3591 // do actual MB decoding and displaying
3592 cbp
= get_vlc2(&v
->s
.gb
, ff_msmp4_mb_i_vlc
.table
, MB_INTRA_VLC_BITS
, 2);
3593 v
->s
.ac_pred
= get_bits1(&v
->s
.gb
);
3595 for(k
= 0; k
< 6; k
++) {
3596 val
= ((cbp
>> (5 - k
)) & 1);
3599 int pred
= vc1_coded_block_pred(&v
->s
, k
, &coded_val
);
3603 cbp
|= val
<< (5 - k
);
3605 vc1_decode_i_block(v
, s
->block
[k
], k
, val
, (k
<4)? v
->codingset
: v
->codingset2
);
3607 s
->dsp
.vc1_inv_trans_8x8(s
->block
[k
]);
3608 if(v
->pq
>= 9 && v
->overlap
) {
3609 for(j
= 0; j
< 64; j
++) s
->block
[k
][j
] += 128;
3613 vc1_put_block(v
, s
->block
);
3614 if(v
->pq
>= 9 && v
->overlap
) {
3616 s
->dsp
.vc1_h_overlap(s
->dest
[0], s
->linesize
);
3617 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3618 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3619 s
->dsp
.vc1_h_overlap(s
->dest
[1], s
->uvlinesize
);
3620 s
->dsp
.vc1_h_overlap(s
->dest
[2], s
->uvlinesize
);
3623 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8, s
->linesize
);
3624 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3625 if(!s
->first_slice_line
) {
3626 s
->dsp
.vc1_v_overlap(s
->dest
[0], s
->linesize
);
3627 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8, s
->linesize
);
3628 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3629 s
->dsp
.vc1_v_overlap(s
->dest
[1], s
->uvlinesize
);
3630 s
->dsp
.vc1_v_overlap(s
->dest
[2], s
->uvlinesize
);
3633 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3634 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3636 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, s
->current_picture
.qscale_table
[mb_pos
]);
3638 if(get_bits_count(&s
->gb
) > v
->bits
) {
3639 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3640 av_log(s
->avctx
, AV_LOG_ERROR
, "Bits overconsumption: %i > %i\n", get_bits_count(&s
->gb
), v
->bits
);
3644 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3645 s
->first_slice_line
= 0;
3647 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3650 /** Decode blocks of I-frame for advanced profile
3652 static void vc1_decode_i_blocks_adv(VC1Context
*v
)
3655 MpegEncContext
*s
= &v
->s
;
3662 GetBitContext
*gb
= &s
->gb
;
3664 /* select codingmode used for VLC tables selection */
3665 switch(v
->y_ac_table_index
){
3667 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3670 v
->codingset
= CS_HIGH_MOT_INTRA
;
3673 v
->codingset
= CS_MID_RATE_INTRA
;
3677 switch(v
->c_ac_table_index
){
3679 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3682 v
->codingset2
= CS_HIGH_MOT_INTER
;
3685 v
->codingset2
= CS_MID_RATE_INTER
;
3690 s
->mb_x
= s
->mb_y
= 0;
3692 s
->first_slice_line
= 1;
3693 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3694 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3695 ff_init_block_index(s
);
3696 ff_update_block_index(s
);
3697 s
->dsp
.clear_blocks(s
->block
[0]);
3698 mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
3699 s
->current_picture
.mb_type
[mb_pos
] = MB_TYPE_INTRA
;
3700 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
3701 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
3703 // do actual MB decoding and displaying
3704 cbp
= get_vlc2(&v
->s
.gb
, ff_msmp4_mb_i_vlc
.table
, MB_INTRA_VLC_BITS
, 2);
3705 if(v
->acpred_is_raw
)
3706 v
->s
.ac_pred
= get_bits1(&v
->s
.gb
);
3708 v
->s
.ac_pred
= v
->acpred_plane
[mb_pos
];
3710 if(v
->condover
== CONDOVER_SELECT
) {
3711 if(v
->overflg_is_raw
)
3712 overlap
= get_bits1(&v
->s
.gb
);
3714 overlap
= v
->over_flags_plane
[mb_pos
];
3716 overlap
= (v
->condover
== CONDOVER_ALL
);
3720 s
->current_picture
.qscale_table
[mb_pos
] = mquant
;
3721 /* Set DC scale - y and c use the same */
3722 s
->y_dc_scale
= s
->y_dc_scale_table
[mquant
];
3723 s
->c_dc_scale
= s
->c_dc_scale_table
[mquant
];
3725 for(k
= 0; k
< 6; k
++) {
3726 val
= ((cbp
>> (5 - k
)) & 1);
3729 int pred
= vc1_coded_block_pred(&v
->s
, k
, &coded_val
);
3733 cbp
|= val
<< (5 - k
);
3735 v
->a_avail
= !s
->first_slice_line
|| (k
==2 || k
==3);
3736 v
->c_avail
= !!s
->mb_x
|| (k
==1 || k
==3);
3738 vc1_decode_i_block_adv(v
, s
->block
[k
], k
, val
, (k
<4)? v
->codingset
: v
->codingset2
, mquant
);
3740 s
->dsp
.vc1_inv_trans_8x8(s
->block
[k
]);
3741 for(j
= 0; j
< 64; j
++) s
->block
[k
][j
] += 128;
3744 vc1_put_block(v
, s
->block
);
3747 s
->dsp
.vc1_h_overlap(s
->dest
[0], s
->linesize
);
3748 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3749 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3750 s
->dsp
.vc1_h_overlap(s
->dest
[1], s
->uvlinesize
);
3751 s
->dsp
.vc1_h_overlap(s
->dest
[2], s
->uvlinesize
);
3754 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8, s
->linesize
);
3755 s
->dsp
.vc1_h_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3756 if(!s
->first_slice_line
) {
3757 s
->dsp
.vc1_v_overlap(s
->dest
[0], s
->linesize
);
3758 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8, s
->linesize
);
3759 if(!(s
->flags
& CODEC_FLAG_GRAY
)) {
3760 s
->dsp
.vc1_v_overlap(s
->dest
[1], s
->uvlinesize
);
3761 s
->dsp
.vc1_v_overlap(s
->dest
[2], s
->uvlinesize
);
3764 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
, s
->linesize
);
3765 s
->dsp
.vc1_v_overlap(s
->dest
[0] + 8 * s
->linesize
+ 8, s
->linesize
);
3767 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, s
->current_picture
.qscale_table
[mb_pos
]);
3769 if(get_bits_count(&s
->gb
) > v
->bits
) {
3770 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3771 av_log(s
->avctx
, AV_LOG_ERROR
, "Bits overconsumption: %i > %i\n", get_bits_count(&s
->gb
), v
->bits
);
3775 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3776 s
->first_slice_line
= 0;
3778 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3781 static void vc1_decode_p_blocks(VC1Context
*v
)
3783 MpegEncContext
*s
= &v
->s
;
3785 /* select codingmode used for VLC tables selection */
3786 switch(v
->c_ac_table_index
){
3788 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3791 v
->codingset
= CS_HIGH_MOT_INTRA
;
3794 v
->codingset
= CS_MID_RATE_INTRA
;
3798 switch(v
->c_ac_table_index
){
3800 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3803 v
->codingset2
= CS_HIGH_MOT_INTER
;
3806 v
->codingset2
= CS_MID_RATE_INTER
;
3810 s
->first_slice_line
= 1;
3811 memset(v
->cbp_base
, 0, sizeof(v
->cbp_base
[0])*2*s
->mb_stride
);
3812 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3813 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3814 ff_init_block_index(s
);
3815 ff_update_block_index(s
);
3816 s
->dsp
.clear_blocks(s
->block
[0]);
3819 if(get_bits_count(&s
->gb
) > v
->bits
|| get_bits_count(&s
->gb
) < 0) {
3820 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3821 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
);
3825 memmove(v
->cbp_base
, v
->cbp
, sizeof(v
->cbp_base
[0])*s
->mb_stride
);
3826 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3827 s
->first_slice_line
= 0;
3829 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3832 static void vc1_decode_b_blocks(VC1Context
*v
)
3834 MpegEncContext
*s
= &v
->s
;
3836 /* select codingmode used for VLC tables selection */
3837 switch(v
->c_ac_table_index
){
3839 v
->codingset
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTRA
: CS_LOW_MOT_INTRA
;
3842 v
->codingset
= CS_HIGH_MOT_INTRA
;
3845 v
->codingset
= CS_MID_RATE_INTRA
;
3849 switch(v
->c_ac_table_index
){
3851 v
->codingset2
= (v
->pqindex
<= 8) ? CS_HIGH_RATE_INTER
: CS_LOW_MOT_INTER
;
3854 v
->codingset2
= CS_HIGH_MOT_INTER
;
3857 v
->codingset2
= CS_MID_RATE_INTER
;
3861 s
->first_slice_line
= 1;
3862 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3863 for(s
->mb_x
= 0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
3864 ff_init_block_index(s
);
3865 ff_update_block_index(s
);
3866 s
->dsp
.clear_blocks(s
->block
[0]);
3869 if(get_bits_count(&s
->gb
) > v
->bits
|| get_bits_count(&s
->gb
) < 0) {
3870 ff_er_add_slice(s
, 0, 0, s
->mb_x
, s
->mb_y
, (AC_END
|DC_END
|MV_END
));
3871 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
);
3874 if(v
->s
.loop_filter
) vc1_loop_filter_iblk(s
, s
->current_picture
.qscale_table
[s
->mb_x
+ s
->mb_y
*s
->mb_stride
]);
3876 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3877 s
->first_slice_line
= 0;
3879 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3882 static void vc1_decode_skip_blocks(VC1Context
*v
)
3884 MpegEncContext
*s
= &v
->s
;
3886 ff_er_add_slice(s
, 0, 0, s
->mb_width
- 1, s
->mb_height
- 1, (AC_END
|DC_END
|MV_END
));
3887 s
->first_slice_line
= 1;
3888 for(s
->mb_y
= 0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
3890 ff_init_block_index(s
);
3891 ff_update_block_index(s
);
3892 memcpy(s
->dest
[0], s
->last_picture
.data
[0] + s
->mb_y
* 16 * s
->linesize
, s
->linesize
* 16);
3893 memcpy(s
->dest
[1], s
->last_picture
.data
[1] + s
->mb_y
* 8 * s
->uvlinesize
, s
->uvlinesize
* 8);
3894 memcpy(s
->dest
[2], s
->last_picture
.data
[2] + s
->mb_y
* 8 * s
->uvlinesize
, s
->uvlinesize
* 8);
3895 ff_draw_horiz_band(s
, s
->mb_y
* 16, 16);
3896 s
->first_slice_line
= 0;
3898 s
->pict_type
= FF_P_TYPE
;
3901 static void vc1_decode_blocks(VC1Context
*v
)
3904 v
->s
.esc3_level_length
= 0;
3906 ff_intrax8_decode_picture(&v
->x8
, 2*v
->pq
+v
->halfpq
, v
->pq
*(!v
->pquantizer
) );
3909 switch(v
->s
.pict_type
) {
3911 if(v
->profile
== PROFILE_ADVANCED
)
3912 vc1_decode_i_blocks_adv(v
);
3914 vc1_decode_i_blocks(v
);
3917 if(v
->p_frame_skipped
)
3918 vc1_decode_skip_blocks(v
);
3920 vc1_decode_p_blocks(v
);
3924 if(v
->profile
== PROFILE_ADVANCED
)
3925 vc1_decode_i_blocks_adv(v
);
3927 vc1_decode_i_blocks(v
);
3929 vc1_decode_b_blocks(v
);
3935 /** Find VC-1 marker in buffer
3936 * @return position where next marker starts or end of buffer if no marker found
3938 static av_always_inline
const uint8_t* find_next_marker(const uint8_t *src
, const uint8_t *end
)
3940 uint32_t mrk
= 0xFFFFFFFF;
3942 if(end
-src
< 4) return end
;
3944 mrk
= (mrk
<< 8) | *src
++;
3951 static av_always_inline
int vc1_unescape_buffer(const uint8_t *src
, int size
, uint8_t *dst
)
3956 for(dsize
= 0; dsize
< size
; dsize
++) *dst
++ = *src
++;
3959 for(i
= 0; i
< size
; i
++, src
++) {
3960 if(src
[0] == 3 && i
>= 2 && !src
[-1] && !src
[-2] && i
< size
-1 && src
[1] < 4) {
3961 dst
[dsize
++] = src
[1];
3965 dst
[dsize
++] = *src
;
3970 /** Initialize a VC1/WMV3 decoder
3971 * @todo TODO: Handle VC-1 IDUs (Transport level?)
3972 * @todo TODO: Decypher remaining bits in extra_data
3974 static av_cold
int vc1_decode_init(AVCodecContext
*avctx
)
3976 VC1Context
*v
= avctx
->priv_data
;
3977 MpegEncContext
*s
= &v
->s
;
3980 if (!avctx
->extradata_size
|| !avctx
->extradata
) return -1;
3981 if (!(avctx
->flags
& CODEC_FLAG_GRAY
))
3982 avctx
->pix_fmt
= PIX_FMT_YUV420P
;
3984 avctx
->pix_fmt
= PIX_FMT_GRAY8
;
3986 avctx
->flags
|= CODEC_FLAG_EMU_EDGE
;
3987 v
->s
.flags
|= CODEC_FLAG_EMU_EDGE
;
3989 if(avctx
->idct_algo
==FF_IDCT_AUTO
){
3990 avctx
->idct_algo
=FF_IDCT_WMV2
;
3993 if(ff_h263_decode_init(avctx
) < 0)
3995 if (vc1_init_common(v
) < 0) return -1;
3997 avctx
->coded_width
= avctx
->width
;
3998 avctx
->coded_height
= avctx
->height
;
3999 if (avctx
->codec_id
== CODEC_ID_WMV3
)
4003 // looks like WMV3 has a sequence header stored in the extradata
4004 // advanced sequence header may be before the first frame
4005 // the last byte of the extradata is a version number, 1 for the
4006 // samples we can decode
4008 init_get_bits(&gb
, avctx
->extradata
, avctx
->extradata_size
*8);
4010 if (decode_sequence_header(avctx
, &gb
) < 0)
4013 count
= avctx
->extradata_size
*8 - get_bits_count(&gb
);
4016 av_log(avctx
, AV_LOG_INFO
, "Extra data: %i bits left, value: %X\n",
4017 count
, get_bits(&gb
, count
));
4021 av_log(avctx
, AV_LOG_INFO
, "Read %i bits in overflow\n", -count
);
4023 } else { // VC1/WVC1
4024 const uint8_t *start
= avctx
->extradata
;
4025 uint8_t *end
= avctx
->extradata
+ avctx
->extradata_size
;
4026 const uint8_t *next
;
4027 int size
, buf2_size
;
4028 uint8_t *buf2
= NULL
;
4029 int seq_initialized
= 0, ep_initialized
= 0;
4031 if(avctx
->extradata_size
< 16) {
4032 av_log(avctx
, AV_LOG_ERROR
, "Extradata size too small: %i\n", avctx
->extradata_size
);
4036 buf2
= av_mallocz(avctx
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
4037 if(start
[0]) start
++; // in WVC1 extradata first byte is its size
4039 for(; next
< end
; start
= next
){
4040 next
= find_next_marker(start
+ 4, end
);
4041 size
= next
- start
- 4;
4042 if(size
<= 0) continue;
4043 buf2_size
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4044 init_get_bits(&gb
, buf2
, buf2_size
* 8);
4045 switch(AV_RB32(start
)){
4046 case VC1_CODE_SEQHDR
:
4047 if(decode_sequence_header(avctx
, &gb
) < 0){
4051 seq_initialized
= 1;
4053 case VC1_CODE_ENTRYPOINT
:
4054 if(decode_entry_point(avctx
, &gb
) < 0){
4063 if(!seq_initialized
|| !ep_initialized
){
4064 av_log(avctx
, AV_LOG_ERROR
, "Incomplete extradata\n");
4068 avctx
->has_b_frames
= !!(avctx
->max_b_frames
);
4069 s
->low_delay
= !avctx
->has_b_frames
;
4071 s
->mb_width
= (avctx
->coded_width
+15)>>4;
4072 s
->mb_height
= (avctx
->coded_height
+15)>>4;
4074 /* Allocate mb bitplanes */
4075 v
->mv_type_mb_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4076 v
->direct_mb_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4077 v
->acpred_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4078 v
->over_flags_plane
= av_malloc(s
->mb_stride
* s
->mb_height
);
4080 v
->cbp_base
= av_malloc(sizeof(v
->cbp_base
[0]) * 2 * s
->mb_stride
);
4081 v
->cbp
= v
->cbp_base
+ s
->mb_stride
;
4083 /* allocate block type info in that way so it could be used with s->block_index[] */
4084 v
->mb_type_base
= av_malloc(s
->b8_stride
* (s
->mb_height
* 2 + 1) + s
->mb_stride
* (s
->mb_height
+ 1) * 2);
4085 v
->mb_type
[0] = v
->mb_type_base
+ s
->b8_stride
+ 1;
4086 v
->mb_type
[1] = v
->mb_type_base
+ s
->b8_stride
* (s
->mb_height
* 2 + 1) + s
->mb_stride
+ 1;
4087 v
->mb_type
[2] = v
->mb_type
[1] + s
->mb_stride
* (s
->mb_height
+ 1);
4089 /* Init coded blocks info */
4090 if (v
->profile
== PROFILE_ADVANCED
)
4092 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
4094 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
4098 ff_intrax8_common_init(&v
->x8
,s
);
4103 /** Decode a VC1/WMV3 frame
4104 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4106 static int vc1_decode_frame(AVCodecContext
*avctx
,
4107 void *data
, int *data_size
,
4108 const uint8_t *buf
, int buf_size
)
4110 VC1Context
*v
= avctx
->priv_data
;
4111 MpegEncContext
*s
= &v
->s
;
4112 AVFrame
*pict
= data
;
4113 uint8_t *buf2
= NULL
;
4115 /* no supplementary picture */
4116 if (buf_size
== 0) {
4117 /* special case for last picture */
4118 if (s
->low_delay
==0 && s
->next_picture_ptr
) {
4119 *pict
= *(AVFrame
*)s
->next_picture_ptr
;
4120 s
->next_picture_ptr
= NULL
;
4122 *data_size
= sizeof(AVFrame
);
4128 /* We need to set current_picture_ptr before reading the header,
4129 * otherwise we cannot store anything in there. */
4130 if(s
->current_picture_ptr
==NULL
|| s
->current_picture_ptr
->data
[0]){
4131 int i
= ff_find_unused_picture(s
, 0);
4132 s
->current_picture_ptr
= &s
->picture
[i
];
4135 //for advanced profile we may need to parse and unescape data
4136 if (avctx
->codec_id
== CODEC_ID_VC1
) {
4138 buf2
= av_mallocz(buf_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
4140 if(IS_MARKER(AV_RB32(buf
))){ /* frame starts with marker and needs to be parsed */
4141 const uint8_t *start
, *end
, *next
;
4145 for(start
= buf
, end
= buf
+ buf_size
; next
< end
; start
= next
){
4146 next
= find_next_marker(start
+ 4, end
);
4147 size
= next
- start
- 4;
4148 if(size
<= 0) continue;
4149 switch(AV_RB32(start
)){
4150 case VC1_CODE_FRAME
:
4151 buf_size2
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4153 case VC1_CODE_ENTRYPOINT
: /* it should be before frame data */
4154 buf_size2
= vc1_unescape_buffer(start
+ 4, size
, buf2
);
4155 init_get_bits(&s
->gb
, buf2
, buf_size2
*8);
4156 decode_entry_point(avctx
, &s
->gb
);
4158 case VC1_CODE_SLICE
:
4159 av_log(avctx
, AV_LOG_ERROR
, "Sliced decoding is not implemented (yet)\n");
4164 }else if(v
->interlace
&& ((buf
[0] & 0xC0) == 0xC0)){ /* WVC1 interlaced stores both fields divided by marker */
4165 const uint8_t *divider
;
4167 divider
= find_next_marker(buf
, buf
+ buf_size
);
4168 if((divider
== (buf
+ buf_size
)) || AV_RB32(divider
) != VC1_CODE_FIELD
){
4169 av_log(avctx
, AV_LOG_ERROR
, "Error in WVC1 interlaced frame\n");
4174 buf_size2
= vc1_unescape_buffer(buf
, divider
- buf
, buf2
);
4176 av_free(buf2
);return -1;
4178 buf_size2
= vc1_unescape_buffer(buf
, buf_size
, buf2
);
4180 init_get_bits(&s
->gb
, buf2
, buf_size2
*8);
4182 init_get_bits(&s
->gb
, buf
, buf_size
*8);
4183 // do parse frame header
4184 if(v
->profile
< PROFILE_ADVANCED
) {
4185 if(vc1_parse_frame_header(v
, &s
->gb
) == -1) {
4190 if(vc1_parse_frame_header_adv(v
, &s
->gb
) == -1) {
4196 if(s
->pict_type
!= FF_I_TYPE
&& !v
->res_rtm_flag
){
4202 s
->current_picture
.pict_type
= s
->pict_type
;
4203 s
->current_picture
.key_frame
= s
->pict_type
== FF_I_TYPE
;
4205 /* skip B-frames if we don't have reference frames */
4206 if(s
->last_picture_ptr
==NULL
&& (s
->pict_type
==FF_B_TYPE
|| s
->dropable
)){
4208 return -1;//buf_size;
4210 /* skip b frames if we are in a hurry */
4211 if(avctx
->hurry_up
&& s
->pict_type
==FF_B_TYPE
) return -1;//buf_size;
4212 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& s
->pict_type
==FF_B_TYPE
)
4213 || (avctx
->skip_frame
>= AVDISCARD_NONKEY
&& s
->pict_type
!=FF_I_TYPE
)
4214 || avctx
->skip_frame
>= AVDISCARD_ALL
) {
4218 /* skip everything if we are in a hurry>=5 */
4219 if(avctx
->hurry_up
>=5) {
4221 return -1;//buf_size;
4224 if(s
->next_p_frame_damaged
){
4225 if(s
->pict_type
==FF_B_TYPE
)
4228 s
->next_p_frame_damaged
=0;
4231 if(MPV_frame_start(s
, avctx
) < 0) {
4236 s
->me
.qpel_put
= s
->dsp
.put_qpel_pixels_tab
;
4237 s
->me
.qpel_avg
= s
->dsp
.avg_qpel_pixels_tab
;
4239 ff_er_frame_start(s
);
4241 v
->bits
= buf_size
* 8;
4242 vc1_decode_blocks(v
);
4243 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
4244 // if(get_bits_count(&s->gb) > buf_size * 8)
4250 assert(s
->current_picture
.pict_type
== s
->current_picture_ptr
->pict_type
);
4251 assert(s
->current_picture
.pict_type
== s
->pict_type
);
4252 if (s
->pict_type
== FF_B_TYPE
|| s
->low_delay
) {
4253 *pict
= *(AVFrame
*)s
->current_picture_ptr
;
4254 } else if (s
->last_picture_ptr
!= NULL
) {
4255 *pict
= *(AVFrame
*)s
->last_picture_ptr
;
4258 if(s
->last_picture_ptr
|| s
->low_delay
){
4259 *data_size
= sizeof(AVFrame
);
4260 ff_print_debug_info(s
, pict
);
4263 /* Return the Picture timestamp as the frame number */
4264 /* we subtract 1 because it is added on utils.c */
4265 avctx
->frame_number
= s
->picture_number
- 1;
4272 /** Close a VC1/WMV3 decoder
4273 * @warning Initial try at using MpegEncContext stuff
4275 static av_cold
int vc1_decode_end(AVCodecContext
*avctx
)
4277 VC1Context
*v
= avctx
->priv_data
;
4279 av_freep(&v
->hrd_rate
);
4280 av_freep(&v
->hrd_buffer
);
4281 MPV_common_end(&v
->s
);
4282 av_freep(&v
->mv_type_mb_plane
);
4283 av_freep(&v
->direct_mb_plane
);
4284 av_freep(&v
->acpred_plane
);
4285 av_freep(&v
->over_flags_plane
);
4286 av_freep(&v
->mb_type_base
);
4287 av_freep(&v
->cbp_base
);
4288 ff_intrax8_common_end(&v
->x8
);
4293 AVCodec vc1_decoder
= {
4304 .long_name
= NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
4307 AVCodec wmv3_decoder
= {
4318 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 9"),