Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
6148 | serge | 1 | /* |
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 |
||
5 | * |
||
6 | * This file is part of FFmpeg. |
||
7 | * |
||
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. |
||
12 | * |
||
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. |
||
17 | * |
||
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 |
||
21 | */ |
||
22 | |||
23 | #ifndef AVCODEC_VC1_H |
||
24 | #define AVCODEC_VC1_H |
||
25 | |||
26 | #include "avcodec.h" |
||
27 | #include "h264chroma.h" |
||
28 | #include "mpegvideo.h" |
||
29 | #include "intrax8.h" |
||
30 | #include "vc1dsp.h" |
||
31 | |||
32 | #define AC_VLC_BITS 9 |
||
33 | |||
34 | /** Markers used in VC-1 AP frame data */ |
||
35 | //@{ |
||
36 | enum VC1Code { |
||
37 | VC1_CODE_RES0 = 0x00000100, |
||
38 | VC1_CODE_ENDOFSEQ = 0x0000010A, |
||
39 | VC1_CODE_SLICE, |
||
40 | VC1_CODE_FIELD, |
||
41 | VC1_CODE_FRAME, |
||
42 | VC1_CODE_ENTRYPOINT, |
||
43 | VC1_CODE_SEQHDR, |
||
44 | }; |
||
45 | //@} |
||
46 | |||
47 | #define IS_MARKER(x) (((x) & ~0xFF) == VC1_CODE_RES0) |
||
48 | |||
49 | /** Available Profiles */ |
||
50 | //@{ |
||
51 | enum Profile { |
||
52 | PROFILE_SIMPLE, |
||
53 | PROFILE_MAIN, |
||
54 | PROFILE_COMPLEX, ///< TODO: WMV9 specific |
||
55 | PROFILE_ADVANCED |
||
56 | }; |
||
57 | //@} |
||
58 | |||
59 | /** Sequence quantizer mode */ |
||
60 | //@{ |
||
61 | enum QuantMode { |
||
62 | QUANT_FRAME_IMPLICIT, ///< Implicitly specified at frame level |
||
63 | QUANT_FRAME_EXPLICIT, ///< Explicitly specified at frame level |
||
64 | QUANT_NON_UNIFORM, ///< Non-uniform quant used for all frames |
||
65 | QUANT_UNIFORM ///< Uniform quant used for all frames |
||
66 | }; |
||
67 | //@} |
||
68 | |||
69 | /** Where quant can be changed */ |
||
70 | //@{ |
||
71 | enum DQProfile { |
||
72 | DQPROFILE_FOUR_EDGES, |
||
73 | DQPROFILE_DOUBLE_EDGES, |
||
74 | DQPROFILE_SINGLE_EDGE, |
||
75 | DQPROFILE_ALL_MBS |
||
76 | }; |
||
77 | //@} |
||
78 | |||
79 | /** @name Where quant can be changed |
||
80 | */ |
||
81 | //@{ |
||
82 | enum DQSingleEdge { |
||
83 | DQSINGLE_BEDGE_LEFT, |
||
84 | DQSINGLE_BEDGE_TOP, |
||
85 | DQSINGLE_BEDGE_RIGHT, |
||
86 | DQSINGLE_BEDGE_BOTTOM |
||
87 | }; |
||
88 | //@} |
||
89 | |||
90 | /** Which pair of edges is quantized with ALTPQUANT */ |
||
91 | //@{ |
||
92 | enum DQDoubleEdge { |
||
93 | DQDOUBLE_BEDGE_TOPLEFT, |
||
94 | DQDOUBLE_BEDGE_TOPRIGHT, |
||
95 | DQDOUBLE_BEDGE_BOTTOMRIGHT, |
||
96 | DQDOUBLE_BEDGE_BOTTOMLEFT |
||
97 | }; |
||
98 | //@} |
||
99 | |||
100 | /** MV modes for P frames */ |
||
101 | //@{ |
||
102 | enum MVModes { |
||
103 | MV_PMODE_1MV_HPEL_BILIN, |
||
104 | MV_PMODE_1MV, |
||
105 | MV_PMODE_1MV_HPEL, |
||
106 | MV_PMODE_MIXED_MV, |
||
107 | MV_PMODE_INTENSITY_COMP |
||
108 | }; |
||
109 | //@} |
||
110 | |||
111 | /** MBMODE for interlaced frame P-picture */ |
||
112 | //@{ |
||
113 | enum MBModesIntfr { |
||
114 | MV_PMODE_INTFR_1MV, |
||
115 | MV_PMODE_INTFR_2MV_FIELD, |
||
116 | MV_PMODE_INTFR_2MV, |
||
117 | MV_PMODE_INTFR_4MV_FIELD, |
||
118 | MV_PMODE_INTFR_4MV, |
||
119 | MV_PMODE_INTFR_INTRA, |
||
120 | }; |
||
121 | //@} |
||
122 | |||
123 | /** @name MV types for B frames */ |
||
124 | //@{ |
||
125 | enum BMVTypes { |
||
126 | BMV_TYPE_BACKWARD, |
||
127 | BMV_TYPE_FORWARD, |
||
128 | BMV_TYPE_INTERPOLATED, |
||
129 | BMV_TYPE_DIRECT |
||
130 | }; |
||
131 | //@} |
||
132 | |||
133 | /** @name Block types for P/B frames */ |
||
134 | //@{ |
||
135 | enum TransformTypes { |
||
136 | TT_8X8, |
||
137 | TT_8X4_BOTTOM, |
||
138 | TT_8X4_TOP, |
||
139 | TT_8X4, // both halves |
||
140 | TT_4X8_RIGHT, |
||
141 | TT_4X8_LEFT, |
||
142 | TT_4X8, // both halves |
||
143 | TT_4X4 |
||
144 | }; |
||
145 | //@} |
||
146 | |||
147 | enum CodingSet { |
||
148 | CS_HIGH_MOT_INTRA = 0, |
||
149 | CS_HIGH_MOT_INTER, |
||
150 | CS_LOW_MOT_INTRA, |
||
151 | CS_LOW_MOT_INTER, |
||
152 | CS_MID_RATE_INTRA, |
||
153 | CS_MID_RATE_INTER, |
||
154 | CS_HIGH_RATE_INTRA, |
||
155 | CS_HIGH_RATE_INTER |
||
156 | }; |
||
157 | |||
158 | /** @name Overlap conditions for Advanced Profile */ |
||
159 | //@{ |
||
160 | enum COTypes { |
||
161 | CONDOVER_NONE = 0, |
||
162 | CONDOVER_ALL, |
||
163 | CONDOVER_SELECT |
||
164 | }; |
||
165 | //@} |
||
166 | |||
167 | /** |
||
168 | * FCM Frame Coding Mode |
||
169 | * @note some content might be marked interlaced |
||
170 | * but have fcm set to 0 as well (e.g. HD-DVD) |
||
171 | */ |
||
172 | enum FrameCodingMode { |
||
173 | PROGRESSIVE = 0, ///< in the bitstream is reported as 00b |
||
174 | ILACE_FRAME, ///< in the bitstream is reported as 10b |
||
175 | ILACE_FIELD ///< in the bitstream is reported as 11b |
||
176 | }; |
||
177 | |||
178 | /** The VC1 Context |
||
179 | * @todo Change size wherever another size is more efficient |
||
180 | * Many members are only used for Advanced Profile |
||
181 | */ |
||
182 | typedef struct VC1Context{ |
||
183 | MpegEncContext s; |
||
184 | IntraX8Context x8; |
||
185 | H264ChromaContext h264chroma; |
||
186 | VC1DSPContext vc1dsp; |
||
187 | |||
188 | int bits; |
||
189 | |||
190 | /** Simple/Main Profile sequence header */ |
||
191 | //@{ |
||
192 | int res_sprite; ///< reserved, sprite mode |
||
193 | int res_y411; ///< reserved, old interlaced mode |
||
194 | int res_x8; ///< reserved |
||
195 | int multires; ///< frame-level RESPIC syntax element present |
||
196 | int res_fasttx; ///< reserved, always 1 |
||
197 | int res_transtab; ///< reserved, always 0 |
||
198 | int rangered; ///< RANGEREDFRM (range reduction) syntax element present |
||
199 | ///< at frame level |
||
200 | int res_rtm_flag; ///< reserved, set to 1 |
||
201 | int reserved; ///< reserved |
||
202 | //@} |
||
203 | |||
204 | /** Advanced Profile */ |
||
205 | //@{ |
||
206 | int level; ///< 3bits, for Advanced/Simple Profile, provided by TS layer |
||
207 | int chromaformat; ///< 2bits, 2=4:2:0, only defined |
||
208 | int postprocflag; ///< Per-frame processing suggestion flag present |
||
209 | int broadcast; ///< TFF/RFF present |
||
210 | int interlace; ///< Progressive/interlaced (RPTFTM syntax element) |
||
211 | int tfcntrflag; ///< TFCNTR present |
||
212 | int panscanflag; ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present |
||
213 | int refdist_flag; ///< REFDIST syntax element present in II, IP, PI or PP field picture headers |
||
214 | int extended_dmv; ///< Additional extended dmv range at P/B frame-level |
||
215 | int hrd_param_flag; ///< Presence of Hypothetical Reference |
||
216 | ///< Decoder parameters |
||
217 | int psf; ///< Progressive Segmented Frame |
||
218 | //@} |
||
219 | |||
220 | /** Sequence header data for all Profiles |
||
221 | * TODO: choose between ints, uint8_ts and monobit flags |
||
222 | */ |
||
223 | //@{ |
||
224 | int profile; ///< 2bits, Profile |
||
225 | int frmrtq_postproc; ///< 3bits, |
||
226 | int bitrtq_postproc; ///< 5bits, quantized framerate-based postprocessing strength |
||
227 | int max_coded_width, max_coded_height; |
||
228 | int fastuvmc; ///< Rounding of qpel vector to hpel ? (not in Simple) |
||
229 | int extended_mv; ///< Ext MV in P/B (not in Simple) |
||
230 | int dquant; ///< How qscale varies with MBs, 2bits (not in Simple) |
||
231 | int vstransform; ///< variable-size [48]x[48] transform type + info |
||
232 | int overlap; ///< overlapped transforms in use |
||
233 | int quantizer_mode; ///< 2bits, quantizer mode used for sequence, see QUANT_* |
||
234 | int finterpflag; ///< INTERPFRM present |
||
235 | //@} |
||
236 | |||
237 | /** Frame decoding info for all profiles */ |
||
238 | //@{ |
||
239 | uint8_t mv_mode; ///< MV coding monde |
||
240 | uint8_t mv_mode2; ///< Secondary MV coding mode (B frames) |
||
241 | int k_x; ///< Number of bits for MVs (depends on MV range) |
||
242 | int k_y; ///< Number of bits for MVs (depends on MV range) |
||
243 | int range_x, range_y; ///< MV range |
||
244 | uint8_t pq, altpq; ///< Current/alternate frame quantizer scale |
||
245 | uint8_t zz_8x8[4][64]; ///< Zigzag table for TT_8x8, permuted for IDCT |
||
246 | int left_blk_sh, top_blk_sh; ///< Either 3 or 0, positions of l/t in blk[] |
||
247 | const uint8_t* zz_8x4; ///< Zigzag scan table for TT_8x4 coding mode |
||
248 | const uint8_t* zz_4x8; ///< Zigzag scan table for TT_4x8 coding mode |
||
249 | /** pquant parameters */ |
||
250 | //@{ |
||
251 | uint8_t dquantfrm; |
||
252 | uint8_t dqprofile; |
||
253 | uint8_t dqsbedge; |
||
254 | uint8_t dqbilevel; |
||
255 | //@} |
||
256 | /** AC coding set indexes |
||
257 | * @see 8.1.1.10, p(1)10 |
||
258 | */ |
||
259 | //@{ |
||
260 | int c_ac_table_index; ///< Chroma index from ACFRM element |
||
261 | int y_ac_table_index; ///< Luma index from AC2FRM element |
||
262 | //@} |
||
263 | int ttfrm; ///< Transform type info present at frame level |
||
264 | uint8_t ttmbf; ///< Transform type flag |
||
265 | int *ttblk_base, *ttblk; ///< Transform type at the block level |
||
266 | int codingset; ///< index of current table set from 11.8 to use for luma block decoding |
||
267 | int codingset2; ///< index of current table set from 11.8 to use for chroma block decoding |
||
268 | int pqindex; ///< raw pqindex used in coding set selection |
||
269 | int a_avail, c_avail; |
||
270 | uint8_t *mb_type_base, *mb_type[3]; |
||
271 | |||
272 | |||
273 | /** Luma compensation parameters */ |
||
274 | //@{ |
||
275 | uint8_t lumscale; |
||
276 | uint8_t lumshift; |
||
277 | //@} |
||
278 | int16_t bfraction; ///< Relative position % anchors=> how to scale MVs |
||
279 | uint8_t halfpq; ///< Uniform quant over image and qp+.5 |
||
280 | uint8_t respic; ///< Frame-level flag for resized images |
||
281 | int buffer_fullness; ///< HRD info |
||
282 | /** Ranges: |
||
283 | * -# 0 -> [-64n 63.f] x [-32, 31.f] |
||
284 | * -# 1 -> [-128, 127.f] x [-64, 63.f] |
||
285 | * -# 2 -> [-512, 511.f] x [-128, 127.f] |
||
286 | * -# 3 -> [-1024, 1023.f] x [-256, 255.f] |
||
287 | */ |
||
288 | uint8_t mvrange; ///< Extended MV range flag |
||
289 | uint8_t pquantizer; ///< Uniform (over sequence) quantizer in use |
||
290 | VLC *cbpcy_vlc; ///< CBPCY VLC table |
||
291 | int tt_index; ///< Index for Transform Type tables (to decode TTMB) |
||
292 | uint8_t* mv_type_mb_plane; ///< bitplane for mv_type == (4MV) |
||
293 | uint8_t* direct_mb_plane; ///< bitplane for "direct" MBs |
||
294 | uint8_t* forward_mb_plane; ///< bitplane for "forward" MBs |
||
295 | int mv_type_is_raw; ///< mv type mb plane is not coded |
||
296 | int dmb_is_raw; ///< direct mb plane is raw |
||
297 | int fmb_is_raw; ///< forward mb plane is raw |
||
298 | int skip_is_raw; ///< skip mb plane is not coded |
||
299 | uint8_t last_luty[2][256], last_lutuv[2][256]; ///< lookup tables used for intensity compensation |
||
300 | uint8_t aux_luty[2][256], aux_lutuv[2][256]; ///< lookup tables used for intensity compensation |
||
301 | uint8_t next_luty[2][256], next_lutuv[2][256]; ///< lookup tables used for intensity compensation |
||
302 | uint8_t (*curr_luty)[256] ,(*curr_lutuv)[256]; |
||
303 | int last_use_ic, curr_use_ic, next_use_ic, aux_use_ic; |
||
304 | int rnd; ///< rounding control |
||
305 | |||
306 | /** Frame decoding info for S/M profiles only */ |
||
307 | //@{ |
||
308 | uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128) |
||
309 | uint8_t interpfrm; |
||
310 | //@} |
||
311 | |||
312 | /** Frame decoding info for Advanced profile */ |
||
313 | //@{ |
||
314 | enum FrameCodingMode fcm; |
||
315 | uint8_t numpanscanwin; |
||
316 | uint8_t tfcntr; |
||
317 | uint8_t rptfrm, tff, rff; |
||
318 | uint16_t topleftx; |
||
319 | uint16_t toplefty; |
||
320 | uint16_t bottomrightx; |
||
321 | uint16_t bottomrighty; |
||
322 | uint8_t uvsamp; |
||
323 | uint8_t postproc; |
||
324 | int hrd_num_leaky_buckets; |
||
325 | uint8_t bit_rate_exponent; |
||
326 | uint8_t buffer_size_exponent; |
||
327 | uint8_t* acpred_plane; ///< AC prediction flags bitplane |
||
328 | int acpred_is_raw; |
||
329 | uint8_t* over_flags_plane; ///< Overflags bitplane |
||
330 | int overflg_is_raw; |
||
331 | uint8_t condover; |
||
332 | uint16_t *hrd_rate, *hrd_buffer; |
||
333 | uint8_t *hrd_fullness; |
||
334 | uint8_t range_mapy_flag; |
||
335 | uint8_t range_mapuv_flag; |
||
336 | uint8_t range_mapy; |
||
337 | uint8_t range_mapuv; |
||
338 | //@} |
||
339 | |||
340 | /** Frame decoding info for interlaced picture */ |
||
341 | uint8_t dmvrange; ///< Extended differential MV range flag |
||
342 | int fourmvswitch; |
||
343 | int intcomp; |
||
344 | uint8_t lumscale2; ///< for interlaced field P picture |
||
345 | uint8_t lumshift2; |
||
346 | VLC* mbmode_vlc; |
||
347 | VLC* imv_vlc; |
||
348 | VLC* twomvbp_vlc; |
||
349 | VLC* fourmvbp_vlc; |
||
350 | uint8_t twomvbp; |
||
351 | uint8_t fourmvbp; |
||
352 | uint8_t* fieldtx_plane; |
||
353 | int fieldtx_is_raw; |
||
354 | uint8_t zzi_8x8[64]; |
||
355 | uint8_t *blk_mv_type_base, *blk_mv_type; ///< 0: frame MV, 1: field MV (interlaced frame) |
||
356 | uint8_t *mv_f_base, *mv_f[2]; ///< 0: MV obtained from same field, 1: opposite field |
||
357 | uint8_t *mv_f_next_base, *mv_f_next[2]; |
||
358 | int field_mode; ///< 1 for interlaced field pictures |
||
359 | int fptype; |
||
360 | int second_field; |
||
361 | int refdist; ///< distance of the current picture from reference |
||
362 | int numref; ///< number of past field pictures used as reference |
||
363 | // 0 corresponds to 1 and 1 corresponds to 2 references |
||
364 | int reffield; ///< if numref = 0 (1 reference) then reffield decides which |
||
365 | // field to use among the two fields from previous frame |
||
366 | int intcompfield; ///< which of the two fields to be intensity compensated |
||
367 | // 0: both fields, 1: bottom field, 2: top field |
||
368 | int cur_field_type; ///< 0: top, 1: bottom |
||
369 | int ref_field_type[2]; ///< forward and backward reference field type (top or bottom) |
||
370 | int blocks_off, mb_off; |
||
371 | int qs_last; ///< if qpel has been used in the previous (tr.) picture |
||
372 | int bmvtype; |
||
373 | int frfd, brfd; ///< reference frame distance (forward or backward) |
||
374 | int first_pic_header_flag; |
||
375 | int pic_header_flag; |
||
376 | |||
377 | /** Frame decoding info for sprite modes */ |
||
378 | //@{ |
||
379 | int new_sprite; |
||
380 | int two_sprites; |
||
381 | AVFrame sprite_output_frame; |
||
382 | int output_width, output_height, sprite_width, sprite_height; |
||
383 | uint8_t* sr_rows[2][2]; ///< Sprite resizer line cache |
||
384 | //@} |
||
385 | |||
386 | int p_frame_skipped; |
||
387 | int bi_type; |
||
388 | int x8_type; |
||
389 | |||
390 | int16_t (*block)[6][64]; |
||
391 | int n_allocated_blks, cur_blk_idx, left_blk_idx, topleft_blk_idx, top_blk_idx; |
||
392 | uint32_t *cbp_base, *cbp; |
||
393 | uint8_t *is_intra_base, *is_intra; |
||
394 | int16_t (*luma_mv_base)[2], (*luma_mv)[2]; |
||
395 | uint8_t bfraction_lut_index; ///< Index for BFRACTION value (see Table 40, reproduced into ff_vc1_bfraction_lut[]) |
||
396 | uint8_t broken_link; ///< Broken link flag (BROKEN_LINK syntax element) |
||
397 | uint8_t closed_entry; ///< Closed entry point flag (CLOSED_ENTRY syntax element) |
||
398 | |||
399 | int end_mb_x; ///< Horizontal macroblock limit (used only by mss2) |
||
400 | |||
401 | int parse_only; ///< Context is used within parser |
||
402 | } VC1Context; |
||
403 | |||
404 | /** Find VC-1 marker in buffer |
||
405 | * @return position where next marker starts or end of buffer if no marker found |
||
406 | */ |
||
407 | static av_always_inline const uint8_t* find_next_marker(const uint8_t *src, const uint8_t *end) |
||
408 | { |
||
409 | uint32_t mrk = 0xFFFFFFFF; |
||
410 | |||
411 | if (end-src < 4) |
||
412 | return end; |
||
413 | while (src < end) { |
||
414 | mrk = (mrk << 8) | *src++; |
||
415 | if (IS_MARKER(mrk)) |
||
416 | return src - 4; |
||
417 | } |
||
418 | return end; |
||
419 | } |
||
420 | |||
421 | static av_always_inline int vc1_unescape_buffer(const uint8_t *src, int size, uint8_t *dst) |
||
422 | { |
||
423 | int dsize = 0, i; |
||
424 | |||
425 | if (size < 4) { |
||
426 | for (dsize = 0; dsize < size; dsize++) |
||
427 | *dst++ = *src++; |
||
428 | return size; |
||
429 | } |
||
430 | for (i = 0; i < size; i++, src++) { |
||
431 | if (src[0] == 3 && i >= 2 && !src[-1] && !src[-2] && i < size-1 && src[1] < 4) { |
||
432 | dst[dsize++] = src[1]; |
||
433 | src++; |
||
434 | i++; |
||
435 | } else |
||
436 | dst[dsize++] = *src; |
||
437 | } |
||
438 | return dsize; |
||
439 | } |
||
440 | |||
441 | /** |
||
442 | * Decode Simple/Main Profiles sequence header |
||
443 | * @see Figure 7-8, p16-17 |
||
444 | * @param avctx Codec context |
||
445 | * @param gb GetBit context initialized from Codec context extra_data |
||
446 | * @return Status |
||
447 | */ |
||
448 | int ff_vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb); |
||
449 | |||
450 | int ff_vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *gb); |
||
451 | |||
452 | int ff_vc1_parse_frame_header (VC1Context *v, GetBitContext *gb); |
||
453 | int ff_vc1_parse_frame_header_adv(VC1Context *v, GetBitContext *gb); |
||
454 | int ff_vc1_init_common(VC1Context *v); |
||
455 | |||
456 | int ff_vc1_decode_init_alloc_tables(VC1Context *v); |
||
457 | void ff_vc1_init_transposed_scantables(VC1Context *v); |
||
458 | int ff_vc1_decode_end(AVCodecContext *avctx); |
||
459 | void ff_vc1_decode_blocks(VC1Context *v); |
||
460 | |||
461 | #endif /* AVCODEC_VC1_H */>>>>>><>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> |