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];
47 static inline int decode210(GetBitContext
*gb
){
51 return 2 - get_bits1(gb
);
55 * Init VC-1 specific tables and VC1Context members
56 * @param v The VC1Context to initialize
59 static int vc1_init_common(VC1Context
*v
)
64 v
->hrd_rate
= v
->hrd_buffer
= NULL
;
70 init_vlc(&ff_vc1_bfraction_vlc
, VC1_BFRACTION_VLC_BITS
, 23,
71 ff_vc1_bfraction_bits
, 1, 1,
72 ff_vc1_bfraction_codes
, 1, 1, 1);
73 init_vlc(&ff_vc1_norm2_vlc
, VC1_NORM2_VLC_BITS
, 4,
74 ff_vc1_norm2_bits
, 1, 1,
75 ff_vc1_norm2_codes
, 1, 1, 1);
76 init_vlc(&ff_vc1_norm6_vlc
, VC1_NORM6_VLC_BITS
, 64,
77 ff_vc1_norm6_bits
, 1, 1,
78 ff_vc1_norm6_codes
, 2, 2, 1);
79 init_vlc(&ff_vc1_imode_vlc
, VC1_IMODE_VLC_BITS
, 7,
80 ff_vc1_imode_bits
, 1, 1,
81 ff_vc1_imode_codes
, 1, 1, 1);
84 init_vlc(&ff_vc1_ttmb_vlc
[i
], VC1_TTMB_VLC_BITS
, 16,
85 ff_vc1_ttmb_bits
[i
], 1, 1,
86 ff_vc1_ttmb_codes
[i
], 2, 2, 1);
87 init_vlc(&ff_vc1_ttblk_vlc
[i
], VC1_TTBLK_VLC_BITS
, 8,
88 ff_vc1_ttblk_bits
[i
], 1, 1,
89 ff_vc1_ttblk_codes
[i
], 1, 1, 1);
90 init_vlc(&ff_vc1_subblkpat_vlc
[i
], VC1_SUBBLKPAT_VLC_BITS
, 15,
91 ff_vc1_subblkpat_bits
[i
], 1, 1,
92 ff_vc1_subblkpat_codes
[i
], 1, 1, 1);
96 init_vlc(&ff_vc1_4mv_block_pattern_vlc
[i
], VC1_4MV_BLOCK_PATTERN_VLC_BITS
, 16,
97 ff_vc1_4mv_block_pattern_bits
[i
], 1, 1,
98 ff_vc1_4mv_block_pattern_codes
[i
], 1, 1, 1);
99 init_vlc(&ff_vc1_cbpcy_p_vlc
[i
], VC1_CBPCY_P_VLC_BITS
, 64,
100 ff_vc1_cbpcy_p_bits
[i
], 1, 1,
101 ff_vc1_cbpcy_p_codes
[i
], 2, 2, 1);
102 init_vlc(&ff_vc1_mv_diff_vlc
[i
], VC1_MV_DIFF_VLC_BITS
, 73,
103 ff_vc1_mv_diff_bits
[i
], 1, 1,
104 ff_vc1_mv_diff_codes
[i
], 2, 2, 1);
107 init_vlc(&ff_vc1_ac_coeff_table
[i
], AC_VLC_BITS
, vc1_ac_sizes
[i
],
108 &vc1_ac_tables
[i
][0][1], 8, 4,
109 &vc1_ac_tables
[i
][0][0], 8, 4, 1);
110 init_vlc(&ff_msmp4_mb_i_vlc
, MB_INTRA_VLC_BITS
, 64,
111 &ff_msmp4_mb_i_table
[0][1], 4, 2,
112 &ff_msmp4_mb_i_table
[0][0], 4, 2, 1);
117 v
->mvrange
= 0; /* 7.1.1.18, p80 */
122 /***********************************************************************/
124 * @defgroup bitplane VC9 Bitplane decoding
129 /** @addtogroup bitplane
142 /** @} */ //imode defines
144 /** Decode rows by checking if they are skipped
145 * @param plane Buffer to store decoded bits
146 * @param[in] width Width of this buffer
147 * @param[in] height Height of this buffer
148 * @param[in] stride of this buffer
150 static void decode_rowskip(uint8_t* plane
, int width
, int height
, int stride
, GetBitContext
*gb
){
153 for (y
=0; y
<height
; y
++){
154 if (!get_bits1(gb
)) //rowskip
155 memset(plane
, 0, width
);
157 for (x
=0; x
<width
; x
++)
158 plane
[x
] = get_bits1(gb
);
163 /** Decode columns by checking if they are skipped
164 * @param plane Buffer to store decoded bits
165 * @param[in] width Width of this buffer
166 * @param[in] height Height of this buffer
167 * @param[in] stride of this buffer
168 * @todo FIXME: Optimize
170 static void decode_colskip(uint8_t* plane
, int width
, int height
, int stride
, GetBitContext
*gb
){
173 for (x
=0; x
<width
; x
++){
174 if (!get_bits1(gb
)) //colskip
175 for (y
=0; y
<height
; y
++)
178 for (y
=0; y
<height
; y
++)
179 plane
[y
*stride
] = get_bits1(gb
);
184 /** Decode a bitplane's bits
185 * @param bp Bitplane where to store the decode bits
186 * @param v VC-1 context for bit reading and logging
188 * @todo FIXME: Optimize
190 static int bitplane_decoding(uint8_t* data
, int *raw_flag
, VC1Context
*v
)
192 GetBitContext
*gb
= &v
->s
.gb
;
194 int imode
, x
, y
, code
, offset
;
195 uint8_t invert
, *planep
= data
;
196 int width
, height
, stride
;
198 width
= v
->s
.mb_width
;
199 height
= v
->s
.mb_height
;
200 stride
= v
->s
.mb_stride
;
201 invert
= get_bits1(gb
);
202 imode
= get_vlc2(gb
, ff_vc1_imode_vlc
.table
, VC1_IMODE_VLC_BITS
, 1);
208 //Data is actually read in the MB layer (same for all tests == "raw")
209 *raw_flag
= 1; //invert ignored
213 if ((height
* width
) & 1)
215 *planep
++ = get_bits1(gb
);
219 // decode bitplane as one long line
220 for (y
= offset
; y
< height
* width
; y
+= 2) {
221 code
= get_vlc2(gb
, ff_vc1_norm2_vlc
.table
, VC1_NORM2_VLC_BITS
, 1);
222 *planep
++ = code
& 1;
224 if(offset
== width
) {
226 planep
+= stride
- width
;
228 *planep
++ = code
>> 1;
230 if(offset
== width
) {
232 planep
+= stride
- width
;
238 if(!(height
% 3) && (width
% 3)) { // use 2x3 decoding
239 for(y
= 0; y
< height
; y
+= 3) {
240 for(x
= width
& 1; x
< width
; x
+= 2) {
241 code
= get_vlc2(gb
, ff_vc1_norm6_vlc
.table
, VC1_NORM6_VLC_BITS
, 2);
243 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "invalid NORM-6 VLC\n");
246 planep
[x
+ 0] = (code
>> 0) & 1;
247 planep
[x
+ 1] = (code
>> 1) & 1;
248 planep
[x
+ 0 + stride
] = (code
>> 2) & 1;
249 planep
[x
+ 1 + stride
] = (code
>> 3) & 1;
250 planep
[x
+ 0 + stride
* 2] = (code
>> 4) & 1;
251 planep
[x
+ 1 + stride
* 2] = (code
>> 5) & 1;
253 planep
+= stride
* 3;
255 if(width
& 1) decode_colskip(data
, 1, height
, stride
, &v
->s
.gb
);
257 planep
+= (height
& 1) * stride
;
258 for(y
= height
& 1; y
< height
; y
+= 2) {
259 for(x
= width
% 3; x
< width
; x
+= 3) {
260 code
= get_vlc2(gb
, ff_vc1_norm6_vlc
.table
, VC1_NORM6_VLC_BITS
, 2);
262 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "invalid NORM-6 VLC\n");
265 planep
[x
+ 0] = (code
>> 0) & 1;
266 planep
[x
+ 1] = (code
>> 1) & 1;
267 planep
[x
+ 2] = (code
>> 2) & 1;
268 planep
[x
+ 0 + stride
] = (code
>> 3) & 1;
269 planep
[x
+ 1 + stride
] = (code
>> 4) & 1;
270 planep
[x
+ 2 + stride
] = (code
>> 5) & 1;
272 planep
+= stride
* 2;
275 if(x
) decode_colskip(data
, x
, height
, stride
, &v
->s
.gb
);
276 if(height
& 1) decode_rowskip(data
+x
, width
- x
, 1, stride
, &v
->s
.gb
);
280 decode_rowskip(data
, width
, height
, stride
, &v
->s
.gb
);
283 decode_colskip(data
, width
, height
, stride
, &v
->s
.gb
);
288 /* Applying diff operator */
289 if (imode
== IMODE_DIFF2
|| imode
== IMODE_DIFF6
)
293 for (x
=1; x
<width
; x
++)
294 planep
[x
] ^= planep
[x
-1];
295 for (y
=1; y
<height
; y
++)
298 planep
[0] ^= planep
[-stride
];
299 for (x
=1; x
<width
; x
++)
301 if (planep
[x
-1] != planep
[x
-stride
]) planep
[x
] ^= invert
;
302 else planep
[x
] ^= planep
[x
-1];
309 for (x
=0; x
<stride
*height
; x
++) planep
[x
] = !planep
[x
]; //FIXME stride
311 return (imode
<<1) + invert
;
314 /** @} */ //Bitplane group
316 /***********************************************************************/
317 /** VOP Dquant decoding
318 * @param v VC-1 Context
320 static int vop_dquant_decoding(VC1Context
*v
)
322 GetBitContext
*gb
= &v
->s
.gb
;
328 pqdiff
= get_bits(gb
, 3);
329 if (pqdiff
== 7) v
->altpq
= get_bits(gb
, 5);
330 else v
->altpq
= v
->pq
+ pqdiff
+ 1;
334 v
->dquantfrm
= get_bits1(gb
);
337 v
->dqprofile
= get_bits(gb
, 2);
338 switch (v
->dqprofile
)
340 case DQPROFILE_SINGLE_EDGE
:
341 case DQPROFILE_DOUBLE_EDGES
:
342 v
->dqsbedge
= get_bits(gb
, 2);
344 case DQPROFILE_ALL_MBS
:
345 v
->dqbilevel
= get_bits1(gb
);
348 default: break; //Forbidden ?
350 if (v
->dqbilevel
|| v
->dqprofile
!= DQPROFILE_ALL_MBS
)
352 pqdiff
= get_bits(gb
, 3);
353 if (pqdiff
== 7) v
->altpq
= get_bits(gb
, 5);
354 else v
->altpq
= v
->pq
+ pqdiff
+ 1;
361 /** Put block onto picture
363 static void vc1_put_block(VC1Context
*v
, DCTELEM block
[6][64])
367 DSPContext
*dsp
= &v
->s
.dsp
;
371 for(k
= 0; k
< 6; k
++)
372 for(j
= 0; j
< 8; j
++)
373 for(i
= 0; i
< 8; i
++)
374 block
[k
][i
+ j
*8] = ((block
[k
][i
+ j
*8] - 128) << 1) + 128;
377 ys
= v
->s
.current_picture
.linesize
[0];
378 us
= v
->s
.current_picture
.linesize
[1];
379 vs
= v
->s
.current_picture
.linesize
[2];
382 dsp
->put_pixels_clamped(block
[0], Y
, ys
);
383 dsp
->put_pixels_clamped(block
[1], Y
+ 8, ys
);
385 dsp
->put_pixels_clamped(block
[2], Y
, ys
);
386 dsp
->put_pixels_clamped(block
[3], Y
+ 8, ys
);
388 if(!(v
->s
.flags
& CODEC_FLAG_GRAY
)) {
389 dsp
->put_pixels_clamped(block
[4], v
->s
.dest
[1], us
);
390 dsp
->put_pixels_clamped(block
[5], v
->s
.dest
[2], vs
);
394 /** Do motion compensation over 1 macroblock
395 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
397 static void vc1_mc_1mv(VC1Context
*v
, int dir
)
399 MpegEncContext
*s
= &v
->s
;
400 DSPContext
*dsp
= &v
->s
.dsp
;
401 uint8_t *srcY
, *srcU
, *srcV
;
402 int dxy
, uvdxy
, mx
, my
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
404 if(!v
->s
.last_picture
.data
[0])return;
406 mx
= s
->mv
[dir
][0][0];
407 my
= s
->mv
[dir
][0][1];
409 // store motion vectors for further use in B frames
410 if(s
->pict_type
== P_TYPE
) {
411 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = mx
;
412 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = my
;
414 uvmx
= (mx
+ ((mx
& 3) == 3)) >> 1;
415 uvmy
= (my
+ ((my
& 3) == 3)) >> 1;
417 uvmx
= uvmx
+ ((uvmx
<0)?
(uvmx
&1):-(uvmx
&1));
418 uvmy
= uvmy
+ ((uvmy
<0)?
(uvmy
&1):-(uvmy
&1));
421 srcY
= s
->last_picture
.data
[0];
422 srcU
= s
->last_picture
.data
[1];
423 srcV
= s
->last_picture
.data
[2];
425 srcY
= s
->next_picture
.data
[0];
426 srcU
= s
->next_picture
.data
[1];
427 srcV
= s
->next_picture
.data
[2];
430 src_x
= s
->mb_x
* 16 + (mx
>> 2);
431 src_y
= s
->mb_y
* 16 + (my
>> 2);
432 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
433 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
435 if(v
->profile
!= PROFILE_ADVANCED
){
436 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
437 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
438 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
439 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
441 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
442 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
443 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
444 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
447 srcY
+= src_y
* s
->linesize
+ src_x
;
448 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
449 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
451 /* for grayscale we should not try to read from unknown area */
452 if(s
->flags
& CODEC_FLAG_GRAY
) {
453 srcU
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
454 srcV
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
457 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
458 || (unsigned)(src_x
- s
->mspel
) > s
->h_edge_pos
- (mx
&3) - 16 - s
->mspel
*3
459 || (unsigned)(src_y
- s
->mspel
) > s
->v_edge_pos
- (my
&3) - 16 - s
->mspel
*3){
460 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 19 * s
->linesize
;
462 srcY
-= s
->mspel
* (1 + s
->linesize
);
463 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 17+s
->mspel
*2, 17+s
->mspel
*2,
464 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
465 srcY
= s
->edge_emu_buffer
;
466 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, 8+1, 8+1,
467 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
468 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
469 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
472 /* if we deal with range reduction we need to scale source blocks */
478 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
479 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
482 src
= srcU
; src2
= srcV
;
483 for(j
= 0; j
< 9; j
++) {
484 for(i
= 0; i
< 9; i
++) {
485 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
486 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
488 src
+= s
->uvlinesize
;
489 src2
+= s
->uvlinesize
;
492 /* if we deal with intensity compensation we need to scale source blocks */
493 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
498 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
499 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = v
->luty
[src
[i
]];
502 src
= srcU
; src2
= srcV
;
503 for(j
= 0; j
< 9; j
++) {
504 for(i
= 0; i
< 9; i
++) {
505 src
[i
] = v
->lutuv
[src
[i
]];
506 src2
[i
] = v
->lutuv
[src2
[i
]];
508 src
+= s
->uvlinesize
;
509 src2
+= s
->uvlinesize
;
512 srcY
+= s
->mspel
* (1 + s
->linesize
);
516 dxy
= ((my
& 3) << 2) | (mx
& 3);
517 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] , srcY
, s
->linesize
, v
->rnd
);
518 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8, srcY
+ 8, s
->linesize
, v
->rnd
);
519 srcY
+= s
->linesize
* 8;
520 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8 * s
->linesize
, srcY
, s
->linesize
, v
->rnd
);
521 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + 8 * s
->linesize
+ 8, srcY
+ 8, s
->linesize
, v
->rnd
);
522 } else { // hpel mc - always used for luma
523 dxy
= (my
& 2) | ((mx
& 2) >> 1);
526 dsp
->put_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
528 dsp
->put_no_rnd_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
531 if(s
->flags
& CODEC_FLAG_GRAY
) return;
532 /* Chroma MC always uses qpel bilinear */
533 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
537 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
538 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
540 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
541 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
545 /** Do motion compensation for 4-MV macroblock - luminance block
547 static void vc1_mc_4mv_luma(VC1Context
*v
, int n
)
549 MpegEncContext
*s
= &v
->s
;
550 DSPContext
*dsp
= &v
->s
.dsp
;
552 int dxy
, mx
, my
, src_x
, src_y
;
555 if(!v
->s
.last_picture
.data
[0])return;
558 srcY
= s
->last_picture
.data
[0];
560 off
= s
->linesize
* 4 * (n
&2) + (n
&1) * 8;
562 src_x
= s
->mb_x
* 16 + (n
&1) * 8 + (mx
>> 2);
563 src_y
= s
->mb_y
* 16 + (n
&2) * 4 + (my
>> 2);
565 if(v
->profile
!= PROFILE_ADVANCED
){
566 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
567 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
569 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
570 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
573 srcY
+= src_y
* s
->linesize
+ src_x
;
575 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
576 || (unsigned)(src_x
- s
->mspel
) > s
->h_edge_pos
- (mx
&3) - 8 - s
->mspel
*2
577 || (unsigned)(src_y
- s
->mspel
) > s
->v_edge_pos
- (my
&3) - 8 - s
->mspel
*2){
578 srcY
-= s
->mspel
* (1 + s
->linesize
);
579 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 9+s
->mspel
*2, 9+s
->mspel
*2,
580 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
581 srcY
= s
->edge_emu_buffer
;
582 /* if we deal with range reduction we need to scale source blocks */
588 for(j
= 0; j
< 9 + s
->mspel
*2; j
++) {
589 for(i
= 0; i
< 9 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
593 /* if we deal with intensity compensation we need to scale source blocks */
594 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
599 for(j
= 0; j
< 9 + s
->mspel
*2; j
++) {
600 for(i
= 0; i
< 9 + s
->mspel
*2; i
++) src
[i
] = v
->luty
[src
[i
]];
604 srcY
+= s
->mspel
* (1 + s
->linesize
);
608 dxy
= ((my
& 3) << 2) | (mx
& 3);
609 dsp
->put_vc1_mspel_pixels_tab
[dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, v
->rnd
);
610 } else { // hpel mc - always used for luma
611 dxy
= (my
& 2) | ((mx
& 2) >> 1);
613 dsp
->put_pixels_tab
[1][dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, 8);
615 dsp
->put_no_rnd_pixels_tab
[1][dxy
](s
->dest
[0] + off
, srcY
, s
->linesize
, 8);
619 static inline int median4(int a
, int b
, int c
, int d
)
622 if(c
< d
) return (FFMIN(b
, d
) + FFMAX(a
, c
)) / 2;
623 else return (FFMIN(b
, c
) + FFMAX(a
, d
)) / 2;
625 if(c
< d
) return (FFMIN(a
, d
) + FFMAX(b
, c
)) / 2;
626 else return (FFMIN(a
, c
) + FFMAX(b
, d
)) / 2;
631 /** Do motion compensation for 4-MV macroblock - both chroma blocks
633 static void vc1_mc_4mv_chroma(VC1Context
*v
)
635 MpegEncContext
*s
= &v
->s
;
636 DSPContext
*dsp
= &v
->s
.dsp
;
637 uint8_t *srcU
, *srcV
;
638 int uvdxy
, uvmx
, uvmy
, uvsrc_x
, uvsrc_y
;
639 int i
, idx
, tx
= 0, ty
= 0;
640 int mvx
[4], mvy
[4], intra
[4];
641 static const int count
[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
643 if(!v
->s
.last_picture
.data
[0])return;
644 if(s
->flags
& CODEC_FLAG_GRAY
) return;
646 for(i
= 0; i
< 4; i
++) {
647 mvx
[i
] = s
->mv
[0][i
][0];
648 mvy
[i
] = s
->mv
[0][i
][1];
649 intra
[i
] = v
->mb_type
[0][s
->block_index
[i
]];
652 /* calculate chroma MV vector from four luma MVs */
653 idx
= (intra
[3] << 3) | (intra
[2] << 2) | (intra
[1] << 1) | intra
[0];
654 if(!idx
) { // all blocks are inter
655 tx
= median4(mvx
[0], mvx
[1], mvx
[2], mvx
[3]);
656 ty
= median4(mvy
[0], mvy
[1], mvy
[2], mvy
[3]);
657 } else if(count
[idx
] == 1) { // 3 inter blocks
660 tx
= mid_pred(mvx
[1], mvx
[2], mvx
[3]);
661 ty
= mid_pred(mvy
[1], mvy
[2], mvy
[3]);
664 tx
= mid_pred(mvx
[0], mvx
[2], mvx
[3]);
665 ty
= mid_pred(mvy
[0], mvy
[2], mvy
[3]);
668 tx
= mid_pred(mvx
[0], mvx
[1], mvx
[3]);
669 ty
= mid_pred(mvy
[0], mvy
[1], mvy
[3]);
672 tx
= mid_pred(mvx
[0], mvx
[1], mvx
[2]);
673 ty
= mid_pred(mvy
[0], mvy
[1], mvy
[2]);
676 } else if(count
[idx
] == 2) {
678 for(i
=0; i
<3;i
++) if(!intra
[i
]) {t1
= i
; break;}
679 for(i
= t1
+1; i
<4; i
++)if(!intra
[i
]) {t2
= i
; break;}
680 tx
= (mvx
[t1
] + mvx
[t2
]) / 2;
681 ty
= (mvy
[t1
] + mvy
[t2
]) / 2;
683 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = 0;
684 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = 0;
685 return; //no need to do MC for inter blocks
688 s
->current_picture
.motion_val
[1][s
->block_index
[0]][0] = tx
;
689 s
->current_picture
.motion_val
[1][s
->block_index
[0]][1] = ty
;
690 uvmx
= (tx
+ ((tx
&3) == 3)) >> 1;
691 uvmy
= (ty
+ ((ty
&3) == 3)) >> 1;
693 uvmx
= uvmx
+ ((uvmx
<0)?
(uvmx
&1):-(uvmx
&1));
694 uvmy
= uvmy
+ ((uvmy
<0)?
(uvmy
&1):-(uvmy
&1));
697 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
698 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
700 if(v
->profile
!= PROFILE_ADVANCED
){
701 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
702 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
704 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
705 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
708 srcU
= s
->last_picture
.data
[1] + uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
709 srcV
= s
->last_picture
.data
[2] + uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
710 if(v
->rangeredfrm
|| (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
711 || (unsigned)uvsrc_x
> (s
->h_edge_pos
>> 1) - 9
712 || (unsigned)uvsrc_y
> (s
->v_edge_pos
>> 1) - 9){
713 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcU
, s
->uvlinesize
, 8+1, 8+1,
714 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
715 ff_emulated_edge_mc(s
->edge_emu_buffer
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
716 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
717 srcU
= s
->edge_emu_buffer
;
718 srcV
= s
->edge_emu_buffer
+ 16;
720 /* if we deal with range reduction we need to scale source blocks */
725 src
= srcU
; src2
= srcV
;
726 for(j
= 0; j
< 9; j
++) {
727 for(i
= 0; i
< 9; i
++) {
728 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
729 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
731 src
+= s
->uvlinesize
;
732 src2
+= s
->uvlinesize
;
735 /* if we deal with intensity compensation we need to scale source blocks */
736 if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
740 src
= srcU
; src2
= srcV
;
741 for(j
= 0; j
< 9; j
++) {
742 for(i
= 0; i
< 9; i
++) {
743 src
[i
] = v
->lutuv
[src
[i
]];
744 src2
[i
] = v
->lutuv
[src2
[i
]];
746 src
+= s
->uvlinesize
;
747 src2
+= s
->uvlinesize
;
752 /* Chroma MC always uses qpel bilinear */
753 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
757 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
758 dsp
->put_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
760 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
761 dsp
->put_no_rnd_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
765 static int decode_sequence_header_adv(VC1Context
*v
, GetBitContext
*gb
);
768 * Decode Simple/Main Profiles sequence header
769 * @see Figure 7-8, p16-17
770 * @param avctx Codec context
771 * @param gb GetBit context initialized from Codec context extra_data
774 static int decode_sequence_header(AVCodecContext
*avctx
, GetBitContext
*gb
)
776 VC1Context
*v
= avctx
->priv_data
;
778 av_log(avctx
, AV_LOG_DEBUG
, "Header: %0X\n", show_bits(gb
, 32));
779 v
->profile
= get_bits(gb
, 2);
780 if (v
->profile
== PROFILE_COMPLEX
)
782 av_log(avctx
, AV_LOG_ERROR
, "WMV3 Complex Profile is not fully supported\n");
785 if (v
->profile
== PROFILE_ADVANCED
)
787 return decode_sequence_header_adv(v
, gb
);
791 v
->res_sm
= get_bits(gb
, 2); //reserved
794 av_log(avctx
, AV_LOG_ERROR
,
795 "Reserved RES_SM=%i is forbidden\n", v
->res_sm
);
801 v
->frmrtq_postproc
= get_bits(gb
, 3); //common
802 // (bitrate-32kbps)/64kbps
803 v
->bitrtq_postproc
= get_bits(gb
, 5); //common
804 v
->s
.loop_filter
= get_bits1(gb
); //common
805 if(v
->s
.loop_filter
== 1 && v
->profile
== PROFILE_SIMPLE
)
807 av_log(avctx
, AV_LOG_ERROR
,
808 "LOOPFILTER shell not be enabled in simple profile\n");
811 v
->res_x8
= get_bits1(gb
); //reserved
812 v
->multires
= get_bits1(gb
);
813 v
->res_fasttx
= get_bits1(gb
);
816 v
->s
.dsp
.vc1_inv_trans_8x8
= simple_idct
;
819 v
->fastuvmc
= get_bits1(gb
); //common
820 if (!v
->profile
&& !v
->fastuvmc
)
822 av_log(avctx
, AV_LOG_ERROR
,
823 "FASTUVMC unavailable in Simple Profile\n");
826 v
->extended_mv
= get_bits1(gb
); //common
827 if (!v
->profile
&& v
->extended_mv
)
829 av_log(avctx
, AV_LOG_ERROR
,
830 "Extended MVs unavailable in Simple Profile\n");
833 v
->dquant
= get_bits(gb
, 2); //common
834 v
->vstransform
= get_bits1(gb
); //common
836 v
->res_transtab
= get_bits1(gb
);
839 av_log(avctx
, AV_LOG_ERROR
,
840 "1 for reserved RES_TRANSTAB is forbidden\n");
844 v
->overlap
= get_bits1(gb
); //common
846 v
->s
.resync_marker
= get_bits1(gb
);
847 v
->rangered
= get_bits1(gb
);
848 if (v
->rangered
&& v
->profile
== PROFILE_SIMPLE
)
850 av_log(avctx
, AV_LOG_INFO
,
851 "RANGERED should be set to 0 in simple profile\n");
854 v
->s
.max_b_frames
= avctx
->max_b_frames
= get_bits(gb
, 3); //common
855 v
->quantizer_mode
= get_bits(gb
, 2); //common
857 v
->finterpflag
= get_bits1(gb
); //common
858 v
->res_rtm_flag
= get_bits1(gb
); //reserved
859 if (!v
->res_rtm_flag
)
861 // av_log(avctx, AV_LOG_ERROR,
862 // "0 for reserved RES_RTM_FLAG is forbidden\n");
863 av_log(avctx
, AV_LOG_ERROR
,
864 "Old WMV3 version detected, only I-frames will be decoded\n");
867 //TODO: figure out what they mean (always 0x402F)
868 if(!v
->res_fasttx
) skip_bits(gb
, 16);
869 av_log(avctx
, AV_LOG_DEBUG
,
870 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
871 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
872 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
873 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
874 v
->profile
, v
->frmrtq_postproc
, v
->bitrtq_postproc
,
875 v
->s
.loop_filter
, v
->multires
, v
->fastuvmc
, v
->extended_mv
,
876 v
->rangered
, v
->vstransform
, v
->overlap
, v
->s
.resync_marker
,
877 v
->dquant
, v
->quantizer_mode
, avctx
->max_b_frames
882 static int decode_sequence_header_adv(VC1Context
*v
, GetBitContext
*gb
)
885 v
->level
= get_bits(gb
, 3);
888 av_log(v
->s
.avctx
, AV_LOG_ERROR
, "Reserved LEVEL %i\n",v
->level
);
890 v
->chromaformat
= get_bits(gb
, 2);
891 if (v
->chromaformat
!= 1)
893 av_log(v
->s
.avctx
, AV_LOG_ERROR
,
894 "Only 4:2:0 chroma format supported\n");
899 v
->frmrtq_postproc
= get_bits(gb
, 3); //common
900 // (bitrate-32kbps)/64kbps
901 v
->bitrtq_postproc
= get_bits(gb
, 5); //common
902 v
->postprocflag
= get_bits1(gb
); //common
904 v
->s
.avctx
->coded_width
= (get_bits(gb
, 12) + 1) << 1;
905 v
->s
.avctx
->coded_height
= (get_bits(gb
, 12) + 1) << 1;
906 v
->s
.avctx
->width
= v
->s
.avctx
->coded_width
;
907 v
->s
.avctx
->height
= v
->s
.avctx
->coded_height
;
908 v
->broadcast
= get_bits1(gb
);
909 v
->interlace
= get_bits1(gb
);
910 v
->tfcntrflag
= get_bits1(gb
);
911 v
->finterpflag
= get_bits1(gb
);
912 skip_bits1(gb
); // reserved
914 v
->s
.h_edge_pos
= v
->s
.avctx
->coded_width
;
915 v
->s
.v_edge_pos
= v
->s
.avctx
->coded_height
;
917 av_log(v
->s
.avctx
, AV_LOG_DEBUG
,
918 "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
919 "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
920 "TFCTRflag=%i, FINTERPflag=%i\n",
921 v
->level
, v
->frmrtq_postproc
, v
->bitrtq_postproc
,
922 v
->s
.loop_filter
, v
->chromaformat
, v
->broadcast
, v
->interlace
,
923 v
->tfcntrflag
, v
->finterpflag
926 v
->psf
= get_bits1(gb
);
927 if(v
->psf
) { //PsF, 6.1.13
928 av_log(v
->s
.avctx
, AV_LOG_ERROR
, "Progressive Segmented Frame mode: not supported (yet)\n");
931 v
->s
.max_b_frames
= v
->s
.avctx
->max_b_frames
= 7;
932 if(get_bits1(gb
)) { //Display Info - decoding is not affected by it
934 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "Display extended info:\n");
935 v
->s
.avctx
->width
= v
->s
.width
= w
= get_bits(gb
, 14) + 1;
936 v
->s
.avctx
->height
= v
->s
.height
= h
= get_bits(gb
, 14) + 1;
937 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "Display dimensions: %ix%i\n", w
, h
);
939 ar
= get_bits(gb
, 4);
941 v
->s
.avctx
->sample_aspect_ratio
= ff_vc1_pixel_aspect
[ar
];
945 v
->s
.avctx
->sample_aspect_ratio
= (AVRational
){w
, h
};
948 if(get_bits1(gb
)){ //framerate stuff
950 v
->s
.avctx
->time_base
.num
= 32;
951 v
->s
.avctx
->time_base
.den
= get_bits(gb
, 16) + 1;
954 nr
= get_bits(gb
, 8);
955 dr
= get_bits(gb
, 4);
956 if(nr
&& nr
< 8 && dr
&& dr
< 3){
957 v
->s
.avctx
->time_base
.num
= ff_vc1_fps_dr
[dr
- 1];
958 v
->s
.avctx
->time_base
.den
= ff_vc1_fps_nr
[nr
- 1] * 1000;
964 v
->color_prim
= get_bits(gb
, 8);
965 v
->transfer_char
= get_bits(gb
, 8);
966 v
->matrix_coef
= get_bits(gb
, 8);
970 v
->hrd_param_flag
= get_bits1(gb
);
971 if(v
->hrd_param_flag
) {
973 v
->hrd_num_leaky_buckets
= get_bits(gb
, 5);
974 skip_bits(gb
, 4); //bitrate exponent
975 skip_bits(gb
, 4); //buffer size exponent
976 for(i
= 0; i
< v
->hrd_num_leaky_buckets
; i
++) {
977 skip_bits(gb
, 16); //hrd_rate[n]
978 skip_bits(gb
, 16); //hrd_buffer[n]
984 static int decode_entry_point(AVCodecContext
*avctx
, GetBitContext
*gb
)
986 VC1Context
*v
= avctx
->priv_data
;
987 int i
, blink
, clentry
, refdist
;
989 av_log(avctx
, AV_LOG_DEBUG
, "Entry point: %08X\n", show_bits_long(gb
, 32));
990 blink
= get_bits1(gb
); // broken link
991 clentry
= get_bits1(gb
); // closed entry
992 v
->panscanflag
= get_bits1(gb
);
993 refdist
= get_bits1(gb
); // refdist flag
994 v
->s
.loop_filter
= get_bits1(gb
);
995 v
->fastuvmc
= get_bits1(gb
);
996 v
->extended_mv
= get_bits1(gb
);
997 v
->dquant
= get_bits(gb
, 2);
998 v
->vstransform
= get_bits1(gb
);
999 v
->overlap
= get_bits1(gb
);
1000 v
->quantizer_mode
= get_bits(gb
, 2);
1002 if(v
->hrd_param_flag
){
1003 for(i
= 0; i
< v
->hrd_num_leaky_buckets
; i
++) {
1004 skip_bits(gb
, 8); //hrd_full[n]
1009 avctx
->coded_width
= (get_bits(gb
, 12)+1)<<1;
1010 avctx
->coded_height
= (get_bits(gb
, 12)+1)<<1;
1013 v
->extended_dmv
= get_bits1(gb
);
1015 av_log(avctx
, AV_LOG_ERROR
, "Luma scaling is not supported, expect wrong picture\n");
1016 skip_bits(gb
, 3); // Y range, ignored for now
1019 av_log(avctx
, AV_LOG_ERROR
, "Chroma scaling is not supported, expect wrong picture\n");
1020 skip_bits(gb
, 3); // UV range, ignored for now
1023 av_log(avctx
, AV_LOG_DEBUG
, "Entry point info:\n"
1024 "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1025 "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1026 "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1027 blink
, clentry
, v
->panscanflag
, refdist
, v
->s
.loop_filter
,
1028 v
->fastuvmc
, v
->extended_mv
, v
->dquant
, v
->vstransform
, v
->overlap
, v
->quantizer_mode
);
1033 static int vc1_parse_frame_header(VC1Context
*v
, GetBitContext
* gb
)
1035 int pqindex
, lowquant
, status
;
1037 if(v
->finterpflag
) v
->interpfrm
= get_bits1(gb
);
1038 skip_bits(gb
, 2); //framecnt unused
1040 if (v
->rangered
) v
->rangeredfrm
= get_bits1(gb
);
1041 v
->s
.pict_type
= get_bits1(gb
);
1042 if (v
->s
.avctx
->max_b_frames
) {
1043 if (!v
->s
.pict_type
) {
1044 if (get_bits1(gb
)) v
->s
.pict_type
= I_TYPE
;
1045 else v
->s
.pict_type
= B_TYPE
;
1046 } else v
->s
.pict_type
= P_TYPE
;
1047 } else v
->s
.pict_type
= v
->s
.pict_type ? P_TYPE
: I_TYPE
;
1050 if(v
->s
.pict_type
== B_TYPE
) {
1051 v
->bfraction
= get_vlc2(gb
, ff_vc1_bfraction_vlc
.table
, VC1_BFRACTION_VLC_BITS
, 1);
1052 v
->bfraction
= ff_vc1_bfraction_lut
[v
->bfraction
];
1053 if(v
->bfraction
== 0) {
1054 v
->s
.pict_type
= BI_TYPE
;
1057 if(v
->s
.pict_type
== I_TYPE
|| v
->s
.pict_type
== BI_TYPE
)
1058 skip_bits(gb
, 7); // skip buffer fullness
1061 if(v
->s
.pict_type
== I_TYPE
|| v
->s
.pict_type
== BI_TYPE
)
1063 if(v
->s
.pict_type
== P_TYPE
)
1066 /* Quantizer stuff */
1067 pqindex
= get_bits(gb
, 5);
1068 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1069 v
->pq
= ff_vc1_pquant_table
[0][pqindex
];
1071 v
->pq
= ff_vc1_pquant_table
[1][pqindex
];
1074 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1075 v
->pquantizer
= pqindex
< 9;
1076 if (v
->quantizer_mode
== QUANT_NON_UNIFORM
)
1078 v
->pqindex
= pqindex
;
1079 if (pqindex
< 9) v
->halfpq
= get_bits1(gb
);
1081 if (v
->quantizer_mode
== QUANT_FRAME_EXPLICIT
)
1082 v
->pquantizer
= get_bits1(gb
);
1084 if (v
->extended_mv
== 1) v
->mvrange
= get_unary(gb
, 0, 3);
1085 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1086 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1087 v
->range_x
= 1 << (v
->k_x
- 1);
1088 v
->range_y
= 1 << (v
->k_y
- 1);
1089 if (v
->profile
== PROFILE_ADVANCED
)
1091 if (v
->postprocflag
) v
->postproc
= get_bits1(gb
);
1094 if (v
->multires
&& v
->s
.pict_type
!= B_TYPE
) v
->respic
= get_bits(gb
, 2);
1096 if(v
->res_x8
&& (v
->s
.pict_type
== I_TYPE
|| v
->s
.pict_type
== BI_TYPE
)){
1097 v
->x8_type
= get_bits1(gb
);
1098 }else v
->x8_type
= 0;
1099 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1100 // (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1102 if(v
->s
.pict_type
== I_TYPE
|| v
->s
.pict_type
== P_TYPE
) v
->use_ic
= 0;
1104 switch(v
->s
.pict_type
) {
1106 if (v
->pq
< 5) v
->tt_index
= 0;
1107 else if(v
->pq
< 13) v
->tt_index
= 1;
1108 else v
->tt_index
= 2;
1110 lowquant
= (v
->pq
> 12) ?
0 : 1;
1111 v
->mv_mode
= ff_vc1_mv_pmode_table
[lowquant
][get_unary(gb
, 1, 4)];
1112 if (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
1114 int scale
, shift
, i
;
1115 v
->mv_mode2
= ff_vc1_mv_pmode_table2
[lowquant
][get_unary(gb
, 1, 3)];
1116 v
->lumscale
= get_bits(gb
, 6);
1117 v
->lumshift
= get_bits(gb
, 6);
1119 /* fill lookup tables for intensity compensation */
1122 shift
= (255 - v
->lumshift
* 2) << 6;
1123 if(v
->lumshift
> 31)
1126 scale
= v
->lumscale
+ 32;
1127 if(v
->lumshift
> 31)
1128 shift
= (v
->lumshift
- 64) << 6;
1130 shift
= v
->lumshift
<< 6;
1132 for(i
= 0; i
< 256; i
++) {
1133 v
->luty
[i
] = av_clip_uint8((scale
* i
+ shift
+ 32) >> 6);
1134 v
->lutuv
[i
] = av_clip_uint8((scale
* (i
- 128) + 128*64 + 32) >> 6);
1137 if(v
->mv_mode
== MV_PMODE_1MV_HPEL
|| v
->mv_mode
== MV_PMODE_1MV_HPEL_BILIN
)
1138 v
->s
.quarter_sample
= 0;
1139 else if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
1140 if(v
->mv_mode2
== MV_PMODE_1MV_HPEL
|| v
->mv_mode2
== MV_PMODE_1MV_HPEL_BILIN
)
1141 v
->s
.quarter_sample
= 0;
1143 v
->s
.quarter_sample
= 1;
1145 v
->s
.quarter_sample
= 1;
1146 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
));
1148 if ((v
->mv_mode
== MV_PMODE_INTENSITY_COMP
&&
1149 v
->mv_mode2
== MV_PMODE_MIXED_MV
)
1150 || v
->mv_mode
== MV_PMODE_MIXED_MV
)
1152 status
= bitplane_decoding(v
->mv_type_mb_plane
, &v
->mv_type_is_raw
, v
);
1153 if (status
< 0) return -1;
1154 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB MV Type plane encoding: "
1155 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1157 v
->mv_type_is_raw
= 0;
1158 memset(v
->mv_type_mb_plane
, 0, v
->s
.mb_stride
* v
->s
.mb_height
);
1160 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1161 if (status
< 0) return -1;
1162 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1163 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1165 /* Hopefully this is correct for P frames */
1166 v
->s
.mv_table_index
= get_bits(gb
, 2); //but using ff_vc1_ tables
1167 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1171 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1172 vop_dquant_decoding(v
);
1175 v
->ttfrm
= 0; //FIXME Is that so ?
1178 v
->ttmbf
= get_bits1(gb
);
1181 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1189 if (v
->pq
< 5) v
->tt_index
= 0;
1190 else if(v
->pq
< 13) v
->tt_index
= 1;
1191 else v
->tt_index
= 2;
1193 lowquant
= (v
->pq
> 12) ?
0 : 1;
1194 v
->mv_mode
= get_bits1(gb
) ? MV_PMODE_1MV
: MV_PMODE_1MV_HPEL_BILIN
;
1195 v
->s
.quarter_sample
= (v
->mv_mode
== MV_PMODE_1MV
);
1196 v
->s
.mspel
= v
->s
.quarter_sample
;
1198 status
= bitplane_decoding(v
->direct_mb_plane
, &v
->dmb_is_raw
, v
);
1199 if (status
< 0) return -1;
1200 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Direct Type plane encoding: "
1201 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1202 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1203 if (status
< 0) return -1;
1204 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1205 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1207 v
->s
.mv_table_index
= get_bits(gb
, 2);
1208 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1212 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1213 vop_dquant_decoding(v
);
1219 v
->ttmbf
= get_bits1(gb
);
1222 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1234 v
->c_ac_table_index
= decode012(gb
);
1235 if (v
->s
.pict_type
== I_TYPE
|| v
->s
.pict_type
== BI_TYPE
)
1237 v
->y_ac_table_index
= decode012(gb
);
1240 v
->s
.dc_table_index
= get_bits1(gb
);
1243 if(v
->s
.pict_type
== BI_TYPE
) {
1244 v
->s
.pict_type
= B_TYPE
;
1250 static int vc1_parse_frame_header_adv(VC1Context
*v
, GetBitContext
* gb
)
1252 int pqindex
, lowquant
;
1255 v
->p_frame_skipped
= 0;
1258 v
->fcm
= decode012(gb
);
1259 if(v
->fcm
) return -1; // interlaced frames/fields are not implemented
1261 switch(get_unary(gb
, 0, 4)) {
1263 v
->s
.pict_type
= P_TYPE
;
1266 v
->s
.pict_type
= B_TYPE
;
1269 v
->s
.pict_type
= I_TYPE
;
1272 v
->s
.pict_type
= BI_TYPE
;
1275 v
->s
.pict_type
= P_TYPE
; // skipped pic
1276 v
->p_frame_skipped
= 1;
1282 if(!v
->interlace
|| v
->psf
) {
1283 v
->rptfrm
= get_bits(gb
, 2);
1285 v
->tff
= get_bits1(gb
);
1286 v
->rptfrm
= get_bits1(gb
);
1289 if(v
->panscanflag
) {
1292 v
->rnd
= get_bits1(gb
);
1294 v
->uvsamp
= get_bits1(gb
);
1295 if(v
->finterpflag
) v
->interpfrm
= get_bits1(gb
);
1296 if(v
->s
.pict_type
== B_TYPE
) {
1297 v
->bfraction
= get_vlc2(gb
, ff_vc1_bfraction_vlc
.table
, VC1_BFRACTION_VLC_BITS
, 1);
1298 v
->bfraction
= ff_vc1_bfraction_lut
[v
->bfraction
];
1299 if(v
->bfraction
== 0) {
1300 v
->s
.pict_type
= BI_TYPE
; /* XXX: should not happen here */
1303 pqindex
= get_bits(gb
, 5);
1304 v
->pqindex
= pqindex
;
1305 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1306 v
->pq
= ff_vc1_pquant_table
[0][pqindex
];
1308 v
->pq
= ff_vc1_pquant_table
[1][pqindex
];
1311 if (v
->quantizer_mode
== QUANT_FRAME_IMPLICIT
)
1312 v
->pquantizer
= pqindex
< 9;
1313 if (v
->quantizer_mode
== QUANT_NON_UNIFORM
)
1315 v
->pqindex
= pqindex
;
1316 if (pqindex
< 9) v
->halfpq
= get_bits1(gb
);
1318 if (v
->quantizer_mode
== QUANT_FRAME_EXPLICIT
)
1319 v
->pquantizer
= get_bits1(gb
);
1321 if(v
->s
.pict_type
== I_TYPE
|| v
->s
.pict_type
== P_TYPE
) v
->use_ic
= 0;
1323 switch(v
->s
.pict_type
) {
1326 status
= bitplane_decoding(v
->acpred_plane
, &v
->acpred_is_raw
, v
);
1327 if (status
< 0) return -1;
1328 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "ACPRED plane encoding: "
1329 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1330 v
->condover
= CONDOVER_NONE
;
1331 if(v
->overlap
&& v
->pq
<= 8) {
1332 v
->condover
= decode012(gb
);
1333 if(v
->condover
== CONDOVER_SELECT
) {
1334 status
= bitplane_decoding(v
->over_flags_plane
, &v
->overflg_is_raw
, v
);
1335 if (status
< 0) return -1;
1336 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "CONDOVER plane encoding: "
1337 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1343 v
->postproc
= get_bits1(gb
);
1344 if (v
->extended_mv
) v
->mvrange
= get_unary(gb
, 0, 3);
1345 else v
->mvrange
= 0;
1346 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1347 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1348 v
->range_x
= 1 << (v
->k_x
- 1);
1349 v
->range_y
= 1 << (v
->k_y
- 1);
1351 if (v
->pq
< 5) v
->tt_index
= 0;
1352 else if(v
->pq
< 13) v
->tt_index
= 1;
1353 else v
->tt_index
= 2;
1355 lowquant
= (v
->pq
> 12) ?
0 : 1;
1356 v
->mv_mode
= ff_vc1_mv_pmode_table
[lowquant
][get_unary(gb
, 1, 4)];
1357 if (v
->mv_mode
== MV_PMODE_INTENSITY_COMP
)
1359 int scale
, shift
, i
;
1360 v
->mv_mode2
= ff_vc1_mv_pmode_table2
[lowquant
][get_unary(gb
, 1, 3)];
1361 v
->lumscale
= get_bits(gb
, 6);
1362 v
->lumshift
= get_bits(gb
, 6);
1363 /* fill lookup tables for intensity compensation */
1366 shift
= (255 - v
->lumshift
* 2) << 6;
1367 if(v
->lumshift
> 31)
1370 scale
= v
->lumscale
+ 32;
1371 if(v
->lumshift
> 31)
1372 shift
= (v
->lumshift
- 64) << 6;
1374 shift
= v
->lumshift
<< 6;
1376 for(i
= 0; i
< 256; i
++) {
1377 v
->luty
[i
] = av_clip_uint8((scale
* i
+ shift
+ 32) >> 6);
1378 v
->lutuv
[i
] = av_clip_uint8((scale
* (i
- 128) + 128*64 + 32) >> 6);
1382 if(v
->mv_mode
== MV_PMODE_1MV_HPEL
|| v
->mv_mode
== MV_PMODE_1MV_HPEL_BILIN
)
1383 v
->s
.quarter_sample
= 0;
1384 else if(v
->mv_mode
== MV_PMODE_INTENSITY_COMP
) {
1385 if(v
->mv_mode2
== MV_PMODE_1MV_HPEL
|| v
->mv_mode2
== MV_PMODE_1MV_HPEL_BILIN
)
1386 v
->s
.quarter_sample
= 0;
1388 v
->s
.quarter_sample
= 1;
1390 v
->s
.quarter_sample
= 1;
1391 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
));
1393 if ((v
->mv_mode
== MV_PMODE_INTENSITY_COMP
&&
1394 v
->mv_mode2
== MV_PMODE_MIXED_MV
)
1395 || v
->mv_mode
== MV_PMODE_MIXED_MV
)
1397 status
= bitplane_decoding(v
->mv_type_mb_plane
, &v
->mv_type_is_raw
, v
);
1398 if (status
< 0) return -1;
1399 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB MV Type plane encoding: "
1400 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1402 v
->mv_type_is_raw
= 0;
1403 memset(v
->mv_type_mb_plane
, 0, v
->s
.mb_stride
* v
->s
.mb_height
);
1405 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1406 if (status
< 0) return -1;
1407 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1408 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1410 /* Hopefully this is correct for P frames */
1411 v
->s
.mv_table_index
= get_bits(gb
, 2); //but using ff_vc1_ tables
1412 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1415 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1416 vop_dquant_decoding(v
);
1419 v
->ttfrm
= 0; //FIXME Is that so ?
1422 v
->ttmbf
= get_bits1(gb
);
1425 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1434 v
->postproc
= get_bits1(gb
);
1435 if (v
->extended_mv
) v
->mvrange
= get_unary(gb
, 0, 3);
1436 else v
->mvrange
= 0;
1437 v
->k_x
= v
->mvrange
+ 9 + (v
->mvrange
>> 1); //k_x can be 9 10 12 13
1438 v
->k_y
= v
->mvrange
+ 8; //k_y can be 8 9 10 11
1439 v
->range_x
= 1 << (v
->k_x
- 1);
1440 v
->range_y
= 1 << (v
->k_y
- 1);
1442 if (v
->pq
< 5) v
->tt_index
= 0;
1443 else if(v
->pq
< 13) v
->tt_index
= 1;
1444 else v
->tt_index
= 2;
1446 lowquant
= (v
->pq
> 12) ?
0 : 1;
1447 v
->mv_mode
= get_bits1(gb
) ? MV_PMODE_1MV
: MV_PMODE_1MV_HPEL_BILIN
;
1448 v
->s
.quarter_sample
= (v
->mv_mode
== MV_PMODE_1MV
);
1449 v
->s
.mspel
= v
->s
.quarter_sample
;
1451 status
= bitplane_decoding(v
->direct_mb_plane
, &v
->dmb_is_raw
, v
);
1452 if (status
< 0) return -1;
1453 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Direct Type plane encoding: "
1454 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1455 status
= bitplane_decoding(v
->s
.mbskip_table
, &v
->skip_is_raw
, v
);
1456 if (status
< 0) return -1;
1457 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "MB Skip plane encoding: "
1458 "Imode: %i, Invert: %i\n", status
>>1, status
&1);
1460 v
->s
.mv_table_index
= get_bits(gb
, 2);
1461 v
->cbpcy_vlc
= &ff_vc1_cbpcy_p_vlc
[get_bits(gb
, 2)];
1465 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1466 vop_dquant_decoding(v
);
1472 v
->ttmbf
= get_bits1(gb
);
1475 v
->ttfrm
= ff_vc1_ttfrm_to_tt
[get_bits(gb
, 2)];
1485 v
->c_ac_table_index
= decode012(gb
);
1486 if (v
->s
.pict_type
== I_TYPE
|| v
->s
.pict_type
== BI_TYPE
)
1488 v
->y_ac_table_index
= decode012(gb
);
1491 v
->s
.dc_table_index
= get_bits1(gb
);
1492 if ((v
->s
.pict_type
== I_TYPE
|| v
->s
.pict_type
== BI_TYPE
) && v
->dquant
) {
1493 av_log(v
->s
.avctx
, AV_LOG_DEBUG
, "VOP DQuant info\n");
1494 vop_dquant_decoding(v
);
1498 if(v
->s
.pict_type
== BI_TYPE
) {
1499 v
->s
.pict_type
= B_TYPE
;
1505 /***********************************************************************/
1507 * @defgroup block VC-1 Block-level functions
1508 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1514 * @brief Get macroblock-level quantizer scale
1516 #define GET_MQUANT() \
1520 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1524 mquant = (get_bits1(gb)) ? v->altpq : v->pq; \
1528 mqdiff = get_bits(gb, 3); \
1529 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1530 else mquant = get_bits(gb, 5); \
1533 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1534 edges = 1 << v->dqsbedge; \
1535 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1536 edges = (3 << v->dqsbedge) % 15; \
1537 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
1539 if((edges&1) && !s->mb_x) \
1540 mquant = v->altpq; \
1541 if((edges&2) && s->first_slice_line) \
1542 mquant = v->altpq; \
1543 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
1544 mquant = v->altpq; \
1545 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
1546 mquant = v->altpq; \
1550 * @def GET_MVDATA(_dmv_x, _dmv_y)
1551 * @brief Get MV differentials
1552 * @see MVDATA decoding from 8.3.5.2, p(1)20
1553 * @param _dmv_x Horizontal differential for decoded MV
1554 * @param _dmv_y Vertical differential for decoded MV
1556 #define GET_MVDATA(_dmv_x, _dmv_y) \
1557 index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[s->mv_table_index].table,\
1558 VC1_MV_DIFF_VLC_BITS, 2); \
1561 mb_has_coeffs = 1; \
1564 else mb_has_coeffs = 0; \
1566 if (!index) { _dmv_x = _dmv_y = 0; } \
1567 else if (index == 35) \
1569 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1570 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1572 else if (index == 36) \
1581 if (!s->quarter_sample && index1 == 5) val = 1; \
1583 if(size_table[index1] - val > 0) \
1584 val = get_bits(gb, size_table[index1] - val); \
1586 sign = 0 - (val&1); \
1587 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1590 if (!s->quarter_sample && index1 == 5) val = 1; \
1592 if(size_table[index1] - val > 0) \
1593 val = get_bits(gb, size_table[index1] - val); \
1595 sign = 0 - (val&1); \
1596 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1599 /** Predict and set motion vector
1601 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
)
1603 int xy
, wrap
, off
= 0;
1608 /* scale MV difference to be quad-pel */
1609 dmv_x
<<= 1 - s
->quarter_sample
;
1610 dmv_y
<<= 1 - s
->quarter_sample
;
1612 wrap
= s
->b8_stride
;
1613 xy
= s
->block_index
[n
];
1616 s
->mv
[0][n
][0] = s
->current_picture
.motion_val
[0][xy
][0] = 0;
1617 s
->mv
[0][n
][1] = s
->current_picture
.motion_val
[0][xy
][1] = 0;
1618 s
->current_picture
.motion_val
[1][xy
][0] = 0;
1619 s
->current_picture
.motion_val
[1][xy
][1] = 0;
1620 if(mv1
) { /* duplicate motion data for 1-MV block */
1621 s
->current_picture
.motion_val
[0][xy
+ 1][0] = 0;
1622 s
->current_picture
.motion_val
[0][xy
+ 1][1] = 0;
1623 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = 0;
1624 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = 0;
1625 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][0] = 0;
1626 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][1] = 0;
1627 s
->current_picture
.motion_val
[1][xy
+ 1][0] = 0;
1628 s
->current_picture
.motion_val
[1][xy
+ 1][1] = 0;
1629 s
->current_picture
.motion_val
[1][xy
+ wrap
][0] = 0;
1630 s
->current_picture
.motion_val
[1][xy
+ wrap
][1] = 0;
1631 s
->current_picture
.motion_val
[1][xy
+ wrap
+ 1][0] = 0;
1632 s
->current_picture
.motion_val
[1][xy
+ wrap
+ 1][1] = 0;
1637 C
= s
->current_picture
.motion_val
[0][xy
- 1];
1638 A
= s
->current_picture
.motion_val
[0][xy
- wrap
];
1640 off
= (s
->mb_x
== (s
->mb_width
- 1)) ?
-1 : 2;
1642 //in 4-MV mode different blocks have different B predictor position
1645 off
= (s
->mb_x
> 0) ?
-1 : 1;
1648 off
= (s
->mb_x
== (s
->mb_width
- 1)) ?
-1 : 1;
1657 B
= s
->current_picture
.motion_val
[0][xy
- wrap
+ off
];
1659 if(!s
->first_slice_line
|| (n
==2 || n
==3)) { // predictor A is not out of bounds
1660 if(s
->mb_width
== 1) {
1664 px
= mid_pred(A
[0], B
[0], C
[0]);
1665 py
= mid_pred(A
[1], B
[1], C
[1]);
1667 } else if(s
->mb_x
|| (n
==1 || n
==3)) { // predictor C is not out of bounds
1673 /* Pullback MV as specified in 8.3.5.3.4 */
1676 qx
= (s
->mb_x
<< 6) + ((n
==1 || n
==3) ?
32 : 0);
1677 qy
= (s
->mb_y
<< 6) + ((n
==2 || n
==3) ?
32 : 0);
1678 X
= (s
->mb_width
<< 6) - 4;
1679 Y
= (s
->mb_height
<< 6) - 4;
1681 if(qx
+ px
< -60) px
= -60 - qx
;
1682 if(qy
+ py
< -60) py
= -60 - qy
;
1684 if(qx
+ px
< -28) px
= -28 - qx
;
1685 if(qy
+ py
< -28) py
= -28 - qy
;
1687 if(qx
+ px
> X
) px
= X
- qx
;
1688 if(qy
+ py
> Y
) py
= Y
- qy
;
1690 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1691 if((!s
->first_slice_line
|| (n
==2 || n
==3)) && (s
->mb_x
|| (n
==1 || n
==3))) {
1692 if(is_intra
[xy
- wrap
])
1693 sum
= FFABS(px
) + FFABS(py
);
1695 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
1697 if(get_bits1(&s
->gb
)) {
1705 if(is_intra
[xy
- 1])
1706 sum
= FFABS(px
) + FFABS(py
);
1708 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
1710 if(get_bits1(&s
->gb
)) {
1720 /* store MV using signed modulus of MV range defined in 4.11 */
1721 s
->mv
[0][n
][0] = s
->current_picture
.motion_val
[0][xy
][0] = ((px
+ dmv_x
+ r_x
) & ((r_x
<< 1) - 1)) - r_x
;
1722 s
->mv
[0][n
][1] = s
->current_picture
.motion_val
[0][xy
][1] = ((py
+ dmv_y
+ r_y
) & ((r_y
<< 1) - 1)) - r_y
;
1723 if(mv1
) { /* duplicate motion data for 1-MV block */
1724 s
->current_picture
.motion_val
[0][xy
+ 1][0] = s
->current_picture
.motion_val
[0][xy
][0];
1725 s
->current_picture
.motion_val
[0][xy
+ 1][1] = s
->current_picture
.motion_val
[0][xy
][1];
1726 s
->current_picture
.motion_val
[0][xy
+ wrap
][0] = s
->current_picture
.motion_val
[0][xy
][0];
1727 s
->current_picture
.motion_val
[0][xy
+ wrap
][1] = s
->current_picture
.motion_val
[0][xy
][1];
1728 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][0] = s
->current_picture
.motion_val
[0][xy
][0];
1729 s
->current_picture
.motion_val
[0][xy
+ wrap
+ 1][1] = s
->current_picture
.motion_val
[0][xy
][1];
1733 /** Motion compensation for direct or interpolated blocks in B-frames
1735 static void vc1_interp_mc(VC1Context
*v
)
1737 MpegEncContext
*s
= &v
->s
;
1738 DSPContext
*dsp
= &v
->s
.dsp
;
1739 uint8_t *srcY
, *srcU
, *srcV
;
1740 int dxy
, uvdxy
, mx
, my
, uvmx
, uvmy
, src_x
, src_y
, uvsrc_x
, uvsrc_y
;
1742 if(!v
->s
.next_picture
.data
[0])return;
1744 mx
= s
->mv
[1][0][0];
1745 my
= s
->mv
[1][0][1];
1746 uvmx
= (mx
+ ((mx
& 3) == 3)) >> 1;
1747 uvmy
= (my
+ ((my
& 3) == 3)) >> 1;
1749 uvmx
= uvmx
+ ((uvmx
<0)?
-(uvmx
&1):(uvmx
&1));
1750 uvmy
= uvmy
+ ((uvmy
<0)?
-(uvmy
&1):(uvmy
&1));
1752 srcY
= s
->next_picture
.data
[0];
1753 srcU
= s
->next_picture
.data
[1];
1754 srcV
= s
->next_picture
.data
[2];
1756 src_x
= s
->mb_x
* 16 + (mx
>> 2);
1757 src_y
= s
->mb_y
* 16 + (my
>> 2);
1758 uvsrc_x
= s
->mb_x
* 8 + (uvmx
>> 2);
1759 uvsrc_y
= s
->mb_y
* 8 + (uvmy
>> 2);
1761 if(v
->profile
!= PROFILE_ADVANCED
){
1762 src_x
= av_clip( src_x
, -16, s
->mb_width
* 16);
1763 src_y
= av_clip( src_y
, -16, s
->mb_height
* 16);
1764 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->mb_width
* 8);
1765 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->mb_height
* 8);
1767 src_x
= av_clip( src_x
, -17, s
->avctx
->coded_width
);
1768 src_y
= av_clip( src_y
, -18, s
->avctx
->coded_height
+ 1);
1769 uvsrc_x
= av_clip(uvsrc_x
, -8, s
->avctx
->coded_width
>> 1);
1770 uvsrc_y
= av_clip(uvsrc_y
, -8, s
->avctx
->coded_height
>> 1);
1773 srcY
+= src_y
* s
->linesize
+ src_x
;
1774 srcU
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
1775 srcV
+= uvsrc_y
* s
->uvlinesize
+ uvsrc_x
;
1777 /* for grayscale we should not try to read from unknown area */
1778 if(s
->flags
& CODEC_FLAG_GRAY
) {
1779 srcU
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
1780 srcV
= s
->edge_emu_buffer
+ 18 * s
->linesize
;
1784 || (unsigned)src_x
> s
->h_edge_pos
- (mx
&3) - 16
1785 || (unsigned)src_y
> s
->v_edge_pos
- (my
&3) - 16){
1786 uint8_t *uvbuf
= s
->edge_emu_buffer
+ 19 * s
->linesize
;
1788 srcY
-= s
->mspel
* (1 + s
->linesize
);
1789 ff_emulated_edge_mc(s
->edge_emu_buffer
, srcY
, s
->linesize
, 17+s
->mspel
*2, 17+s
->mspel
*2,
1790 src_x
- s
->mspel
, src_y
- s
->mspel
, s
->h_edge_pos
, s
->v_edge_pos
);
1791 srcY
= s
->edge_emu_buffer
;
1792 ff_emulated_edge_mc(uvbuf
, srcU
, s
->uvlinesize
, 8+1, 8+1,
1793 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
1794 ff_emulated_edge_mc(uvbuf
+ 16, srcV
, s
->uvlinesize
, 8+1, 8+1,
1795 uvsrc_x
, uvsrc_y
, s
->h_edge_pos
>> 1, s
->v_edge_pos
>> 1);
1798 /* if we deal with range reduction we need to scale source blocks */
1799 if(v
->rangeredfrm
) {
1801 uint8_t *src
, *src2
;
1804 for(j
= 0; j
< 17 + s
->mspel
*2; j
++) {
1805 for(i
= 0; i
< 17 + s
->mspel
*2; i
++) src
[i
] = ((src
[i
] - 128) >> 1) + 128;
1808 src
= srcU
; src2
= srcV
;
1809 for(j
= 0; j
< 9; j
++) {
1810 for(i
= 0; i
< 9; i
++) {
1811 src
[i
] = ((src
[i
] - 128) >> 1) + 128;
1812 src2
[i
] = ((src2
[i
] - 128) >> 1) + 128;
1814 src
+= s
->uvlinesize
;
1815 src2
+= s
->uvlinesize
;
1818 srcY
+= s
->mspel
* (1 + s
->linesize
);
1823 dxy
= ((my
& 1) << 1) | (mx
& 1);
1825 dsp
->avg_pixels_tab
[0][dxy
](s
->dest
[0], srcY
, s
->linesize
, 16);
1827 if(s
->flags
& CODEC_FLAG_GRAY
) return;
1828 /* Chroma MC always uses qpel blilinear */
1829 uvdxy
= ((uvmy
& 3) << 2) | (uvmx
& 3);
1832 dsp
->avg_h264_chroma_pixels_tab
[0](s
->dest
[1], srcU
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1833 dsp
->avg_h264_chroma_pixels_tab
[0](s
->dest
[2], srcV
, s
->uvlinesize
, 8, uvmx
, uvmy
);
1836 static av_always_inline
int scale_mv(int value
, int bfrac
, int inv
, int qs
)
1840 #if B_FRACTION_DEN==256
1844 return 2 * ((value
* n
+ 255) >> 9);
1845 return (value
* n
+ 128) >> 8;
1848 n
-= B_FRACTION_DEN
;
1850 return 2 * ((value
* n
+ B_FRACTION_DEN
- 1) / (2 * B_FRACTION_DEN
));
1851 return (value
* n
+ B_FRACTION_DEN
/2) / B_FRACTION_DEN
;
1855 /** Reconstruct motion vector for B-frame and do motion compensation
1857 static inline void vc1_b_mc(VC1Context
*v
, int dmv_x
[2], int dmv_y
[2], int direct
, int mode
)
1860 v
->mv_mode2
= v
->mv_mode
;
1861 v
->mv_mode
= MV_PMODE_INTENSITY_COMP
;
1866 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1869 if(mode
== BMV_TYPE_INTERPOLATED
) {
1872 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1876 if(v
->use_ic
&& (mode
== BMV_TYPE_BACKWARD
)) v
->mv_mode
= v
->mv_mode2
;
1877 vc1_mc_1mv(v
, (mode
== BMV_TYPE_BACKWARD
));
1878 if(v
->use_ic
) v
->mv_mode
= v
->mv_mode2
;
1881 static inline void vc1_pred_b_mv(VC1Context
*v
, int dmv_x
[2], int dmv_y
[2], int direct
, int mvtype
)
1883 MpegEncContext
*s
= &v
->s
;
1884 int xy
, wrap
, off
= 0;
1889 const uint8_t *is_intra
= v
->mb_type
[0];
1893 /* scale MV difference to be quad-pel */
1894 dmv_x
[0] <<= 1 - s
->quarter_sample
;
1895 dmv_y
[0] <<= 1 - s
->quarter_sample
;
1896 dmv_x
[1] <<= 1 - s
->quarter_sample
;
1897 dmv_y
[1] <<= 1 - s
->quarter_sample
;
1899 wrap
= s
->b8_stride
;
1900 xy
= s
->block_index
[0];
1903 s
->current_picture
.motion_val
[0][xy
][0] =
1904 s
->current_picture
.motion_val
[0][xy
][1] =
1905 s
->current_picture
.motion_val
[1][xy
][0] =
1906 s
->current_picture
.motion_val
[1][xy
][1] = 0;
1909 s
->mv
[0][0][0] = scale_mv(s
->next_picture
.motion_val
[1][xy
][0], v
->bfraction
, 0, s
->quarter_sample
);
1910 s
->mv
[0][0][1] = scale_mv(s
->next_picture
.motion_val
[1][xy
][1], v
->bfraction
, 0, s
->quarter_sample
);
1911 s
->mv
[1][0][0] = scale_mv(s
->next_picture
.motion_val
[1][xy
][0], v
->bfraction
, 1, s
->quarter_sample
);
1912 s
->mv
[1][0][1] = scale_mv(s
->next_picture
.motion_val
[1][xy
][1], v
->bfraction
, 1, s
->quarter_sample
);
1914 /* Pullback predicted motion vectors as specified in 8.4.5.4 */
1915 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));
1916 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));
1917 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));
1918 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));
1920 s
->current_picture
.motion_val
[0][xy
][0] = s
->mv
[0][0][0];
1921 s
->current_picture
.motion_val
[0][xy
][1] = s
->mv
[0][0][1];
1922 s
->current_picture
.motion_val
[1][xy
][0] = s
->mv
[1][0][0];
1923 s
->current_picture
.motion_val
[1][xy
][1] = s
->mv
[1][0][1];
1927 if((mvtype
== BMV_TYPE_FORWARD
) || (mvtype
== BMV_TYPE_INTERPOLATED
)) {
1928 C
= s
->current_picture
.motion_val
[0][xy
- 2];
1929 A
= s
->current_picture
.motion_val
[0][xy
- wrap
*2];
1930 off
= (s
->mb_x
== (s
->mb_width
- 1)) ?
-2 : 2;
1931 B
= s
->current_picture
.motion_val
[0][xy
- wrap
*2 + off
];
1933 if(!s
->mb_x
) C
[0] = C
[1] = 0;
1934 if(!s
->first_slice_line
) { // predictor A is not out of bounds
1935 if(s
->mb_width
== 1) {
1939 px
= mid_pred(A
[0], B
[0], C
[0]);
1940 py
= mid_pred(A
[1], B
[1], C
[1]);
1942 } else if(s
->mb_x
) { // predictor C is not out of bounds
1948 /* Pullback MV as specified in 8.3.5.3.4 */
1951 if(v
->profile
< PROFILE_ADVANCED
) {
1952 qx
= (s
->mb_x
<< 5);
1953 qy
= (s
->mb_y
<< 5);
1954 X
= (s
->mb_width
<< 5) - 4;
1955 Y
= (s
->mb_height
<< 5) - 4;
1956 if(qx
+ px
< -28) px
= -28 - qx
;
1957 if(qy
+ py
< -28) py
= -28 - qy
;
1958 if(qx
+ px
> X
) px
= X
- qx
;
1959 if(qy
+ py
> Y
) py
= Y
- qy
;
1961 qx
= (s
->mb_x
<< 6);
1962 qy
= (s
->mb_y
<< 6);
1963 X
= (s
->mb_width
<< 6) - 4;
1964 Y
= (s
->mb_height
<< 6) - 4;
1965 if(qx
+ px
< -60) px
= -60 - qx
;
1966 if(qy
+ py
< -60) py
= -60 - qy
;
1967 if(qx
+ px
> X
) px
= X
- qx
;
1968 if(qy
+ py
> Y
) py
= Y
- qy
;
1971 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1972 if(0 && !s
->first_slice_line
&& s
->mb_x
) {
1973 if(is_intra
[xy
- wrap
])
1974 sum
= FFABS(px
) + FFABS(py
);
1976 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
1978 if(get_bits1(&s
->gb
)) {
1986 if(is_intra
[xy
- 2])
1987 sum
= FFABS(px
) + FFABS(py
);
1989 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
1991 if(get_bits1(&s
->gb
)) {
2001 /* store MV using signed modulus of MV range defined in 4.11 */
2002 s
->mv
[0][0][0] = ((px
+ dmv_x
[0] + r_x
) & ((r_x
<< 1) - 1)) - r_x
;
2003 s
->mv
[0][0][1] = ((py
+ dmv_y
[0] + r_y
) & ((r_y
<< 1) - 1)) - r_y
;
2005 if((mvtype
== BMV_TYPE_BACKWARD
) || (mvtype
== BMV_TYPE_INTERPOLATED
)) {
2006 C
= s
->current_picture
.motion_val
[1][xy
- 2];
2007 A
= s
->current_picture
.motion_val
[1][xy
- wrap
*2];
2008 off
= (s
->mb_x
== (s
->mb_width
- 1)) ?
-2 : 2;
2009 B
= s
->current_picture
.motion_val
[1][xy
- wrap
*2 + off
];
2011 if(!s
->mb_x
) C
[0] = C
[1] = 0;
2012 if(!s
->first_slice_line
) { // predictor A is not out of bounds
2013 if(s
->mb_width
== 1) {
2017 px
= mid_pred(A
[0], B
[0], C
[0]);
2018 py
= mid_pred(A
[1], B
[1], C
[1]);
2020 } else if(s
->mb_x
) { // predictor C is not out of bounds
2026 /* Pullback MV as specified in 8.3.5.3.4 */
2029 if(v
->profile
< PROFILE_ADVANCED
) {
2030 qx
= (s
->mb_x
<< 5);
2031 qy
= (s
->mb_y
<< 5);
2032 X
= (s
->mb_width
<< 5) - 4;
2033 Y
= (s
->mb_height
<< 5) - 4;
2034 if(qx
+ px
< -28) px
= -28 - qx
;
2035 if(qy
+ py
< -28) py
= -28 - qy
;
2036 if(qx
+ px
> X
) px
= X
- qx
;
2037 if(qy
+ py
> Y
) py
= Y
- qy
;
2039 qx
= (s
->mb_x
<< 6);
2040 qy
= (s
->mb_y
<< 6);
2041 X
= (s
->mb_width
<< 6) - 4;
2042 Y
= (s
->mb_height
<< 6) - 4;
2043 if(qx
+ px
< -60) px
= -60 - qx
;
2044 if(qy
+ py
< -60) py
= -60 - qy
;
2045 if(qx
+ px
> X
) px
= X
- qx
;
2046 if(qy
+ py
> Y
) py
= Y
- qy
;
2049 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2050 if(0 && !s
->first_slice_line
&& s
->mb_x
) {
2051 if(is_intra
[xy
- wrap
])
2052 sum
= FFABS(px
) + FFABS(py
);
2054 sum
= FFABS(px
- A
[0]) + FFABS(py
- A
[1]);
2056 if(get_bits1(&s
->gb
)) {
2064 if(is_intra
[xy
- 2])
2065 sum
= FFABS(px
) + FFABS(py
);
2067 sum
= FFABS(px
- C
[0]) + FFABS(py
- C
[1]);
2069 if(get_bits1(&s
->gb
)) {
2079 /* store MV using signed modulus of MV range defined in 4.11 */
2081 s
->mv
[1][0][0] = ((px
+ dmv_x
[1] + r_x
) & ((r_x
<< 1) - 1)) - r_x
;
2082 s
->mv
[1][0][1] = ((py
+ dmv_y
[1] + r_y
) & ((r_y
<< 1) - 1)) - r_y
;
2084 s
->current_picture
.motion_val
[0][xy
][0] = s
->mv
[0][0][0];
2085 s
->current_picture
.motion_val
[0][xy
][1] = s
->mv
[0][0][1];
2086 s
->current_picture
.motion_val
[1][xy
][0] = s
->mv
[1][0][0];
2087 s
->current_picture
.motion_val
[1][xy
][1] = s
->mv
[1][0][1];
2090 /** Get predicted DC value for I-frames only
2091 * prediction dir: left=0, top=1
2092 * @param s MpegEncContext
2093 * @param[in] n block index in the current MB
2094 * @param dc_val_ptr Pointer to DC predictor
2095 * @param dir_ptr Prediction direction for use in AC prediction
2097 static inline int vc1_i_pred_dc(MpegEncContext
*s
, int overlap
, int pq
, int n
,
2098 int16_t **dc_val_ptr
, int *dir_ptr
)
2100 int a
, b
, c
, wrap
, pred
, scale
;
2102 static const uint16_t dcpred
[32] = {
2103 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
2104 114, 102, 93, 85, 79, 73, 68, 64,
2105 60, 57, 54, 51, 49, 47, 45, 43,
2106 41, 39, 38, 37, 35, 34, 33
2109 /* find prediction - wmv3_dc_scale always used here in fact */
2110 if (n
< 4) scale
= s
->y_dc_scale
;
2111 else scale
= s
->c_dc_scale
;
2113 wrap
= s
->block_wrap
[n
];
2114 dc_val
= s
->dc_val
[0] + s
->block_index
[n
];
2120 b
= dc_val
[ - 1 - wrap
];
2121 a
= dc_val
[ - wrap
];
2123 if (pq
< 9 || !overlap
)
2125 /* Set outer values */
2126 if (s
->first_slice_line
&& (n
!=2 && n
!=3)) b
=a
=dcpred
[scale
];
2127 if (s
->mb_x
== 0 && (n
!=1 && n
!=3)) b
=c
=dcpred
[scale
];
2131 /* Set outer values */
2132 if (s
->first_slice_line
&& (n
!=2 && n
!=3)) b
=a
=0;
2133 if (s
->mb_x
== 0 && (n
!=1 && n
!=3)) b
=c
=0;
2136 if (abs(a
- b
) <= abs(b
- c
)) {
2144 /* update predictor */
2145 *dc_val_ptr
= &dc_val
[0];
2150 /** Get predicted DC value
2151 * prediction dir: left=0, top=1
2152 * @param s MpegEncContext
2153 * @param[in] n block index in the current MB
2154 * @param dc_val_ptr Pointer to DC predictor
2155 * @param dir_ptr Prediction direction for use in AC prediction
2157 static inline int vc1_pred_dc(MpegEncContext
*s
, int overlap
, int pq
, int n
,
2158 int a_avail
, int c_avail
,
2159 int16_t **dc_val_ptr
, int *dir_ptr
)
2161 int a
, b
, c
, wrap
, pred
, scale
;
2163 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2166 /* find prediction - wmv3_dc_scale always used here in fact */
2167 if (n
< 4) scale
= s
->y_dc_scale
;
2168 else scale
= s
->c_dc_scale
;
2170 wrap
= s
->block_wrap
[n
];
2171 dc_val
= s
->dc_val
[0] + s
->block_index
[n
];
2177 b
= dc_val
[ - 1 - wrap
];
2178 a
= dc_val
[ - wrap
];
2179 /* scale predictors if needed */
2180 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2181 if(c_avail
&& (n
!= 1 && n
!=3)) {
2182 q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2184 c
= (c
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2186 if(a_avail
&& (n
!= 2 && n
!=3)) {
2187 q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2189 a
= (a
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2191 if(a_avail
&& c_avail
&& (n
!=3)) {
2194 if(n
!= 2) off
-= s
->mb_stride
;
2195 q2
= s
->current_picture
.qscale_table
[off
];
2197 b
= (b
* s
->y_dc_scale_table
[q2
] * ff_vc1_dqscale
[s
->y_dc_scale_table
[q1
] - 1] + 0x20000) >> 18;
2200 if(a_avail
&& c_avail
) {
2201 if(abs(a
- b
) <= abs(b
- c
)) {
2208 } else if(a_avail
) {
2211 } else if(c_avail
) {
2219 /* update predictor */
2220 *dc_val_ptr
= &dc_val
[0];
2226 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2227 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2231 static inline int vc1_coded_block_pred(MpegEncContext
* s
, int n
, uint8_t **coded_block_ptr
)
2233 int xy
, wrap
, pred
, a
, b
, c
;
2235 xy
= s
->block_index
[n
];
2236 wrap
= s
->b8_stride
;
2241 a
= s
->coded_block
[xy
- 1 ];
2242 b
= s
->coded_block
[xy
- 1 - wrap
];
2243 c
= s
->coded_block
[xy
- wrap
];
2252 *coded_block_ptr
= &s
->coded_block
[xy
];
2258 * Decode one AC coefficient
2259 * @param v The VC1 context
2260 * @param last Last coefficient
2261 * @param skip How much zero coefficients to skip
2262 * @param value Decoded AC coefficient value
2265 static void vc1_decode_ac_coeff(VC1Context
*v
, int *last
, int *skip
, int *value
, int codingset
)
2267 GetBitContext
*gb
= &v
->s
.gb
;
2268 int index
, escape
, run
= 0, level
= 0, lst
= 0;
2270 index
= get_vlc2(gb
, ff_vc1_ac_coeff_table
[codingset
].table
, AC_VLC_BITS
, 3);
2271 if (index
!= vc1_ac_sizes
[codingset
] - 1) {
2272 run
= vc1_index_decode_table
[codingset
][index
][0];
2273 level
= vc1_index_decode_table
[codingset
][index
][1];
2274 lst
= index
>= vc1_last_decode_table
[codingset
];
2278 escape
= decode210(gb
);
2280 index
= get_vlc2(gb
, ff_vc1_ac_coeff_table
[codingset
].table
, AC_VLC_BITS
, 3);
2281 run
= vc1_index_decode_table
[codingset
][index
][0];
2282 level
= vc1_index_decode_table
[codingset
][index
][1];
2283 lst
= index
>= vc1_last_decode_table
[codingset
];
2286 level
+= vc1_last_delta_level_table
[codingset
][run
];
2288 level
+= vc1_delta_level_table
[codingset
][run
];
2291 run
+= vc1_last_delta_run_table
[codingset
][level
] + 1;
2293 run
+= vc1_delta_run_table
[codingset
][level
] + 1;
2299 lst
= get_bits1(gb
);
2300 if(v
->s
.esc3_level_length
== 0) {
2301 if(v
->pq
< 8 || v
->dquantfrm
) { // table 59
2302 v
->s
.esc3_level_length
= get_bits(gb
, 3);
2303 if(!v
->s
.esc3_level_length
)
2304 v
->s
.esc3_level_length
= get_bits(gb
, 2) + 8;
2306 v
->s
.esc3_level_length
= get_unary(gb
, 1, 6) + 2;
2308 v
->s
.esc3_run_length
= 3 + get_bits(gb
, 2);
2310 run
= get_bits(gb
, v
->s
.esc3_run_length
);
2311 sign
= get_bits1(gb
);
2312 level
= get_bits(gb
, v
->s
.esc3_level_length
);
2323 /** Decode intra block in intra frames - should be faster than decode_intra_block
2324 * @param v VC1Context
2325 * @param block block to decode
2326 * @param coded are AC coeffs present or not
2327 * @param codingset set of VLC to decode data
2329 static int vc1_decode_i_block(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int codingset
)
2331 GetBitContext
*gb
= &v
->s
.gb
;
2332 MpegEncContext
*s
= &v
->s
;
2333 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2336 int16_t *ac_val
, *ac_val2
;
2339 /* Get DC differential */
2341 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2343 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2346 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2351 if (dcdiff
== 119 /* ESC index value */)
2353 /* TODO: Optimize */
2354 if (v
->pq
== 1) dcdiff
= get_bits(gb
, 10);
2355 else if (v
->pq
== 2) dcdiff
= get_bits(gb
, 9);
2356 else dcdiff
= get_bits(gb
, 8);
2361 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2362 else if (v
->pq
== 2)
2363 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2370 dcdiff
+= vc1_i_pred_dc(&v
->s
, v
->overlap
, v
->pq
, n
, &dc_val
, &dc_pred_dir
);
2373 /* Store the quantized DC coeff, used for prediction */
2375 block
[0] = dcdiff
* s
->y_dc_scale
;
2377 block
[0] = dcdiff
* s
->c_dc_scale
;
2390 int last
= 0, skip
, value
;
2391 const int8_t *zz_table
;
2395 scale
= v
->pq
* 2 + v
->halfpq
;
2399 zz_table
= ff_vc1_horizontal_zz
;
2401 zz_table
= ff_vc1_vertical_zz
;
2403 zz_table
= ff_vc1_normal_zz
;
2405 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2407 if(dc_pred_dir
) //left
2410 ac_val
-= 16 * s
->block_wrap
[n
];
2413 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2417 block
[zz_table
[i
++]] = value
;
2420 /* apply AC prediction if needed */
2422 if(dc_pred_dir
) { //left
2423 for(k
= 1; k
< 8; k
++)
2424 block
[k
<< 3] += ac_val
[k
];
2426 for(k
= 1; k
< 8; k
++)
2427 block
[k
] += ac_val
[k
+ 8];
2430 /* save AC coeffs for further prediction */
2431 for(k
= 1; k
< 8; k
++) {
2432 ac_val2
[k
] = block
[k
<< 3];
2433 ac_val2
[k
+ 8] = block
[k
];
2436 /* scale AC coeffs */
2437 for(k
= 1; k
< 64; k
++)
2441 block
[k
] += (block
[k
] < 0) ?
-v
->pq
: v
->pq
;
2444 if(s
->ac_pred
) i
= 63;
2450 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2453 scale
= v
->pq
* 2 + v
->halfpq
;
2454 memset(ac_val2
, 0, 16 * 2);
2455 if(dc_pred_dir
) {//left
2458 memcpy(ac_val2
, ac_val
, 8 * 2);
2460 ac_val
-= 16 * s
->block_wrap
[n
];
2462 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2465 /* apply AC prediction if needed */
2467 if(dc_pred_dir
) { //left
2468 for(k
= 1; k
< 8; k
++) {
2469 block
[k
<< 3] = ac_val
[k
] * scale
;
2470 if(!v
->pquantizer
&& block
[k
<< 3])
2471 block
[k
<< 3] += (block
[k
<< 3] < 0) ?
-v
->pq
: v
->pq
;
2474 for(k
= 1; k
< 8; k
++) {
2475 block
[k
] = ac_val
[k
+ 8] * scale
;
2476 if(!v
->pquantizer
&& block
[k
])
2477 block
[k
] += (block
[k
] < 0) ?
-v
->pq
: v
->pq
;
2483 s
->block_last_index
[n
] = i
;
2488 /** Decode intra block in intra frames - should be faster than decode_intra_block
2489 * @param v VC1Context
2490 * @param block block to decode
2491 * @param coded are AC coeffs present or not
2492 * @param codingset set of VLC to decode data
2494 static int vc1_decode_i_block_adv(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int codingset
, int mquant
)
2496 GetBitContext
*gb
= &v
->s
.gb
;
2497 MpegEncContext
*s
= &v
->s
;
2498 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2501 int16_t *ac_val
, *ac_val2
;
2503 int a_avail
= v
->a_avail
, c_avail
= v
->c_avail
;
2504 int use_pred
= s
->ac_pred
;
2507 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2509 /* Get DC differential */
2511 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2513 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2516 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2521 if (dcdiff
== 119 /* ESC index value */)
2523 /* TODO: Optimize */
2524 if (mquant
== 1) dcdiff
= get_bits(gb
, 10);
2525 else if (mquant
== 2) dcdiff
= get_bits(gb
, 9);
2526 else dcdiff
= get_bits(gb
, 8);
2531 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2532 else if (mquant
== 2)
2533 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2540 dcdiff
+= vc1_pred_dc(&v
->s
, v
->overlap
, mquant
, n
, v
->a_avail
, v
->c_avail
, &dc_val
, &dc_pred_dir
);
2543 /* Store the quantized DC coeff, used for prediction */
2545 block
[0] = dcdiff
* s
->y_dc_scale
;
2547 block
[0] = dcdiff
* s
->c_dc_scale
;
2556 /* check if AC is needed at all */
2557 if(!a_avail
&& !c_avail
) use_pred
= 0;
2558 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2561 scale
= mquant
* 2 + ((mquant
== v
->pq
) ? v
->halfpq
: 0);
2563 if(dc_pred_dir
) //left
2566 ac_val
-= 16 * s
->block_wrap
[n
];
2568 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2569 if(dc_pred_dir
&& c_avail
&& mb_pos
) q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2570 if(!dc_pred_dir
&& a_avail
&& mb_pos
>= s
->mb_stride
) q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2571 if(dc_pred_dir
&& n
==1) q2
= q1
;
2572 if(!dc_pred_dir
&& n
==2) q2
= q1
;
2576 int last
= 0, skip
, value
;
2577 const int8_t *zz_table
;
2582 zz_table
= ff_vc1_horizontal_zz
;
2584 zz_table
= ff_vc1_vertical_zz
;
2586 zz_table
= ff_vc1_normal_zz
;
2589 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2593 block
[zz_table
[i
++]] = value
;
2596 /* apply AC prediction if needed */
2598 /* scale predictors if needed*/
2600 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2601 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2603 if(dc_pred_dir
) { //left
2604 for(k
= 1; k
< 8; k
++)
2605 block
[k
<< 3] += (ac_val
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2607 for(k
= 1; k
< 8; k
++)
2608 block
[k
] += (ac_val
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2611 if(dc_pred_dir
) { //left
2612 for(k
= 1; k
< 8; k
++)
2613 block
[k
<< 3] += ac_val
[k
];
2615 for(k
= 1; k
< 8; k
++)
2616 block
[k
] += ac_val
[k
+ 8];
2620 /* save AC coeffs for further prediction */
2621 for(k
= 1; k
< 8; k
++) {
2622 ac_val2
[k
] = block
[k
<< 3];
2623 ac_val2
[k
+ 8] = block
[k
];
2626 /* scale AC coeffs */
2627 for(k
= 1; k
< 64; k
++)
2631 block
[k
] += (block
[k
] < 0) ?
-mquant
: mquant
;
2634 if(use_pred
) i
= 63;
2635 } else { // no AC coeffs
2638 memset(ac_val2
, 0, 16 * 2);
2639 if(dc_pred_dir
) {//left
2641 memcpy(ac_val2
, ac_val
, 8 * 2);
2643 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2644 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2645 for(k
= 1; k
< 8; k
++)
2646 ac_val2
[k
] = (ac_val2
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2651 memcpy(ac_val2
+ 8, ac_val
+ 8, 8 * 2);
2653 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2654 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2655 for(k
= 1; k
< 8; k
++)
2656 ac_val2
[k
+ 8] = (ac_val2
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2661 /* apply AC prediction if needed */
2663 if(dc_pred_dir
) { //left
2664 for(k
= 1; k
< 8; k
++) {
2665 block
[k
<< 3] = ac_val2
[k
] * scale
;
2666 if(!v
->pquantizer
&& block
[k
<< 3])
2667 block
[k
<< 3] += (block
[k
<< 3] < 0) ?
-mquant
: mquant
;
2670 for(k
= 1; k
< 8; k
++) {
2671 block
[k
] = ac_val2
[k
+ 8] * scale
;
2672 if(!v
->pquantizer
&& block
[k
])
2673 block
[k
] += (block
[k
] < 0) ?
-mquant
: mquant
;
2679 s
->block_last_index
[n
] = i
;
2684 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2685 * @param v VC1Context
2686 * @param block block to decode
2687 * @param coded are AC coeffs present or not
2688 * @param mquant block quantizer
2689 * @param codingset set of VLC to decode data
2691 static int vc1_decode_intra_block(VC1Context
*v
, DCTELEM block
[64], int n
, int coded
, int mquant
, int codingset
)
2693 GetBitContext
*gb
= &v
->s
.gb
;
2694 MpegEncContext
*s
= &v
->s
;
2695 int dc_pred_dir
= 0; /* Direction of the DC prediction used */
2698 int16_t *ac_val
, *ac_val2
;
2700 int mb_pos
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
;
2701 int a_avail
= v
->a_avail
, c_avail
= v
->c_avail
;
2702 int use_pred
= s
->ac_pred
;
2706 /* XXX: Guard against dumb values of mquant */
2707 mquant
= (mquant
< 1) ?
0 : ( (mquant
>31) ?
31 : mquant
);
2709 /* Set DC scale - y and c use the same */
2710 s
->y_dc_scale
= s
->y_dc_scale_table
[mquant
];
2711 s
->c_dc_scale
= s
->c_dc_scale_table
[mquant
];
2713 /* Get DC differential */
2715 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_luma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2717 dcdiff
= get_vlc2(&s
->gb
, ff_msmp4_dc_chroma_vlc
[s
->dc_table_index
].table
, DC_VLC_BITS
, 3);
2720 av_log(s
->avctx
, AV_LOG_ERROR
, "Illegal DC VLC\n");
2725 if (dcdiff
== 119 /* ESC index value */)
2727 /* TODO: Optimize */
2728 if (mquant
== 1) dcdiff
= get_bits(gb
, 10);
2729 else if (mquant
== 2) dcdiff
= get_bits(gb
, 9);
2730 else dcdiff
= get_bits(gb
, 8);
2735 dcdiff
= (dcdiff
<<2) + get_bits(gb
, 2) - 3;
2736 else if (mquant
== 2)
2737 dcdiff
= (dcdiff
<<1) + get_bits1(gb
) - 1;
2744 dcdiff
+= vc1_pred_dc(&v
->s
, v
->overlap
, mquant
, n
, a_avail
, c_avail
, &dc_val
, &dc_pred_dir
);
2747 /* Store the quantized DC coeff, used for prediction */
2750 block
[0] = dcdiff
* s
->y_dc_scale
;
2752 block
[0] = dcdiff
* s
->c_dc_scale
;
2761 /* check if AC is needed at all and adjust direction if needed */
2762 if(!a_avail
) dc_pred_dir
= 1;
2763 if(!c_avail
) dc_pred_dir
= 0;
2764 if(!a_avail
&& !c_avail
) use_pred
= 0;
2765 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
2768 scale
= mquant
* 2 + v
->halfpq
;
2770 if(dc_pred_dir
) //left
2773 ac_val
-= 16 * s
->block_wrap
[n
];
2775 q1
= s
->current_picture
.qscale_table
[mb_pos
];
2776 if(dc_pred_dir
&& c_avail
&& mb_pos
) q2
= s
->current_picture
.qscale_table
[mb_pos
- 1];
2777 if(!dc_pred_dir
&& a_avail
&& mb_pos
>= s
->mb_stride
) q2
= s
->current_picture
.qscale_table
[mb_pos
- s
->mb_stride
];
2778 if(dc_pred_dir
&& n
==1) q2
= q1
;
2779 if(!dc_pred_dir
&& n
==2) q2
= q1
;
2783 int last
= 0, skip
, value
;
2784 const int8_t *zz_table
;
2787 zz_table
= ff_vc1_simple_progressive_8x8_zz
;
2790 vc1_decode_ac_coeff(v
, &last
, &skip
, &value
, codingset
);
2794 block
[zz_table
[i
++]] = value
;
2797 /* apply AC prediction if needed */
2799 /* scale predictors if needed*/
2801 q1
= q1
* 2 + ((q1
== v
->pq
) ? v
->halfpq
: 0) - 1;
2802 q2
= q2
* 2 + ((q2
== v
->pq
) ? v
->halfpq
: 0) - 1;
2804 if(dc_pred_dir
) { //left
2805 for(k
= 1; k
< 8; k
++)
2806 block
[k
<< 3] += (ac_val
[k
] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2808 for(k
= 1; k
< 8; k
++)
2809 block
[k
] += (ac_val
[k
+ 8] * q2
* ff_vc1_dqscale
[q1
- 1] + 0x20000) >> 18;
2812 if(dc_pred_dir
) { //left
2813 for(k
= 1; k
< 8; k
++)
2814 block
[k
<< 3] += ac_val
[k
];
2816 for(k
= 1; k
< 8; k
++)
2817 block
[k
] += ac_val
[k
+ 8];
2821 /* save AC coeffs for further prediction */