?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
make mpa_decode_header() 10 times faster
[FFMpeg-mirror/ordered_chapters.git] / libavcodec / vc1.c
blobe61c8011b77ea72e498d6ec256e5ed00f136f416
1 /*
2 * VC-1 and WMV3 decoder
3 * Copyright (c) 2006 Konstantin Shishkov
4 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 */
21
22 /**
23 * @file vc1.c
24 * VC-1 and WMV3 decoder
25 *
26 */
27 #include "common.h"
28 #include "dsputil.h"
29 #include "avcodec.h"
30 #include "mpegvideo.h"
31 #include "vc1data.h"
32 #include "vc1acdata.h"
33
34 #undef NDEBUG
35 #include <assert.h>
36
37 extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];
38 extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];
39 extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];
40 #define MB_INTRA_VLC_BITS 9
41 extern VLC ff_msmp4_mb_i_vlc;
42 extern const uint16_t ff_msmp4_mb_i_table[64][2];
43 #define DC_VLC_BITS 9
44 #define AC_VLC_BITS 9
45 static const uint16_t table_mb_intra[64][2];
46
47
48 /** Available Profiles */
49 //@{
50 enum Profile {
51 PROFILE_SIMPLE,
52 PROFILE_MAIN,
53 PROFILE_COMPLEX, ///< TODO: WMV9 specific
54 PROFILE_ADVANCED
55 };
56 //@}
57
58 /** Sequence quantizer mode */
59 //@{
60 enum QuantMode {
61 QUANT_FRAME_IMPLICIT, ///< Implicitly specified at frame level
62 QUANT_FRAME_EXPLICIT, ///< Explicitly specified at frame level
63 QUANT_NON_UNIFORM, ///< Non-uniform quant used for all frames
64 QUANT_UNIFORM ///< Uniform quant used for all frames
65 };
66 //@}
67
68 /** Where quant can be changed */
69 //@{
70 enum DQProfile {
71 DQPROFILE_FOUR_EDGES,
72 DQPROFILE_DOUBLE_EDGES,
73 DQPROFILE_SINGLE_EDGE,
74 DQPROFILE_ALL_MBS
75 };
76 //@}
77
78 /** @name Where quant can be changed
79 */
80 //@{
81 enum DQSingleEdge {
82 DQSINGLE_BEDGE_LEFT,
83 DQSINGLE_BEDGE_TOP,
84 DQSINGLE_BEDGE_RIGHT,
85 DQSINGLE_BEDGE_BOTTOM
86 };
87 //@}
88
89 /** Which pair of edges is quantized with ALTPQUANT */
90 //@{
91 enum DQDoubleEdge {
92 DQDOUBLE_BEDGE_TOPLEFT,
93 DQDOUBLE_BEDGE_TOPRIGHT,
94 DQDOUBLE_BEDGE_BOTTOMRIGHT,
95 DQDOUBLE_BEDGE_BOTTOMLEFT
96 };
97 //@}
98
99 /** MV modes for P frames */
100 //@{
101 enum MVModes {
102 MV_PMODE_1MV_HPEL_BILIN,
103 MV_PMODE_1MV,
104 MV_PMODE_1MV_HPEL,
105 MV_PMODE_MIXED_MV,
106 MV_PMODE_INTENSITY_COMP
107 };
108 //@}
109
110 /** @name MV types for B frames */
111 //@{
112 enum BMVTypes {
113 BMV_TYPE_BACKWARD,
114 BMV_TYPE_FORWARD,
115 BMV_TYPE_INTERPOLATED
116 };
117 //@}
118
119 /** @name Block types for P/B frames */
120 //@{
121 enum TransformTypes {
122 TT_8X8,
123 TT_8X4_BOTTOM,
124 TT_8X4_TOP,
125 TT_8X4, //Both halves
126 TT_4X8_RIGHT,
127 TT_4X8_LEFT,
128 TT_4X8, //Both halves
129 TT_4X4
130 };
131 //@}
132
133 /** Table for conversion between TTBLK and TTMB */
134 static const int ttblk_to_tt[3][8] = {
135 { TT_8X4, TT_4X8, TT_8X8, TT_4X4, TT_8X4_TOP, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT },
136 { TT_8X8, TT_4X8_RIGHT, TT_4X8_LEFT, TT_4X4, TT_8X4, TT_4X8, TT_8X4_BOTTOM, TT_8X4_TOP },
137 { TT_8X8, TT_4X8, TT_4X4, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT, TT_8X4, TT_8X4_TOP }
138 };
139
140 static const int ttfrm_to_tt[4] = { TT_8X8, TT_8X4, TT_4X8, TT_4X4 };
141
142 /** MV P mode - the 5th element is only used for mode 1 */
143 static const uint8_t mv_pmode_table[2][5] = {
144 { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV },
145 { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN }
146 };
147 static const uint8_t mv_pmode_table2[2][4] = {
148 { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV },
149 { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN }
150 };
151
152 /** One more frame type */
153 #define BI_TYPE 7
154
155 static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
156 fps_dr[2] = { 1000, 1001 };
157 static const uint8_t pquant_table[3][32] = {
158 { /* Implicit quantizer */
159 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 7, 8, 9, 10, 11, 12,
160 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
161 },
162 { /* Explicit quantizer, pquantizer uniform */
163 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
164 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
165 },
166 { /* Explicit quantizer, pquantizer non-uniform */
167 0, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
168 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
169 }
170 };
171
172 /** @name VC-1 VLC tables and defines
173 * @todo TODO move this into the context
174 */
175 //@{
176 #define VC1_BFRACTION_VLC_BITS 7
177 static VLC vc1_bfraction_vlc;
178 #define VC1_IMODE_VLC_BITS 4
179 static VLC vc1_imode_vlc;
180 #define VC1_NORM2_VLC_BITS 3
181 static VLC vc1_norm2_vlc;
182 #define VC1_NORM6_VLC_BITS 9
183 static VLC vc1_norm6_vlc;
184 /* Could be optimized, one table only needs 8 bits */
185 #define VC1_TTMB_VLC_BITS 9 //12
186 static VLC vc1_ttmb_vlc[3];
187 #define VC1_MV_DIFF_VLC_BITS 9 //15
188 static VLC vc1_mv_diff_vlc[4];
189 #define VC1_CBPCY_P_VLC_BITS 9 //14
190 static VLC vc1_cbpcy_p_vlc[4];
191 #define VC1_4MV_BLOCK_PATTERN_VLC_BITS 6
192 static VLC vc1_4mv_block_pattern_vlc[4];
193 #define VC1_TTBLK_VLC_BITS 5
194 static VLC vc1_ttblk_vlc[3];
195 #define VC1_SUBBLKPAT_VLC_BITS 6
196 static VLC vc1_subblkpat_vlc[3];
197
198 static VLC vc1_ac_coeff_table[8];
199 //@}
200
201 enum CodingSet {
202 CS_HIGH_MOT_INTRA = 0,
203 CS_HIGH_MOT_INTER,
204 CS_LOW_MOT_INTRA,
205 CS_LOW_MOT_INTER,
206 CS_MID_RATE_INTRA,
207 CS_MID_RATE_INTER,
208 CS_HIGH_RATE_INTRA,
209 CS_HIGH_RATE_INTER
210 };
211
212 /** The VC1 Context
213 * @fixme Change size wherever another size is more efficient
214 * Many members are only used for Advanced Profile
215 */
216 typedef struct VC1Context{
217 MpegEncContext s;
218
219 int bits;
220
221 /** Simple/Main Profile sequence header */
222 //@{
223 int res_sm; ///< reserved, 2b
224 int res_x8; ///< reserved
225 int multires; ///< frame-level RESPIC syntax element present
226 int res_fasttx; ///< reserved, always 1
227 int res_transtab; ///< reserved, always 0
228 int rangered; ///< RANGEREDFRM (range reduction) syntax element present
229 ///< at frame level
230 int res_rtm_flag; ///< reserved, set to 1
231 int reserved; ///< reserved
232 //@}
233
234 /** Advanced Profile */
235 //@{
236 int level; ///< 3bits, for Advanced/Simple Profile, provided by TS layer
237 int chromaformat; ///< 2bits, 2=4:2:0, only defined
238 int postprocflag; ///< Per-frame processing suggestion flag present
239 int broadcast; ///< TFF/RFF present
240 int interlace; ///< Progressive/interlaced (RPTFTM syntax element)
241 int tfcntrflag; ///< TFCNTR present
242 int panscanflag; ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
243 int extended_dmv; ///< Additional extended dmv range at P/B frame-level
244 int color_prim; ///< 8bits, chroma coordinates of the color primaries
245 int transfer_char; ///< 8bits, Opto-electronic transfer characteristics
246 int matrix_coef; ///< 8bits, Color primaries->YCbCr transform matrix
247 int hrd_param_flag; ///< Presence of Hypothetical Reference
248 ///< Decoder parameters
249 //@}
250
251 /** Sequence header data for all Profiles
252 * TODO: choose between ints, uint8_ts and monobit flags
253 */
254 //@{
255 int profile; ///< 2bits, Profile
256 int frmrtq_postproc; ///< 3bits,
257 int bitrtq_postproc; ///< 5bits, quantized framerate-based postprocessing strength
258 int fastuvmc; ///< Rounding of qpel vector to hpel ? (not in Simple)
259 int extended_mv; ///< Ext MV in P/B (not in Simple)
260 int dquant; ///< How qscale varies with MBs, 2bits (not in Simple)
261 int vstransform; ///< variable-size [48]x[48] transform type + info
262 int overlap; ///< overlapped transforms in use
263 int quantizer_mode; ///< 2bits, quantizer mode used for sequence, see QUANT_*
264 int finterpflag; ///< INTERPFRM present
265 //@}
266
267 /** Frame decoding info for all profiles */
268 //@{
269 uint8_t mv_mode; ///< MV coding monde
270 uint8_t mv_mode2; ///< Secondary MV coding mode (B frames)
271 int k_x; ///< Number of bits for MVs (depends on MV range)
272 int k_y; ///< Number of bits for MVs (depends on MV range)
273 int range_x, range_y; ///< MV range
274 uint8_t pq, altpq; ///< Current/alternate frame quantizer scale
275 /** pquant parameters */
276 //@{
277 uint8_t dquantfrm;
278 uint8_t dqprofile;
279 uint8_t dqsbedge;
280 uint8_t dqbilevel;
281 //@}
282 /** AC coding set indexes
283 * @see 8.1.1.10, p(1)10
284 */
285 //@{
286 int c_ac_table_index; ///< Chroma index from ACFRM element
287 int y_ac_table_index; ///< Luma index from AC2FRM element
288 //@}
289 int ttfrm; ///< Transform type info present at frame level
290 uint8_t ttmbf; ///< Transform type flag
291 uint8_t ttblk4x4; ///< Value of ttblk which indicates a 4x4 transform
292 int codingset; ///< index of current table set from 11.8 to use for luma block decoding
293 int codingset2; ///< index of current table set from 11.8 to use for chroma block decoding
294 int pqindex; ///< raw pqindex used in coding set selection
295 int a_avail, c_avail;
296 uint8_t *mb_type_base, *mb_type[3];
297
298
299 /** Luma compensation parameters */
300 //@{
301 uint8_t lumscale;
302 uint8_t lumshift;
303 //@}
304 int16_t bfraction; ///< Relative position % anchors=> how to scale MVs
305 uint8_t halfpq; ///< Uniform quant over image and qp+.5
306 uint8_t respic; ///< Frame-level flag for resized images
307 int buffer_fullness; ///< HRD info
308 /** Ranges:
309 * -# 0 -> [-64n 63.f] x [-32, 31.f]
310 * -# 1 -> [-128, 127.f] x [-64, 63.f]
311 * -# 2 -> [-512, 511.f] x [-128, 127.f]
312 * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
313 */
314 uint8_t mvrange;
315 uint8_t pquantizer; ///< Uniform (over sequence) quantizer in use
316 VLC *cbpcy_vlc; ///< CBPCY VLC table
317 int tt_index; ///< Index for Transform Type tables
318 uint8_t* mv_type_mb_plane; ///< bitplane for mv_type == (4MV)
319 uint8_t* direct_mb_plane; ///< bitplane for "direct" MBs
320 int mv_type_is_raw; ///< mv type mb plane is not coded
321 int dmb_is_raw; ///< direct mb plane is raw
322 int skip_is_raw; ///< skip mb plane is not coded
323 uint8_t luty[256], lutuv[256]; // lookup tables used for intensity compensation
324 int rnd; ///< rounding control
325
326 /** Frame decoding info for S/M profiles only */
327 //@{
328 uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
329 uint8_t interpfrm;
330 //@}
331
332 /** Frame decoding info for Advanced profile */
333 //@{
334 uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
335 uint8_t numpanscanwin;
336 uint8_t tfcntr;
337 uint8_t rptfrm, tff, rff;
338 uint16_t topleftx;
339 uint16_t toplefty;
340 uint16_t bottomrightx;
341 uint16_t bottomrighty;
342 uint8_t uvsamp;
343 uint8_t postproc;
344 int hrd_num_leaky_buckets;
345 uint8_t bit_rate_exponent;
346 uint8_t buffer_size_exponent;
347 // BitPlane ac_pred_plane; ///< AC prediction flags bitplane
348 // BitPlane over_flags_plane; ///< Overflags bitplane
349 uint8_t condover;
350 uint16_t *hrd_rate, *hrd_buffer;
351 uint8_t *hrd_fullness;
352 uint8_t range_mapy_flag;
353 uint8_t range_mapuv_flag;
354 uint8_t range_mapy;
355 uint8_t range_mapuv;
356 //@}
357 } VC1Context;
358
359 /**
360 * Get unary code of limited length
361 * @fixme FIXME Slow and ugly
362 * @param gb GetBitContext
363 * @param[in] stop The bitstop value (unary code of 1's or 0's)
364 * @param[in] len Maximum length
365 * @return Unary length/index
366 */
367 static int get_prefix(GetBitContext *gb, int stop, int len)
368 {
369 #if 1
370 int i;
371
372 for(i = 0; i < len && get_bits1(gb) != stop; i++);
373 return i;
374 /* int i = 0, tmp = !stop;
375
376 while (i != len && tmp != stop)
377 {
378 tmp = get_bits(gb, 1);
379 i++;
380 }
381 if (i == len && tmp != stop) return len+1;
382 return i;*/
383 #else
384 unsigned int buf;
385 int log;
386
387 OPEN_READER(re, gb);
388 UPDATE_CACHE(re, gb);
389 buf=GET_CACHE(re, gb); //Still not sure
390 if (stop) buf = ~buf;
391
392 log= av_log2(-buf); //FIXME: -?
393 if (log < limit){
394 LAST_SKIP_BITS(re, gb, log+1);
395 CLOSE_READER(re, gb);
396 return log;
397 }
398
399 LAST_SKIP_BITS(re, gb, limit);
400 CLOSE_READER(re, gb);
401 return limit;
402 #endif
403 }
404
405 static inline int decode210(GetBitContext *gb){
406 int n;
407 n = get_bits1(gb);
408 if (n == 1)
409 return 0;
410 else
411 return 2 - get_bits1(gb);
412 }
413
414 /**
415 * Init VC-1 specific tables and VC1Context members
416 * @param v The VC1Context to initialize
417 * @return Status
418 */
419 static int vc1_init_common(VC1Context *v)
420 {
421 static int done = 0;
422 int i = 0;
423
424 v->hrd_rate = v->hrd_buffer = NULL;
425
426 /* VLC tables */
427 if(!done)
428 {
429 done = 1;
430 init_vlc(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
431 vc1_bfraction_bits, 1, 1,
432 vc1_bfraction_codes, 1, 1, 1);
433 init_vlc(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
434 vc1_norm2_bits, 1, 1,
435 vc1_norm2_codes, 1, 1, 1);
436 init_vlc(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
437 vc1_norm6_bits, 1, 1,
438 vc1_norm6_codes, 2, 2, 1);
439 init_vlc(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
440 vc1_imode_bits, 1, 1,
441 vc1_imode_codes, 1, 1, 1);
442 for (i=0; i<3; i++)
443 {
444 init_vlc(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
445 vc1_ttmb_bits[i], 1, 1,
446 vc1_ttmb_codes[i], 2, 2, 1);
447 init_vlc(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
448 vc1_ttblk_bits[i], 1, 1,
449 vc1_ttblk_codes[i], 1, 1, 1);
450 init_vlc(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
451 vc1_subblkpat_bits[i], 1, 1,
452 vc1_subblkpat_codes[i], 1, 1, 1);
453 }
454 for(i=0; i<4; i++)
455 {
456 init_vlc(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
457 vc1_4mv_block_pattern_bits[i], 1, 1,
458 vc1_4mv_block_pattern_codes[i], 1, 1, 1);
459 init_vlc(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
460 vc1_cbpcy_p_bits[i], 1, 1,
461 vc1_cbpcy_p_codes[i], 2, 2, 1);
462 init_vlc(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
463 vc1_mv_diff_bits[i], 1, 1,
464 vc1_mv_diff_codes[i], 2, 2, 1);
465 }
466 for(i=0; i<8; i++)
467 init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
468 &vc1_ac_tables[i][0][1], 8, 4,
469 &vc1_ac_tables[i][0][0], 8, 4, 1);
470 init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
471 &ff_msmp4_mb_i_table[0][1], 4, 2,
472 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
473 }
474
475 /* Other defaults */
476 v->pq = -1;
477 v->mvrange = 0; /* 7.1.1.18, p80 */
478
479 return 0;
480 }
481
482 /***********************************************************************/
483 /**
484 * @defgroup bitplane VC9 Bitplane decoding
485 * @see 8.7, p56
486 * @{
487 */
488
489 /** @addtogroup bitplane
490 * Imode types
491 * @{
492 */
493 enum Imode {
494 IMODE_RAW,
495 IMODE_NORM2,
496 IMODE_DIFF2,
497 IMODE_NORM6,
498 IMODE_DIFF6,
499 IMODE_ROWSKIP,
500 IMODE_COLSKIP
501 };
502 /** @} */ //imode defines
503
504 /** Decode rows by checking if they are skipped
505 * @param plane Buffer to store decoded bits
506 * @param[in] width Width of this buffer
507 * @param[in] height Height of this buffer
508 * @param[in] stride of this buffer
509 */
510 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
511 int x, y;
512
513 for (y=0; y<height; y++){
514 if (!get_bits(gb, 1)) //rowskip
515 memset(plane, 0, width);
516 else
517 for (x=0; x<width; x++)
518 plane[x] = get_bits(gb, 1);
519 plane += stride;
520 }
521 }
522
523 /** Decode columns by checking if they are skipped
524 * @param plane Buffer to store decoded bits
525 * @param[in] width Width of this buffer
526 * @param[in] height Height of this buffer
527 * @param[in] stride of this buffer
528 * @fixme FIXME: Optimize
529 */
530 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
531 int x, y;
532
533 for (x=0; x<width; x++){
534 if (!get_bits(gb, 1)) //colskip
535 for (y=0; y<height; y++)
536 plane[y*stride] = 0;
537 else
538 for (y=0; y<height; y++)
539 plane[y*stride] = get_bits(gb, 1);
540 plane ++;
541 }
542 }
543
544 /** Decode a bitplane's bits
545 * @param bp Bitplane where to store the decode bits
546 * @param v VC-1 context for bit reading and logging
547 * @return Status
548 * @fixme FIXME: Optimize
549 * @todo TODO: Decide if a struct is needed
550 */
551 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
552 {
553 GetBitContext *gb = &v->s.gb;
554
555 int imode, x, y, code, offset;
556 uint8_t invert, *planep = data;
557 int width, height, stride;
558
559 width = v->s.mb_width;
560 height = v->s.mb_height;
561 stride = v->s.mb_stride;
562 invert = get_bits(gb, 1);
563 imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
564
565 *raw_flag = 0;
566 switch (imode)
567 {
568 case IMODE_RAW:
569 //Data is actually read in the MB layer (same for all tests == "raw")
570 *raw_flag = 1; //invert ignored
571 return invert;
572 case IMODE_DIFF2:
573 case IMODE_NORM2:
574 if ((height * width) & 1)
575 {
576 *planep++ = get_bits(gb, 1);
577 offset = 1;
578 }
579 else offset = 0;
580 // decode bitplane as one long line
581 for (y = offset; y < height * width; y += 2) {
582 code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
583 *planep++ = code & 1;
584 offset++;
585 if(offset == width) {
586 offset = 0;
587 planep += stride - width;
588 }
589 *planep++ = code >> 1;
590 offset++;
591 if(offset == width) {
592 offset = 0;
593 planep += stride - width;
594 }
595 }
596 break;
597 case IMODE_DIFF6:
598 case IMODE_NORM6:
599 if(!(height % 3) && (width % 3)) { // use 2x3 decoding
600 for(y = 0; y < height; y+= 3) {
601 for(x = width & 1; x < width; x += 2) {
602 code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
603 if(code < 0){
604 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
605 return -1;
606 }
607 planep[x + 0] = (code >> 0) & 1;
608 planep[x + 1] = (code >> 1) & 1;
609 planep[x + 0 + stride] = (code >> 2) & 1;
610 planep[x + 1 + stride] = (code >> 3) & 1;
611 planep[x + 0 + stride * 2] = (code >> 4) & 1;
612 planep[x + 1 + stride * 2] = (code >> 5) & 1;
613 }
614 planep += stride * 3;
615 }
616 if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
617 } else { // 3x2
618 planep += (height & 1) * stride;
619 for(y = height & 1; y < height; y += 2) {
620 for(x = width % 3; x < width; x += 3) {
621 code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
622 if(code < 0){
623 av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
624 return -1;
625 }
626 planep[x + 0] = (code >> 0) & 1;
627 planep[x + 1] = (code >> 1) & 1;
628 planep[x + 2] = (code >> 2) & 1;
629 planep[x + 0 + stride] = (code >> 3) & 1;
630 planep[x + 1 + stride] = (code >> 4) & 1;
631 planep[x + 2 + stride] = (code >> 5) & 1;
632 }
633 planep += stride * 2;
634 }
635 x = width % 3;
636 if(x) decode_colskip(data , x, height , stride, &v->s.gb);
637 if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
638 }
639 break;
640 case IMODE_ROWSKIP:
641 decode_rowskip(data, width, height, stride, &v->s.gb);
642 break;
643 case IMODE_COLSKIP:
644 decode_colskip(data, width, height, stride, &v->s.gb);
645 break;
646 default: break;
647 }
648
649 /* Applying diff operator */
650 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
651 {
652 planep = data;
653 planep[0] ^= invert;
654 for (x=1; x<width; x++)
655 planep[x] ^= planep[x-1];
656 for (y=1; y<height; y++)
657 {
658 planep += stride;
659 planep[0] ^= planep[-stride];
660 for (x=1; x<width; x++)
661 {
662 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
663 else planep[x] ^= planep[x-1];
664 }
665 }
666 }
667 else if (invert)
668 {
669 planep = data;
670 for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
671 }
672 return (imode<<1) + invert;
673 }
674
675 /** @} */ //Bitplane group
676
677 /***********************************************************************/
678 /** VOP Dquant decoding
679 * @param v VC-1 Context
680 */
681 static int vop_dquant_decoding(VC1Context *v)
682 {
683 GetBitContext *gb = &v->s.gb;
684 int pqdiff;
685
686 //variable size
687 if (v->dquant == 2)
688 {
689 pqdiff = get_bits(gb, 3);
690 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
691 else v->altpq = v->pq + pqdiff + 1;
692 }
693 else
694 {
695 v->dquantfrm = get_bits(gb, 1);
696 if ( v->dquantfrm )
697 {
698 v->dqprofile = get_bits(gb, 2);
699 switch (v->dqprofile)
700 {
701 case DQPROFILE_SINGLE_EDGE:
702 case DQPROFILE_DOUBLE_EDGES:
703 v->dqsbedge = get_bits(gb, 2);
704 break;
705 case DQPROFILE_ALL_MBS:
706 v->dqbilevel = get_bits(gb, 1);
707 default: break; //Forbidden ?
708 }
709 if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
710 {
711 pqdiff = get_bits(gb, 3);
712 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
713 else v->altpq = v->pq + pqdiff + 1;
714 }
715 }
716 }
717 return 0;
718 }
719
720 /** Put block onto picture
721 * @todo move to DSPContext
722 */
723 static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
724 {
725 uint8_t *Y;
726 int ys, us, vs;
727 DSPContext *dsp = &v->s.dsp;
728
729 if(v->rangeredfrm) {
730 int i, j, k;
731 for(k = 0; k < 6; k++)
732 for(j = 0; j < 8; j++)
733 for(i = 0; i < 8; i++)
734 block[k][i + j*8] = ((block[k][i + j*8] - 128) << 1) + 128;
735
736 }
737 ys = v->s.current_picture.linesize[0];
738 us = v->s.current_picture.linesize[1];
739 vs = v->s.current_picture.linesize[2];
740 Y = v->s.dest[0];
741
742 dsp->put_pixels_clamped(block[0], Y, ys);
743 dsp->put_pixels_clamped(block[1], Y + 8, ys);
744 Y += ys * 8;
745 dsp->put_pixels_clamped(block[2], Y, ys);
746 dsp->put_pixels_clamped(block[3], Y + 8, ys);
747
748 if(!(v->s.flags & CODEC_FLAG_GRAY)) {
749 dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
750 dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
751 }
752 }
753
754 /** Do motion compensation over 1 macroblock
755 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
756 */
757 static void vc1_mc_1mv(VC1Context *v, int dir)
758 {
759 MpegEncContext *s = &v->s;
760 DSPContext *dsp = &v->s.dsp;
761 uint8_t *srcY, *srcU, *srcV;
762 int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
763
764 if(!v->s.last_picture.data[0])return;
765
766 mx = s->mv[0][0][0];
767 my = s->mv[0][0][1];
768 uvmx = (mx + ((mx & 3) == 3)) >> 1;
769 uvmy = (my + ((my & 3) == 3)) >> 1;
770 if(!dir) {
771 srcY = s->last_picture.data[0];
772 srcU = s->last_picture.data[1];
773 srcV = s->last_picture.data[2];
774 } else {
775 srcY = s->next_picture.data[0];
776 srcU = s->next_picture.data[1];
777 srcV = s->next_picture.data[2];
778 }
779
780 src_x = s->mb_x * 16 + (mx >> 2);
781 src_y = s->mb_y * 16 + (my >> 2);
782 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
783 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
784
785 src_x = clip( src_x, -16, s->mb_width * 16);
786 src_y = clip( src_y, -16, s->mb_height * 16);
787 uvsrc_x = clip(uvsrc_x, -8, s->mb_width * 8);
788 uvsrc_y = clip(uvsrc_y, -8, s->mb_height * 8);
789
790 srcY += src_y * s->linesize + src_x;
791 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
792 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
793
794 /* for grayscale we should not try to read from unknown area */
795 if(s->flags & CODEC_FLAG_GRAY) {
796 srcU = s->edge_emu_buffer + 18 * s->linesize;
797 srcV = s->edge_emu_buffer + 18 * s->linesize;
798 }
799
800 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
801 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
802 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
803 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
804
805 srcY -= s->mspel * (1 + s->linesize);
806 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
807 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
808 srcY = s->edge_emu_buffer;
809 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
810 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
811 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
812 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
813 srcU = uvbuf;
814 srcV = uvbuf + 16;
815 /* if we deal with range reduction we need to scale source blocks */
816 if(v->rangeredfrm) {
817 int i, j;
818 uint8_t *src, *src2;
819
820 src = srcY;
821 for(j = 0; j < 17 + s->mspel*2; j++) {
822 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
823 src += s->linesize;
824 }
825 src = srcU; src2 = srcV;
826 for(j = 0; j < 9; j++) {
827 for(i = 0; i < 9; i++) {
828 src[i] = ((src[i] - 128) >> 1) + 128;
829 src2[i] = ((src2[i] - 128) >> 1) + 128;
830 }
831 src += s->uvlinesize;
832 src2 += s->uvlinesize;
833 }
834 }
835 /* if we deal with intensity compensation we need to scale source blocks */
836 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
837 int i, j;
838 uint8_t *src, *src2;
839
840 src = srcY;
841 for(j = 0; j < 17 + s->mspel*2; j++) {
842 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
843 src += s->linesize;
844 }
845 src = srcU; src2 = srcV;
846 for(j = 0; j < 9; j++) {
847 for(i = 0; i < 9; i++) {
848 src[i] = v->lutuv[src[i]];
849 src2[i] = v->lutuv[src2[i]];
850 }
851 src += s->uvlinesize;
852 src2 += s->uvlinesize;
853 }
854 }
855 srcY += s->mspel * (1 + s->linesize);
856 }
857
858 if(v->fastuvmc) {
859 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
860 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
861 }
862
863 if(s->mspel) {
864 dxy = ((my & 3) << 2) | (mx & 3);
865 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] , srcY , s->linesize, v->rnd);
866 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
867 srcY += s->linesize * 8;
868 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize , srcY , s->linesize, v->rnd);
869 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
870 } else if(!s->quarter_sample) { // hpel mc
871 mx >>= 1;
872 my >>= 1;
873 dxy = ((my & 1) << 1) | (mx & 1);
874
875 if(!v->rnd)
876 dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
877 else
878 dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
879 } else {
880 dxy = ((my & 3) << 2) | (mx & 3);
881
882 if(!v->rnd)
883 dsp->put_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
884 else
885 dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
886 }
887
888 if(s->flags & CODEC_FLAG_GRAY) return;
889 /* Chroma MC always uses qpel blilinear */
890 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
891 if(!v->rnd){
892 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
893 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
894 }else{
895 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
896 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
897 }
898 }
899
900 /** Do motion compensation for 4-MV macroblock - luminance block
901 */
902 static void vc1_mc_4mv_luma(VC1Context *v, int n)
903 {
904 MpegEncContext *s = &v->s;
905 DSPContext *dsp = &v->s.dsp;
906 uint8_t *srcY;
907 int dxy, mx, my, src_x, src_y;
908 int off;
909
910 if(!v->s.last_picture.data[0])return;
911 mx = s->mv[0][n][0];
912 my = s->mv[0][n][1];
913 srcY = s->last_picture.data[0];
914
915 off = s->linesize * 4 * (n&2) + (n&1) * 8;
916
917 src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
918 src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
919
920 src_x = clip( src_x, -16, s->mb_width * 16);
921 src_y = clip( src_y, -16, s->mb_height * 16);
922
923 srcY += src_y * s->linesize + src_x;
924
925 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
926 || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
927 || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
928 srcY -= s->mspel * (1 + s->linesize);
929 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
930 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
931 srcY = s->edge_emu_buffer;
932 /* if we deal with range reduction we need to scale source blocks */
933 if(v->rangeredfrm) {
934 int i, j;
935 uint8_t *src;
936
937 src = srcY;
938 for(j = 0; j < 9 + s->mspel*2; j++) {
939 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
940 src += s->linesize;
941 }
942 }
943 /* if we deal with intensity compensation we need to scale source blocks */
944 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
945 int i, j;
946 uint8_t *src;
947
948 src = srcY;
949 for(j = 0; j < 9 + s->mspel*2; j++) {
950 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
951 src += s->linesize;
952 }
953 }
954 srcY += s->mspel * (1 + s->linesize);
955 }
956
957 if(s->mspel) {
958 dxy = ((my & 3) << 2) | (mx & 3);
959 dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
960 } else if(!s->quarter_sample) { // hpel mc
961 mx >>= 1;
962 my >>= 1;
963 dxy = ((my & 1) << 1) | (mx & 1);
964
965 if(!v->rnd)
966 dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
967 else
968 dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
969 } else {
970 dxy = ((my & 3) << 2) | (mx & 3);
971
972 if(!v->rnd)
973 dsp->put_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
974 else
975 dsp->put_no_rnd_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
976 }
977 }
978
979 static inline int median4(int a, int b, int c, int d)
980 {
981 if(a < b) {
982 if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
983 else return (FFMIN(b, c) + FFMAX(a, d)) / 2;
984 } else {
985 if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
986 else return (FFMIN(a, c) + FFMAX(b, d)) / 2;
987 }
988 }
989
990
991 /** Do motion compensation for 4-MV macroblock - both chroma blocks
992 */
993 static void vc1_mc_4mv_chroma(VC1Context *v)
994 {
995 MpegEncContext *s = &v->s;
996 DSPContext *dsp = &v->s.dsp;
997 uint8_t *srcU, *srcV;
998 int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
999 int i, idx, tx = 0, ty = 0;
1000 int mvx[4], mvy[4], intra[4];
1001 static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1002
1003 if(!v->s.last_picture.data[0])return;
1004 if(s->flags & CODEC_FLAG_GRAY) return;
1005
1006 for(i = 0; i < 4; i++) {
1007 mvx[i] = s->mv[0][i][0];
1008 mvy[i] = s->mv[0][i][1];
1009 intra[i] = v->mb_type[0][s->block_index[i]];
1010 }
1011
1012 /* calculate chroma MV vector from four luma MVs */
1013 idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1014 if(!idx) { // all blocks are inter
1015 tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1016 ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1017 } else if(count[idx] == 1) { // 3 inter blocks
1018 switch(idx) {
1019 case 0x1:
1020 tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1021 ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1022 break;
1023 case 0x2:
1024 tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1025 ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1026 break;
1027 case 0x4:
1028 tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1029 ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1030 break;
1031 case 0x8:
1032 tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1033 ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1034 break;
1035 }
1036 } else if(count[idx] == 2) {
1037 int t1 = 0, t2 = 0;
1038 for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1039 for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1040 tx = (mvx[t1] + mvx[t2]) / 2;
1041 ty = (mvy[t1] + mvy[t2]) / 2;
1042 } else
1043 return; //no need to do MC for inter blocks
1044
1045 uvmx = (tx + ((tx&3) == 3)) >> 1;
1046 uvmy = (ty + ((ty&3) == 3)) >> 1;
1047
1048 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1049 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1050
1051 uvsrc_x = clip(uvsrc_x, -8, s->mb_width * 8);
1052 uvsrc_y = clip(uvsrc_y, -8, s->mb_height * 8);
1053 srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1054 srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1055 if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1056 || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
1057 || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
1058 ff_emulated_edge_mc(s->edge_emu_buffer , srcU, s->uvlinesize, 8+1, 8+1,
1059 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1060 ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1061 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1062 srcU = s->edge_emu_buffer;
1063 srcV = s->edge_emu_buffer + 16;
1064
1065 /* if we deal with range reduction we need to scale source blocks */
1066 if(v->rangeredfrm) {
1067 int i, j;
1068 uint8_t *src, *src2;
1069
1070 src = srcU; src2 = srcV;
1071 for(j = 0; j < 9; j++) {
1072 for(i = 0; i < 9; i++) {
1073 src[i] = ((src[i] - 128) >> 1) + 128;
1074 src2[i] = ((src2[i] - 128) >> 1) + 128;
1075 }
1076 src += s->uvlinesize;
1077 src2 += s->uvlinesize;
1078 }
1079 }
1080 /* if we deal with intensity compensation we need to scale source blocks */
1081 if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1082 int i, j;
1083 uint8_t *src, *src2;
1084
1085 src = srcU; src2 = srcV;
1086 for(j = 0; j < 9; j++) {
1087 for(i = 0; i < 9; i++) {
1088 src[i] = v->lutuv[src[i]];
1089 src2[i] = v->lutuv[src2[i]];
1090 }
1091 src += s->uvlinesize;
1092 src2 += s->uvlinesize;
1093 }
1094 }
1095 }
1096
1097 if(v->fastuvmc) {
1098 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1099 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1100 }
1101
1102 /* Chroma MC always uses qpel blilinear */
1103 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
1104 if(!v->rnd){
1105 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
1106 dsp->put_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1107 }else{
1108 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
1109 dsp->put_no_rnd_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1110 }
1111 }
1112
1113 /**
1114 * Decode Simple/Main Profiles sequence header
1115 * @see Figure 7-8, p16-17
1116 * @param avctx Codec context
1117 * @param gb GetBit context initialized from Codec context extra_data
1118 * @return Status
1119 */
1120 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1121 {
1122 VC1Context *v = avctx->priv_data;
1123
1124 av_log(avctx, AV_LOG_INFO, "Header: %0X\n", show_bits(gb, 32));
1125 v->profile = get_bits(gb, 2);
1126 if (v->profile == 2)
1127 {
1128 av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1129 return -1;
1130 }
1131
1132 if (v->profile == PROFILE_ADVANCED)
1133 {
1134 v->level = get_bits(gb, 3);
1135 if(v->level >= 5)
1136 {
1137 av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1138 }
1139 v->chromaformat = get_bits(gb, 2);
1140 if (v->chromaformat != 1)
1141 {
1142 av_log(avctx, AV_LOG_ERROR,
1143 "Only 4:2:0 chroma format supported\n");
1144 return -1;
1145 }
1146 }
1147 else
1148 {
1149 v->res_sm = get_bits(gb, 2); //reserved
1150 if (v->res_sm)
1151 {
1152 av_log(avctx, AV_LOG_ERROR,
1153 "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1154 return -1;
1155 }
1156 }
1157
1158 // (fps-2)/4 (->30)
1159 v->frmrtq_postproc = get_bits(gb, 3); //common
1160 // (bitrate-32kbps)/64kbps
1161 v->bitrtq_postproc = get_bits(gb, 5); //common
1162 v->s.loop_filter = get_bits(gb, 1); //common
1163 if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1164 {
1165 av_log(avctx, AV_LOG_ERROR,
1166 "LOOPFILTER shell not be enabled in simple profile\n");
1167 }
1168
1169 if (v->profile < PROFILE_ADVANCED)
1170 {
1171 v->res_x8 = get_bits(gb, 1); //reserved
1172 if (v->res_x8)
1173 {
1174 av_log(avctx, AV_LOG_ERROR,
1175 "1 for reserved RES_X8 is forbidden\n");
1176 //return -1;
1177 }
1178 v->multires = get_bits(gb, 1);
1179 v->res_fasttx = get_bits(gb, 1);
1180 if (!v->res_fasttx)
1181 {
1182 av_log(avctx, AV_LOG_ERROR,
1183 "0 for reserved RES_FASTTX is forbidden\n");
1184 //return -1;
1185 }
1186 }
1187
1188 v->fastuvmc = get_bits(gb, 1); //common
1189 if (!v->profile && !v->fastuvmc)
1190 {
1191 av_log(avctx, AV_LOG_ERROR,
1192 "FASTUVMC unavailable in Simple Profile\n");
1193 return -1;
1194 }
1195 v->extended_mv = get_bits(gb, 1); //common
1196 if (!v->profile && v->extended_mv)
1197 {
1198 av_log(avctx, AV_LOG_ERROR,
1199 "Extended MVs unavailable in Simple Profile\n");
1200 return -1;
1201 }
1202 v->dquant = get_bits(gb, 2); //common
1203 v->vstransform = get_bits(gb, 1); //common
1204
1205 if (v->profile < PROFILE_ADVANCED)
1206 {
1207 v->res_transtab = get_bits(gb, 1);
1208 if (v->res_transtab)
1209 {
1210 av_log(avctx, AV_LOG_ERROR,
1211 "1 for reserved RES_TRANSTAB is forbidden\n");
1212 return -1;
1213 }
1214 }
1215
1216 v->overlap = get_bits(gb, 1); //common
1217
1218 if (v->profile < PROFILE_ADVANCED)
1219 {
1220 v->s.resync_marker = get_bits(gb, 1);
1221 v->rangered = get_bits(gb, 1);
1222 if (v->rangered && v->profile == PROFILE_SIMPLE)
1223 {
1224 av_log(avctx, AV_LOG_INFO,
1225 "RANGERED should be set to 0 in simple profile\n");
1226 }
1227 }
1228
1229 v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1230 v->quantizer_mode = get_bits(gb, 2); //common
1231
1232 if (v->profile < PROFILE_ADVANCED)
1233 {
1234 v->finterpflag = get_bits(gb, 1); //common
1235 v->res_rtm_flag = get_bits(gb, 1); //reserved
1236 if (!v->res_rtm_flag)
1237 {
1238 // av_log(avctx, AV_LOG_ERROR,
1239 // "0 for reserved RES_RTM_FLAG is forbidden\n");
1240 av_log(avctx, AV_LOG_ERROR,
1241 "Old WMV3 version detected, only I-frames will be decoded\n");
1242 //return -1;
1243 }
1244 av_log(avctx, AV_LOG_DEBUG,
1245 "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1246 "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1247 "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1248 "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1249 v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1250 v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1251 v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1252 v->dquant, v->quantizer_mode, avctx->max_b_frames
1253 );
1254 return 0;
1255 }
1256 return -1;
1257 }
1258
1259
1260 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1261 {
1262 int pqindex, lowquant, status;
1263
1264 if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1265 skip_bits(gb, 2); //framecnt unused
1266 v->rangeredfrm = 0;
1267 if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1268 v->s.pict_type = get_bits(gb, 1);
1269 if (v->s.avctx->max_b_frames) {
1270 if (!v->s.pict_type) {
1271 if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1272 else v->s.pict_type = B_TYPE;
1273 } else v->s.pict_type = P_TYPE;
1274 } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1275
1276 if(v->s.pict_type == I_TYPE)
1277 get_bits(gb, 7); // skip buffer fullness
1278 if(v->s.pict_type == B_TYPE) {
1279 v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1280 v->bfraction = vc1_bfraction_lut[v->bfraction];
1281 if(v->bfraction == -1) {
1282 v->s.pict_type = BI_TYPE;
1283 }
1284 }
1285
1286 /* calculate RND */
1287 if(v->s.pict_type == I_TYPE)
1288 v->rnd = 1;
1289 if(v->s.pict_type == P_TYPE)
1290 v->rnd ^= 1;
1291
1292 /* Quantizer stuff */
1293 pqindex = get_bits(gb, 5);
1294 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1295 v->pq = pquant_table[0][pqindex];
1296 else
1297 v->pq = pquant_table[1][pqindex];
1298
1299 v->pquantizer = 1;
1300 if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1301 v->pquantizer = pqindex < 9;
1302 if (v->quantizer_mode == QUANT_NON_UNIFORM)
1303 v->pquantizer = 0;
1304 v->pqindex = pqindex;
1305 if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1306 else v->halfpq = 0;
1307 if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1308 v->pquantizer = get_bits(gb, 1);
1309 v->dquantfrm = 0;
1310 if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1311 v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1312 v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1313 v->range_x = 1 << (v->k_x - 1);
1314 v->range_y = 1 << (v->k_y - 1);
1315 if (v->profile == PROFILE_ADVANCED)
1316 {
1317 if (v->postprocflag) v->postproc = get_bits(gb, 1);
1318 }
1319 else
1320 if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1321
1322 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1323 // (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1324
1325 //TODO: complete parsing for P/B/BI frames
1326 switch(v->s.pict_type) {
1327 case P_TYPE:
1328 if (v->pq < 5) v->tt_index = 0;
1329 else if(v->pq < 13) v->tt_index = 1;
1330 else v->tt_index = 2;
1331
1332 lowquant = (v->pq > 12) ? 0 : 1;
1333 v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1334 if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1335 {
1336 int scale, shift, i;
1337 v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1338 v->lumscale = get_bits(gb, 6);
1339 v->lumshift = get_bits(gb, 6);
1340 /* fill lookup tables for intensity compensation */
1341 if(!v->lumscale) {
1342 scale = -64;
1343 shift = (255 - v->lumshift * 2) << 6;
1344 if(v->lumshift > 31)
1345 shift += 128 << 6;
1346 } else {
1347 scale = v->lumscale + 32;
1348 if(v->lumshift > 31)
1349 shift = (v->lumshift - 64) << 6;
1350 else
1351 shift = v->lumshift << 6;
1352 }
1353 for(i = 0; i < 256; i++) {
1354 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1355 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1356 }
1357 }
1358 if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1359 v->s.quarter_sample = 0;
1360 else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1361 if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1362 v->s.quarter_sample = 0;
1363 else
1364 v->s.quarter_sample = 1;
1365 } else
1366 v->s.quarter_sample = 1;
1367 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));
1368
1369 if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1370 v->mv_mode2 == MV_PMODE_MIXED_MV)
1371 || v->mv_mode == MV_PMODE_MIXED_MV)
1372 {
1373 status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1374 if (status < 0) return -1;
1375 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1376 "Imode: %i, Invert: %i\n", status>>1, status&1);
1377 } else {
1378 v->mv_type_is_raw = 0;
1379 memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1380 }
1381 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1382 if (status < 0) return -1;
1383 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1384 "Imode: %i, Invert: %i\n", status>>1, status&1);
1385
1386 /* Hopefully this is correct for P frames */
1387 v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1388 v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1389
1390 if (v->dquant)
1391 {
1392 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1393 vop_dquant_decoding(v);
1394 }
1395
1396 v->ttfrm = 0; //FIXME Is that so ?
1397 if (v->vstransform)
1398 {
1399 v->ttmbf = get_bits(gb, 1);
1400 if (v->ttmbf)
1401 {
1402 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1403 }
1404 } else {
1405 v->ttmbf = 1;
1406 v->ttfrm = TT_8X8;
1407 }
1408 break;
1409 case B_TYPE:
1410 if (v->pq < 5) v->tt_index = 0;
1411 else if(v->pq < 13) v->tt_index = 1;
1412 else v->tt_index = 2;
1413
1414 lowquant = (v->pq > 12) ? 0 : 1;
1415 v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1416 v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1417 v->s.mspel = v->s.quarter_sample;
1418
1419 status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1420 if (status < 0) return -1;
1421 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1422 "Imode: %i, Invert: %i\n", status>>1, status&1);
1423 status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1424 if (status < 0) return -1;
1425 av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1426 "Imode: %i, Invert: %i\n", status>>1, status&1);
1427
1428 v->s.mv_table_index = get_bits(gb, 2);
1429 v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1430
1431 if (v->dquant)
1432 {
1433 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1434 vop_dquant_decoding(v);
1435 }
1436
1437 v->ttfrm = 0;
1438 if (v->vstransform)
1439 {
1440 v->ttmbf = get_bits(gb, 1);
1441 if (v->ttmbf)
1442 {
1443 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1444 }
1445 } else {
1446 v->ttmbf = 1;
1447 v->ttfrm = TT_8X8;
1448 }
1449 break;
1450 }
1451
1452 /* AC Syntax */
1453 v->c_ac_table_index = decode012(gb);
1454 if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1455 {
1456 v->y_ac_table_index = decode012(gb);
1457 }
1458 /* DC Syntax */
1459 v->s.dc_table_index = get_bits(gb, 1);
1460
1461 return 0;
1462 }
1463
1464 /***********************************************************************/
1465 /**
1466 * @defgroup block VC-1 Block-level functions
1467 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1468 * @todo TODO: Integrate to MpegEncContext facilities
1469 * @{
1470 */
1471
1472 /**
1473 * @def GET_MQUANT
1474 * @brief Get macroblock-level quantizer scale
1475 * @warning XXX: qdiff to the frame quant, not previous quant ?
1476 * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1477 */
1478 #define GET_MQUANT() \
1479 if (v->dquantfrm) \
1480 { \
1481 int edges = 0; \
1482 if (v->dqprofile == DQPROFILE_ALL_MBS) \
1483 { \
1484 if (v->dqbilevel) \
1485 { \
1486 mquant = (get_bits(gb, 1)) ? v->altpq : v->pq; \
1487 } \
1488 else \
1489 { \
1490 mqdiff = get_bits(gb, 3); \
1491 if (mqdiff != 7) mquant = v->pq + mqdiff; \
1492 else mquant = get_bits(gb, 5); \
1493 } \
1494 } \
1495 if(v->dqprofile == DQPROFILE_SINGLE_EDGE) \
1496 edges = 1 << v->dqsbedge; \
1497 else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES) \
1498 edges = (3 << v->dqsbedge) % 15; \
1499 else if(v->dqprofile == DQPROFILE_FOUR_EDGES) \
1500 edges = 15; \
1501 if((edges&1) && !s->mb_x) \
1502 mquant = v->altpq; \
1503 if((edges&2) && s->first_slice_line) \
1504 mquant = v->altpq; \
1505 if((edges&4) && s->mb_x == (s->mb_width - 1)) \
1506 mquant = v->altpq; \
1507 if((edges&8) && s->mb_y == (s->mb_height - 1)) \
1508 mquant = v->altpq; \
1509 }
1510
1511 /**
1512 * @def GET_MVDATA(_dmv_x, _dmv_y)
1513 * @brief Get MV differentials
1514 * @see MVDATA decoding from 8.3.5.2, p(1)20
1515 * @param _dmv_x Horizontal differential for decoded MV
1516 * @param _dmv_y Vertical differential for decoded MV
1517 * @todo TODO: Use MpegEncContext arrays to store them
1518 */
1519 #define GET_MVDATA(_dmv_x, _dmv_y) \
1520 index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1521 VC1_MV_DIFF_VLC_BITS, 2); \
1522 if (index > 36) \
1523 { \
1524 mb_has_coeffs = 1; \
1525 index -= 37; \
1526 } \
1527 else mb_has_coeffs = 0; \
1528 s->mb_intra = 0; \
1529 if (!index) { _dmv_x = _dmv_y = 0; } \
1530 else if (index == 35) \
1531 { \
1532 _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \
1533 _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \
1534 } \
1535 else if (index == 36) \
1536 { \
1537 _dmv_x = 0; \
1538 _dmv_y = 0; \
1539 s->mb_intra = 1; \
1540 } \
1541 else \
1542 { \
1543 index1 = index%6; \
1544 if (!s->quarter_sample && index1 == 5) val = 1; \
1545 else val = 0; \
1546 if(size_table[index1] - val > 0) \
1547 val = get_bits(gb, size_table[index1] - val); \
1548 else val = 0; \
1549 sign = 0 - (val&1); \
1550 _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1551 \
1552 index1 = index/6; \
1553 if (!s->quarter_sample && index1 == 5) val = 1; \
1554 else val = 0; \
1555 if(size_table[index1] - val > 0) \
1556 val = get_bits(gb, size_table[index1] - val); \
1557 else val = 0; \
1558 sign = 0 - (val&1); \
1559 _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign; \
1560 }
1561
1562 /** Predict and set motion vector
1563 */
1564 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)
1565 {
1566 int xy, wrap, off = 0;
1567 int16_t *A, *B, *C;
1568 int px, py;
1569 int sum;
1570
1571 /* scale MV difference to be quad-pel */
1572 dmv_x <<= 1 - s->quarter_sample;
1573 dmv_y <<= 1 - s->quarter_sample;
1574
1575 wrap = s->b8_stride;
1576 xy = s->block_index[n];
1577
1578 if(s->mb_intra){
1579 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1580 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1581 if(mv1) { /* duplicate motion data for 1-MV block */
1582 s->current_picture.motion_val[0][xy + 1][0] = 0;
1583 s->current_picture.motion_val[0][xy + 1][1] = 0;
1584 s->current_picture.motion_val[0][xy + wrap][0] = 0;
1585 s->current_picture.motion_val[0][xy + wrap][1] = 0;
1586 s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1587 s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1588 }
1589 return;
1590 }
1591
1592 C = s->current_picture.motion_val[0][xy - 1];
1593 A = s->current_picture.motion_val[0][xy - wrap];
1594 if(mv1)
1595 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1596 else {
1597 //in 4-MV mode different blocks have different B predictor position
1598 switch(n){
1599 case 0:
1600 off = (s->mb_x > 0) ? -1 : 1;
1601 break;
1602 case 1:
1603 off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1604 break;
1605 case 2:
1606 off = 1;
1607 break;
1608 case 3:
1609 off = -1;
1610 }
1611 }
1612 B = s->current_picture.motion_val[0][xy - wrap + off];
1613
1614 if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
1615 if(s->mb_width == 1) {
1616 px = A[0];
1617 py = A[1];
1618 } else {
1619 px = mid_pred(A[0], B[0], C[0]);
1620 py = mid_pred(A[1], B[1], C[1]);
1621 }
1622 } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
1623 px = C[0];
1624 py = C[1];
1625 } else {
1626 px = py = 0;
1627 }
1628 /* Pullback MV as specified in 8.3.5.3.4 */
1629 {
1630 int qx, qy, X, Y;
1631 qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
1632 qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
1633 X = (s->mb_width << 6) - 4;
1634 Y = (s->mb_height << 6) - 4;
1635 if(mv1) {
1636 if(qx + px < -60) px = -60 - qx;
1637 if(qy + py < -60) py = -60 - qy;
1638 } else {
1639 if(qx + px < -28) px = -28 - qx;
1640 if(qy + py < -28) py = -28 - qy;
1641 }
1642 if(qx + px > X) px = X - qx;
1643 if(qy + py > Y) py = Y - qy;
1644 }
1645 /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1646 if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
1647 if(is_intra[xy - wrap])
1648 sum = ABS(px) + ABS(py);
1649 else
1650 sum = ABS(px - A[0]) + ABS(py - A[1]);
1651 if(sum > 32) {
1652 if(get_bits1(&s->gb)) {
1653 px = A[0];
1654 py = A[1];
1655 } else {
1656 px = C[0];
1657 py = C[1];
1658 }
1659 } else {
1660 if(is_intra[xy - 1])
1661 sum = ABS(px) + ABS(py);
1662 else
1663 sum = ABS(px - C[0]) + ABS(py - C[1]);
1664 if(sum > 32) {
1665 if(get_bits1(&s->gb)) {
1666 px = A[0];
1667 py = A[1];
1668 } else {
1669 px = C[0];
1670 py = C[1];
1671 }
1672 }
1673 }
1674 }
1675 /* store MV using signed modulus of MV range defined in 4.11 */
1676 s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1677 s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1678 if(mv1) { /* duplicate motion data for 1-MV block */
1679 s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
1680 s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
1681 s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
1682 s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
1683 s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
1684 s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
1685 }
1686 }
1687
1688 /** Motion compensation for direct or interpolated blocks in B-frames
1689 */
1690 static void vc1_interp_mc(VC1Context *v)
1691 {
1692 MpegEncContext *s = &v->s;
1693 DSPContext *dsp = &v->s.dsp;
1694 uint8_t *srcY, *srcU, *srcV;
1695 int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
1696
1697 if(!v->s.next_picture.data[0])return;
1698
1699 mx = s->mv[1][0][0];
1700 my = s->mv[1][0][1];
1701 uvmx = (mx + ((mx & 3) == 3)) >> 1;
1702 uvmy = (my + ((my & 3) == 3)) >> 1;
1703 srcY = s->next_picture.data[0];
1704 srcU = s->next_picture.data[1];
1705 srcV = s->next_picture.data[2];
1706
1707 src_x = s->mb_x * 16 + (mx >> 2);
1708 src_y = s->mb_y * 16 + (my >> 2);
1709 uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1710 uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1711
1712 src_x = clip( src_x, -16, s->mb_width * 16);
1713 src_y = clip( src_y, -16, s->mb_height * 16);
1714 uvsrc_x = clip(uvsrc_x, -8, s->mb_width * 8);
1715 uvsrc_y = clip(uvsrc_y, -8, s->mb_height * 8);
1716
1717 srcY += src_y * s->linesize + src_x;
1718 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
1719 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
1720
1721 /* for grayscale we should not try to read from unknown area */
1722 if(s->flags & CODEC_FLAG_GRAY) {
1723 srcU = s->edge_emu_buffer + 18 * s->linesize;
1724 srcV = s->edge_emu_buffer + 18 * s->linesize;
1725 }
1726
1727 if(v->rangeredfrm
1728 || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
1729 || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
1730 uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
1731
1732 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17, 17,
1733 src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
1734 srcY = s->edge_emu_buffer;
1735 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, 8+1, 8+1,
1736 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1737 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
1738 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1739 srcU = uvbuf;
1740 srcV = uvbuf + 16;
1741 /* if we deal with range reduction we need to scale source blocks */
1742 if(v->rangeredfrm) {
1743 int i, j;
1744 uint8_t *src, *src2;
1745
1746 src = srcY;
1747 for(j = 0; j < 17; j++) {
1748 for(i = 0; i < 17; i++) src[i] = ((src[i] - 128) >> 1) + 128;
1749 src += s->linesize;
1750 }
1751 src = srcU; src2 = srcV;
1752 for(j = 0; j < 9; j++) {
1753 for(i = 0; i < 9; i++) {
1754 src[i] = ((src[i] - 128) >> 1) + 128;
1755 src2[i] = ((src2[i] - 128) >> 1) + 128;
1756 }
1757 src += s->uvlinesize;
1758 src2 += s->uvlinesize;
1759 }
1760 }
1761 }
1762
1763 if(v->fastuvmc) {
1764 uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1765 uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1766 }
1767
1768 if(!s->quarter_sample) { // hpel mc
1769 mx >>= 1;
1770 my >>= 1;
1771 dxy = ((my & 1) << 1) | (mx & 1);
1772
1773 dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
1774 } else {
1775 dxy = ((my & 3) << 2) | (mx & 3);
1776
1777 dsp->avg_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
1778 }
1779
1780 if(s->flags & CODEC_FLAG_GRAY) return;
1781 /* Chroma MC always uses qpel blilinear */
1782 uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
1783 dsp->avg_qpel_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize);
1784 dsp->avg_qpel_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize);
1785 }
1786
1787 /** Reconstruct motion vector for B-frame and do motion compensation
1788 */
1789 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
1790 {
1791 MpegEncContext *s = &v->s;
1792 int mx[4], my[4], mv_x, mv_y;
1793 int i;
1794
1795 /* scale MV difference to be quad-pel */
1796 dmv_x[0] <<= 1 - s->quarter_sample;
1797 dmv_y[0] <<= 1 - s->quarter_sample;
1798 dmv_x[1] <<= 1 - s->quarter_sample;
1799 dmv_y[1] <<= 1 - s->quarter_sample;
1800
1801 if(direct) {
1802 for(i = 0; i < 4; i++) {
1803 mx[i] = s->last_picture.motion_val[0][s->block_index[i]][0];
1804 my[i] = s->last_picture.motion_val[0][s->block_index[i]][1];
1805 }
1806 mv_x = median4(mx[0], mx[1], mx[2], mx[3]);
1807 mv_y = median4(my[0], my[1], my[2], my[3]);
1808 s->mv[0][0][0] = (mv_x * v->bfraction + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1809 s->mv[0][0][1] = (mv_y * v->bfraction + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1810 vc1_mc_1mv(v, 0);
1811
1812 for(i = 0; i < 4; i++) {
1813 mx[i] = s->next_picture.motion_val[0][s->block_index[i]][0];
1814 my[i] = s->next_picture.motion_val[0][s->block_index[i]][1];
1815 }
1816 mv_x = median4(mx[0], mx[1], mx[2], mx[3]);
1817 mv_y = median4(my[0], my[1], my[2], my[3]);
1818 s->mv[1][0][0] = (mv_x * (B_FRACTION_DEN - v->bfraction) + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1819 s->mv[1][0][1] = (mv_y * (B_FRACTION_DEN - v->bfraction) + B_FRACTION_DEN/2) / B_FRACTION_DEN;
1820 vc1_interp_mc(v);
1821 return;
1822 }
1823 if(mode == BMV_TYPE_INTERPOLATED) {
1824 s->mv[0][0][0] = dmv_x[0];
1825 s->mv[0][0][1] = dmv_y[0];
1826 vc1_mc_1mv(v, 0);
1827 s->mv[1][0][0] = dmv_x[1];
1828 s->mv[1][0][1] = dmv_y[1];
1829 vc1_interp_mc(v);
1830 return;
1831 }
1832
1833 if(mode == BMV_TYPE_BACKWARD) {
1834 for(i = 0; i < 4; i++) {
1835 mx[i] = s->last_picture.motion_val[0][s->block_index[i]][0];
1836 my[i] = s->last_picture.motion_val[0][s->block_index[i]][1];
1837 }
1838 } else {
1839 for(i = 0; i < 4; i++) {
1840 mx[i] = s->next_picture.motion_val[0][s->block_index[i]][0];
1841 my[i] = s->next_picture.motion_val[0][s->block_index[i]][1];
1842 }
1843 }
1844
1845 /* XXX: not right but how to determine 4-MV intra/inter in another frame? */
1846 mv_x = median4(mx[0], mx[1], mx[2], mx[3]);
1847 mv_y = median4(my[0], my[1], my[2], my[3]);
1848 s->mv[0][0][0] = mv_x;
1849 s->mv[0][0][1] = mv_y;
1850
1851 vc1_mc_1mv(v, (mode == BMV_TYPE_FORWARD));
1852 }
1853
1854 /** Get predicted DC value for I-frames only
1855 * prediction dir: left=0, top=1
1856 * @param s MpegEncContext
1857 * @param[in] n block index in the current MB
1858 * @param dc_val_ptr Pointer to DC predictor
1859 * @param dir_ptr Prediction direction for use in AC prediction
1860 */
1861 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1862 int16_t **dc_val_ptr, int *dir_ptr)
1863 {
1864 int a, b, c, wrap, pred, scale;
1865 int16_t *dc_val;
1866 static const uint16_t dcpred[32] = {
1867 -1, 1024, 512, 341, 256, 205, 171, 146, 128,
1868 114, 102, 93, 85, 79, 73, 68, 64,
1869 60, 57, 54, 51, 49, 47, 45, 43,
1870 41, 39, 38, 37, 35, 34, 33
1871 };
1872
1873 /* find prediction - wmv3_dc_scale always used here in fact */
1874 if (n < 4) scale = s->y_dc_scale;
1875 else scale = s->c_dc_scale;
1876
1877 wrap = s->block_wrap[n];
1878 dc_val= s->dc_val[0] + s->block_index[n];
1879
1880 /* B A
1881 * C X
1882 */
1883 c = dc_val[ - 1];
1884 b = dc_val[ - 1 - wrap];
1885 a = dc_val[ - wrap];
1886
1887 if (pq < 9 || !overlap)
1888 {
1889 /* Set outer values */
1890 if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
1891 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1892 }
1893 else
1894 {
1895 /* Set outer values */
1896 if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
1897 if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1898 }
1899
1900 if (abs(a - b) <= abs(b - c)) {
1901 pred = c;
1902 *dir_ptr = 1;//left
1903 } else {
1904 pred = a;
1905 *dir_ptr = 0;//top
1906 }
1907
1908 /* update predictor */
1909 *dc_val_ptr = &dc_val[0];
1910 return pred;
1911 }
1912
1913
1914 /** Get predicted DC value
1915 * prediction dir: left=0, top=1
1916 * @param s MpegEncContext
1917 * @param[in] n block index in the current MB
1918 * @param dc_val_ptr Pointer to DC predictor
1919 * @param dir_ptr Prediction direction for use in AC prediction
1920 */
1921 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1922 int a_avail, int c_avail,
1923 int16_t **dc_val_ptr, int *dir_ptr)
1924 {
1925 int a, b, c, wrap, pred, scale;
1926 int16_t *dc_val;
1927 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1928 int q1, q2 = 0;
1929
1930 /* find prediction - wmv3_dc_scale always used here in fact */
1931 if (n < 4) scale = s->y_dc_scale;
1932 else scale = s->c_dc_scale;
1933
1934 wrap = s->block_wrap[n];
1935 dc_val= s->dc_val[0] + s->block_index[n];
1936
1937 /* B A
1938 * C X
1939 */
1940 c = dc_val[ - 1];
1941 b = dc_val[ - 1 - wrap];
1942 a = dc_val[ - wrap];
1943 /* scale predictors if needed */
1944 q1 = s->current_picture.qscale_table[mb_pos];
1945 if(c_avail && (n!= 1 && n!=3)) {
1946 q2 = s->current_picture.qscale_table[mb_pos - 1];
1947 if(q2 && q2 != q1)
1948 c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1949 }
1950 if(a_avail && (n!= 2 && n!=3)) {
1951 q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
1952 if(q2 && q2 != q1)
1953 a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1954 }
1955 if(a_avail && c_avail && (n!=3)) {
1956 int off = mb_pos;
1957 if(n != 1) off--;
1958 if(n != 2) off -= s->mb_stride;
1959 q2 = s->current_picture.qscale_table[off];
1960 if(q2 && q2 != q1)
1961 b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1962 }
1963
1964 if(a_avail && c_avail) {
1965 if(abs(a - b) <= abs(b - c)) {
1966 pred = c;
1967 *dir_ptr = 1;//left
1968 } else {
1969 pred = a;
1970 *dir_ptr = 0;//top
1971 }
1972 } else if(a_avail) {
1973 pred = a;
1974 *dir_ptr = 0;//top
1975 } else if(c_avail) {
1976 pred = c;
1977 *dir_ptr = 1;//left
1978 } else {
1979 pred = 0;
1980 *dir_ptr = 1;//left
1981 }
1982
1983 /* update predictor */
1984 *dc_val_ptr = &dc_val[0];
1985 return pred;
1986 }
1987
1988
1989 /**
1990 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
1991 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1992 * @todo TODO: Integrate to MpegEncContext facilities
1993 * @{
1994 */
1995
1996 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1997 {
1998 int xy, wrap, pred, a, b, c;
1999
2000 xy = s->block_index[n];
2001 wrap = s->b8_stride;
2002
2003 /* B C
2004 * A X
2005 */
2006 a = s->coded_block[xy - 1 ];
2007 b = s->coded_block[xy - 1 - wrap];
2008 c = s->coded_block[xy - wrap];
2009
2010 if (b == c) {
2011 pred = a;
2012 } else {
2013 pred = c;
2014 }
2015
2016 /* store value */
2017 *coded_block_ptr = &s->coded_block[xy];
2018
2019 return pred;
2020 }
2021
2022 /**
2023 * Decode one AC coefficient
2024 * @param v The VC1 context
2025 * @param last Last coefficient
2026 * @param skip How much zero coefficients to skip
2027 * @param value Decoded AC coefficient value
2028 * @see 8.1.3.4
2029 */
2030 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
2031 {
2032 GetBitContext *gb = &v->s.gb;
2033 int index, escape, run = 0, level = 0, lst = 0;
2034
2035 index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2036 if (index != vc1_ac_sizes[codingset] - 1) {
2037 run = vc1_index_decode_table[codingset][index][0];
2038 level = vc1_index_decode_table[codingset][index][1];
2039 lst = index >= vc1_last_decode_table[codingset];
2040 if(get_bits(gb, 1))
2041 level = -level;
2042 } else {
2043 escape = decode210(gb);
2044 if (escape != 2) {
2045 index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2046 run = vc1_index_decode_table[codingset][index][0];
2047 level = vc1_index_decode_table[codingset][index][1];
2048 lst = index >= vc1_last_decode_table[codingset];
2049 if(escape == 0) {
2050 if(lst)
2051 level += vc1_last_delta_level_table[codingset][run];
2052 else
2053 level += vc1_delta_level_table[codingset][run];
2054 } else {
2055 if(lst)
2056 run += vc1_last_delta_run_table[codingset][level] + 1;
2057 else
2058 run += vc1_delta_run_table[codingset][level] + 1;
2059 }
2060 if(get_bits(gb, 1))
2061 level = -level;
2062 } else {
2063 int sign;
2064 lst = get_bits(gb, 1);
2065 if(v->s.esc3_level_length == 0) {
2066 if(v->pq < 8 || v->dquantfrm) { // table 59
2067 v->s.esc3_level_length = get_bits(gb, 3);
2068 if(!v->s.esc3_level_length)
2069 v->s.esc3_level_length = get_bits(gb, 2) + 8;
2070 } else { //table 60
2071 v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
2072 }
2073 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2074 }
2075 run = get_bits(gb, v->s.esc3_run_length);
2076 sign = get_bits(gb, 1);
2077 level = get_bits(gb, v->s.esc3_level_length);
2078 if(sign)
2079 level = -level;
2080 }
2081 }
2082
2083 *last = lst;
2084 *skip = run;
2085 *value = level;
2086 }
2087
2088 /** Decode intra block in intra frames - should be faster than decode_intra_block
2089 * @param v VC1Context
2090 * @param block block to decode
2091 * @param coded are AC coeffs present or not
2092 * @param codingset set of VLC to decode data
2093 */
2094 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
2095 {
2096 GetBitContext *gb = &v->s.gb;
2097 MpegEncContext *s = &v->s;
2098 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2099 int run_diff, i;
2100 int16_t *dc_val;
2101 int16_t *ac_val, *ac_val2;
2102 int dcdiff;
2103
2104 /* Get DC differential */
2105 if (n < 4) {
2106 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2107 } else {
2108 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2109 }
2110 if (dcdiff < 0){
2111 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2112 return -1;
2113 }
2114 if (dcdiff)
2115 {
2116 if (dcdiff == 119 /* ESC index value */)
2117 {
2118 /* TODO: Optimize */
2119 if (v->pq == 1) dcdiff = get_bits(gb, 10);
2120 else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2121 else dcdiff = get_bits(gb, 8);
2122 }
2123 else
2124 {
2125 if (v->pq == 1)
2126 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2127 else if (v->pq == 2)
2128 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2129 }
2130 if (get_bits(gb, 1))
2131 dcdiff = -dcdiff;
2132 }
2133
2134 /* Prediction */
2135 dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2136 *dc_val = dcdiff;
2137
2138 /* Store the quantized DC coeff, used for prediction */
2139 if (n < 4) {
2140 block[0] = dcdiff * s->y_dc_scale;
2141 } else {
2142 block[0] = dcdiff * s->c_dc_scale;
2143 }
2144 /* Skip ? */
2145 run_diff = 0;
2146 i = 0;
2147 if (!coded) {
2148 goto not_coded;
2149 }
2150
2151 //AC Decoding
2152 i = 1;
2153
2154 {
2155 int last = 0, skip, value;
2156 const int8_t *zz_table;
2157 int scale;
2158 int k;
2159
2160 scale = v->pq * 2 + v->halfpq;
2161
2162 if(v->s.ac_pred) {
2163 if(!dc_pred_dir)
2164 zz_table = vc1_horizontal_zz;
2165 else
2166 zz_table = vc1_vertical_zz;
2167 } else
2168 zz_table = vc1_normal_zz;
2169
2170 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2171 ac_val2 = ac_val;
2172 if(dc_pred_dir) //left
2173 ac_val -= 16;
2174 else //top
2175 ac_val -= 16 * s->block_wrap[n];
2176
2177 while (!last) {
2178 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2179 i += skip;
2180 if(i > 63)
2181 break;
2182 block[zz_table[i++]] = value;
2183 }
2184
2185 /* apply AC prediction if needed */
2186 if(s->ac_pred) {
2187 if(dc_pred_dir) { //left
2188 for(k = 1; k < 8; k++)
2189 block[k << 3] += ac_val[k];
2190 } else { //top
2191 for(k = 1; k < 8; k++)
2192 block[k] += ac_val[k + 8];
2193 }
2194 }
2195 /* save AC coeffs for further prediction */
2196 for(k = 1; k < 8; k++) {
2197 ac_val2[k] = block[k << 3];
2198 ac_val2[k + 8] = block[k];
2199 }
2200
2201 /* scale AC coeffs */
2202 for(k = 1; k < 64; k++)
2203 if(block[k]) {
2204 block[k] *= scale;
2205 if(!v->pquantizer)
2206 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2207 }
2208
2209 if(s->ac_pred) i = 63;
2210 }
2211
2212 not_coded:
2213 if(!coded) {
2214 int k, scale;
2215 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2216 ac_val2 = ac_val;
2217
2218 scale = v->pq * 2 + v->halfpq;
2219 memset(ac_val2, 0, 16 * 2);
2220 if(dc_pred_dir) {//left
2221 ac_val -= 16;
2222 if(s->ac_pred)
2223 memcpy(ac_val2, ac_val, 8 * 2);
2224 } else {//top
2225 ac_val -= 16 * s->block_wrap[n];
2226 if(s->ac_pred)
2227 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2228 }
2229
2230 /* apply AC prediction if needed */
2231 if(s->ac_pred) {
2232 if(dc_pred_dir) { //left
2233 for(k = 1; k < 8; k++) {
2234 block[k << 3] = ac_val[k] * scale;
2235 if(!v->pquantizer && block[k << 3])
2236 block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2237 }
2238 } else { //top
2239 for(k = 1; k < 8; k++) {
2240 block[k] = ac_val[k + 8] * scale;
2241 if(!v->pquantizer && block[k])
2242 block[k] += (block[k] < 0) ? -v->pq : v->pq;
2243 }
2244 }
2245 i = 63;
2246 }
2247 }
2248 s->block_last_index[n] = i;
2249
2250 return 0;
2251 }
2252
2253 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2254 * @param v VC1Context
2255 * @param block block to decode
2256 * @param coded are AC coeffs present or not
2257 * @param mquant block quantizer
2258 * @param codingset set of VLC to decode data
2259 */
2260 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
2261 {
2262 GetBitContext *gb = &v->s.gb;
2263 MpegEncContext *s = &v->s;
2264 int dc_pred_dir = 0; /* Direction of the DC prediction used */
2265 int run_diff, i;
2266 int16_t *dc_val;
2267 int16_t *ac_val, *ac_val2;
2268 int dcdiff;
2269 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2270 int a_avail = v->a_avail, c_avail = v->c_avail;
2271 int use_pred = s->ac_pred;
2272 int scale;
2273 int q1, q2 = 0;
2274
2275 /* XXX: Guard against dumb values of mquant */
2276 mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
2277
2278 /* Set DC scale - y and c use the same */
2279 s->y_dc_scale = s->y_dc_scale_table[mquant];
2280 s->c_dc_scale = s->c_dc_scale_table[mquant];
2281
2282 /* Get DC differential */
2283 if (n < 4) {
2284 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2285 } else {
2286 dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2287 }
2288 if (dcdiff < 0){
2289 av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2290 return -1;
2291 }
2292 if (dcdiff)
2293 {
2294 if (dcdiff == 119 /* ESC index value */)
2295 {
2296 /* TODO: Optimize */
2297 if (mquant == 1) dcdiff = get_bits(gb, 10);
2298 else if (mquant == 2) dcdiff = get_bits(gb, 9);
2299 else dcdiff = get_bits(gb, 8);
2300 }
2301 else
2302 {
2303 if (mquant == 1)
2304 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2305 else if (mquant == 2)
2306 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2307 }
2308 if (get_bits(gb, 1))
2309 dcdiff = -dcdiff;
2310 }
2311
2312 /* Prediction */
2313 dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2314 *dc_val = dcdiff;
2315
2316 /* Store the quantized DC coeff, used for prediction */
2317
2318 if (n < 4) {
2319 block[0] = dcdiff * s->y_dc_scale;
2320 } else {
2321 block[0] = dcdiff * s->c_dc_scale;
2322 }
2323 /* Skip ? */
2324 run_diff = 0;
2325 i = 0;
2326
2327 //AC Decoding
2328 i = 1;
2329
2330 /* check if AC is needed at all and adjust direction if needed */
2331 if(!a_avail) dc_pred_dir = 1;
2332 if(!c_avail) dc_pred_dir = 0;
2333 if(!a_avail && !c_avail) use_pred = 0;
2334 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2335 ac_val2 = ac_val;
2336
2337 scale = mquant * 2 + v->halfpq;
2338
2339 if(dc_pred_dir) //left
2340 ac_val -= 16;
2341 else //top
2342 ac_val -= 16 * s->block_wrap[n];
2343
2344 q1 = s->current_picture.qscale_table[mb_pos];
2345 if(dc_pred_dir && c_avail) q2 = s->current_picture.qscale_table[mb_pos - 1];
2346 if(!dc_pred_dir && a_avail) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2347 if(n && n<4) q2 = q1;
2348
2349 if(coded) {
2350 int last = 0, skip, value;
2351 const int8_t *zz_table;
2352 int k;
2353
2354 zz_table = vc1_simple_progressive_8x8_zz;
2355
2356 while (!last) {
2357 vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2358 i += skip;
2359 if(i > 63)
2360 break;
2361 block[zz_table[i++]] = value;
2362 }
2363
2364 /* apply AC prediction if needed */
2365 if(use_pred) {
2366 /* scale predictors if needed*/
2367 if(q2 && q1!=q2) {
2368 q1 = q1 * 2 - 1;
2369 q2 = q2 * 2 - 1;
2370
2371 if(dc_pred_dir) { //left
2372 for(k = 1; k < 8; k++)
2373 block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2374 } else { //top
2375 for(k = 1; k < 8; k++)
2376 block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2377 }
2378 } else {
2379 if(dc_pred_dir) { //left
2380 for(k = 1; k < 8; k++)
2381 block[k << 3] += ac_val[k];
2382 } else { //top
2383 for(k = 1; k < 8; k++)
2384 block[k] += ac_val[k + 8];
2385 }
2386 }
2387 }
2388 /* save AC coeffs for further prediction */
2389 for(k = 1; k < 8; k++) {
2390 ac_val2[k] = block[k << 3];
2391 ac_val2[k + 8] = block[k];
2392 }
2393
2394 /* scale AC coeffs */
2395 for(k = 1; k < 64; k++)
2396 if(block[k]) {
2397 block[k] *= scale;
2398 if(!v->pquantizer)
2399 block[k] += (block[k] < 0) ? -mquant : mquant;
2400 }
2401
2402 if(use_pred) i = 63;
2403 } else { // no AC coeffs
2404 int k;
2405
2406 memset(ac_val2, 0, 16 * 2);
2407 if(dc_pred_dir) {//left
2408 if(use_pred) {
2409 memcpy(ac_val2, ac_val, 8 * 2);
2410 if(q2 && q1!=q2) {
2411 q1 = q1 * 2 - 1;
2412 q2 = q2 * 2 - 1;
2413 for(k = 1; k < 8; k++)
2414 ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2415 }
2416 }
2417 } else {//top
2418 if(use_pred) {
2419 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2420 if(q2 && q1!=q2) {
2421 q1 = q1 * 2 - 1;
2422 q2 = q2 * 2 - 1;
2423 for(k = 1; k < 8; k++)
2424 ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2425 }
2426 }
2427 }
2428
2429 /* apply AC prediction if needed */
2430 if(use_pred) {
2431 if(dc_pred_dir) { //left
2432 for(k = 1; k < 8; k++) {
2433 block[k << 3] = ac_val2[k] * scale;
2434 if(!v->pquantizer && block[k << 3])
2435 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2436 }
2437 } else { //top
2438 for(k = 1; k < 8; k++) {
2439 block[k] = ac_val2[k + 8] * scale;
2440 if(!v->pquantizer && block[k])
2441 block[k] += (block[k] < 0) ? -mquant : mquant;
2442 }
2443 }
2444 i = 63;
2445 }
2446 }
2447 s->block_last_index[n] = i;
2448
2449 return 0;
2450 }
2451
2452 /** Decode P block
2453 */
2454 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
2455 {
2456 MpegEncContext *s = &v->s;
2457 GetBitContext *gb = &s->gb;
2458 int i, j;
2459 int subblkpat = 0;
2460 int scale, off, idx, last, skip, value;
2461 int ttblk = ttmb & 7;
2462
2463 if(ttmb == -1) {
2464 ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
2465 }
2466 if(ttblk == TT_4X4) {
2467 subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
2468 }
2469 if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
2470 subblkpat = decode012(gb);
2471 if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
2472 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
2473 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
2474 }
2475 scale = 2 * mquant + v->halfpq;
2476
2477 // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2478 if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
2479 subblkpat = 2 - (ttblk == TT_8X4_TOP);
2480 ttblk = TT_8X4;
2481 }
2482 if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
2483 subblkpat = 2 - (ttblk == TT_4X8_LEFT);
2484 ttblk = TT_4X8;
2485 }
2486 switch(ttblk) {
2487 case TT_8X8:
2488 i = 0;
2489 last = 0;
2490 while (!last) {
2491 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2492 i += skip;
2493 if(i > 63)
2494 break;
2495 idx = vc1_simple_progressive_8x8_zz[i++];
2496 block[idx] = value * scale;
2497 if(!v->pquantizer)
2498 block[idx] += (block[idx] < 0) ? -mquant : mquant;
2499 }
2500 s->dsp.vc1_inv_trans_8x8(block);
2501 break;
2502 case TT_4X4:
2503 for(j = 0; j < 4; j++) {
2504 last = subblkpat & (1 << (3 - j));
2505 i = 0;
2506 off = (j & 1) * 4 + (j & 2) * 16;
2507 while (!last) {
2508 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2509 i += skip;
2510 if(i > 15)
2511 break;
2512 idx = vc1_simple_progressive_4x4_zz[i++];
2513 block[idx + off] = value * scale;
2514 if(!v->pquantizer)
2515 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2516 }
2517 if(!(subblkpat & (1 << (3 - j))))
2518 s->dsp.vc1_inv_trans_4x4(block, j);
2519 }
2520 break;
2521 case TT_8X4:
2522 for(j = 0; j < 2; j++) {
2523 last = subblkpat & (1 << (1 - j));
2524 i = 0;
2525 off = j * 32;
2526 while (!last) {
2527 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2528 i += skip;
2529 if(i > 31)
2530 break;
2531 idx = vc1_simple_progressive_8x4_zz[i++];
2532 block[idx + off] = value * scale;
2533 if(!v->pquantizer)
2534 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2535 }
2536 if(!(subblkpat & (1 << (1 - j))))
2537 s->dsp.vc1_inv_trans_8x4(block, j);
2538 }
2539 break;
2540 case TT_4X8:
2541 for(j = 0; j < 2; j++) {
2542 last = subblkpat & (1 << (1 - j));
2543 i = 0;
2544 off = j * 4;
2545 while (!last) {
2546 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2547 i += skip;
2548 if(i > 31)
2549 break;
2550 idx = vc1_simple_progressive_4x8_zz[i++];
2551 block[idx + off] = value * scale;
2552 if(!v->pquantizer)
2553 block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
2554 }
2555 if(!(subblkpat & (1 << (1 - j))))
2556 s->dsp.vc1_inv_trans_4x8(block, j);
2557 }
2558 break;
2559 }
2560 return 0;
2561 }
2562
2563
2564 /** Decode one P-frame MB (in Simple/Main profile)
2565 * @todo TODO: Extend to AP
2566 * @fixme FIXME: DC value for inter blocks not set
2567 */
2568 static int vc1_decode_p_mb(VC1Context *v)
2569 {
2570 MpegEncContext *s = &v->s;
2571 GetBitContext *gb = &s->gb;
2572 int i, j;
2573 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2574 int cbp; /* cbp decoding stuff */
2575 int mqdiff, mquant; /* MB quantization */
2576 int ttmb = v->ttfrm; /* MB Transform type */
2577 int status;
2578
2579 static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2580 offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2581 int mb_has_coeffs = 1; /* last_flag */
2582 int dmv_x, dmv_y; /* Differential MV components */
2583 int index, index1; /* LUT indices */
2584 int val, sign; /* temp values */
2585 int first_block = 1;
2586 int dst_idx, off;
2587 int skipped, fourmv;
2588
2589 mquant = v->pq; /* Loosy initialization */
2590
2591 if (v->mv_type_is_raw)
2592 fourmv = get_bits1(gb);
2593 else
2594 fourmv = v->mv_type_mb_plane[mb_pos];
2595 if (v->skip_is_raw)
2596 skipped = get_bits1(gb);
2597 else
2598 skipped = v->s.mbskip_table[mb_pos];
2599
2600 s->dsp.clear_blocks(s->block[0]);
2601
2602 if (!fourmv) /* 1MV mode */
2603 {
2604 if (!skipped)
2605 {
2606 GET_MVDATA(dmv_x, dmv_y);
2607
2608 s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
2609 vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
2610
2611 /* FIXME Set DC val for inter block ? */
2612 if (s->mb_intra && !mb_has_coeffs)
2613 {
2614 GET_MQUANT();
2615 s->ac_pred = get_bits(gb, 1);
2616 cbp = 0;
2617 }
2618 else if (mb_has_coeffs)
2619 {
2620 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2621 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2622 GET_MQUANT();
2623 }
2624 else
2625 {
2626 mquant = v->pq;
2627 cbp = 0;
2628 }
2629 s->current_picture.qscale_table[mb_pos] = mquant;
2630
2631 if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2632 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2633 VC1_TTMB_VLC_BITS, 2);
2634 if(!s->mb_intra) vc1_mc_1mv(v, 0);
2635 dst_idx = 0;
2636 for (i=0; i<6; i++)
2637 {
2638 s->dc_val[0][s->block_index[i]] = 0;
2639 dst_idx += i >> 2;
2640 val = ((cbp >> (5 - i)) & 1);
2641 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2642 v->mb_type[0][s->block_index[i]] = s->mb_intra;
2643 if(s->mb_intra) {
2644 /* check if prediction blocks A and C are available */
2645 v->a_avail = v->c_avail = 0;
2646 if(i == 2 || i == 3 || !s->first_slice_line)
2647 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2648 if(i == 1 || i == 3 || s->mb_x)
2649 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2650
2651 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2652 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
2653 s->dsp.vc1_inv_trans_8x8(s->block[i]);
2654 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
2655 for(j = 0; j < 64; j++) s->block[i][j] += 128;
2656 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2657 /* TODO: proper loop filtering */
2658 if(v->pq >= 9 && v->overlap) {
2659 if(v->a_avail)
2660 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1));
2661 if(v->c_avail)
2662 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1));
2663 }
2664 } else if(val) {
2665 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2666 if(!v->ttmbf && ttmb < 8) ttmb = -1;
2667 first_block = 0;
2668 if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
2669 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2670 }
2671 }
2672 }
2673 else //Skipped
2674 {
2675 s->mb_intra = 0;
2676 for(i = 0; i < 6; i++) {
2677 v->mb_type[0][s->block_index[i]] = 0;
2678 s->dc_val[0][s->block_index[i]] = 0;
2679 }
2680 s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
2681 s->current_picture.qscale_table[mb_pos] = 0;
2682 vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
2683 vc1_mc_1mv(v, 0);
2684 return 0;
2685 }
2686 } //1MV mode
2687 else //4MV mode
2688 {
2689 if (!skipped /* unskipped MB */)
2690 {
2691 int intra_count = 0, coded_inter = 0;
2692 int is_intra[6], is_coded[6];
2693 /* Get CBPCY */
2694 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2695 for (i=0; i<6; i++)
2696 {
2697 val = ((cbp >> (5 - i)) & 1);
2698 s->dc_val[0][s->block_index[i]] = 0;
2699 s->mb_intra = 0;
2700 if(i < 4) {
2701 dmv_x = dmv_y = 0;
2702 s->mb_intra = 0;
2703 mb_has_coeffs = 0;
2704 if(val) {
2705 GET_MVDATA(dmv_x, dmv_y);
2706 }
2707 vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
2708 if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
2709 intra_count += s->mb_intra;
2710 is_intra[i] = s->mb_intra;
2711 is_coded[i] = mb_has_coeffs;
2712 }
2713 if(i&4){
2714 is_intra[i] = (intra_count >= 3);
2715 is_coded[i] = val;
2716 }
2717 if(i == 4) vc1_mc_4mv_chroma(v);
2718 v->mb_type[0][s->block_index[i]] = is_intra[i];
2719 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
2720 }
2721 // if there are no coded blocks then don't do anything more
2722 if(!intra_count && !coded_inter) return 0;
2723 dst_idx = 0;
2724 GET_MQUANT();
2725 s->current_picture.qscale_table[mb_pos] = mquant;
2726 /* test if block is intra and has pred */
2727 {
2728 int intrapred = 0;
2729 for(i=0; i<6; i++)
2730 if(is_intra[i]) {
2731 if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
2732 || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
2733 intrapred = 1;
2734 break;
2735 }
2736 }
2737 if(intrapred)s->ac_pred = get_bits(gb, 1);
2738 else s->ac_pred = 0;
2739 }
2740 if (!v->ttmbf && coded_inter)
2741 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
2742 for (i=0; i<6; i++)
2743 {
2744 dst_idx += i >> 2;
2745 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2746 s->mb_intra = is_intra[i];
2747 if (is_intra[i]) {
2748 /* check if prediction blocks A and C are available */
2749 v->a_avail = v->c_avail = 0;
2750 if(i == 2 || i == 3 || !s->first_slice_line)
2751 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2752 if(i == 1 || i == 3 || s->mb_x)
2753 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2754
2755 vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
2756 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
2757 s->dsp.vc1_inv_trans_8x8(s->block[i]);
2758 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
2759 for(j = 0; j < 64; j++) s->block[i][j] += 128;
2760 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2761 /* TODO: proper loop filtering */
2762 if(v->pq >= 9 && v->overlap) {
2763 if(v->a_avail)
2764 s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? ((i&1)>>1) : (s->mb_y&1));
2765 if(v->c_avail)
2766 s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), (i<4) ? (i&1) : (s->mb_x&1));
2767 }
2768 } else if(is_coded[i]) {
2769 status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2770 if(!v->ttmbf && ttmb < 8) ttmb = -1;
2771 first_block = 0;
2772 if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
2773 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2774 }
2775 }
2776 return status;
2777 }
2778 else //Skipped MB
2779 {
2780 s->mb_intra = 0;
2781 s->current_picture.qscale_table[mb_pos] = 0;
2782 for (i=0; i<6; i++) {
2783 v->mb_type[0][s->block_index[i]] = 0;
2784 s->dc_val[0][s->block_index[i]] = 0;
2785 }
2786 for (i=0; i<4; i++)
2787 {
2788 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
2789 vc1_mc_4mv_luma(v, i);
2790 }
2791 vc1_mc_4mv_chroma(v);
2792 s->current_picture.qscale_table[mb_pos] = 0;
2793 return 0;
2794 }
2795 }
2796
2797 /* Should never happen */
2798 return -1;
2799 }
2800
2801 /** Decode one B-frame MB (in Main profile)
2802 */
2803 static void vc1_decode_b_mb(VC1Context *v)
2804 {
2805 MpegEncContext *s = &v->s;
2806 GetBitContext *gb = &s->gb;
2807 int i, j;
2808 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2809 int cbp = 0; /* cbp decoding stuff */
2810 int mqdiff, mquant; /* MB quantization */
2811 int ttmb = v->ttfrm; /* MB Transform type */
2812
2813 static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2814 offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2815 int mb_has_coeffs = 0; /* last_flag */
2816 int index, index1; /* LUT indices */
2817 int val, sign; /* temp values */
2818 int first_block = 1;
2819 int dst_idx, off;
2820 int skipped, direct;
2821 int dmv_x[2], dmv_y[2];
2822 int bmvtype = BMV_TYPE_BACKWARD; /* XXX: is it so? */
2823
2824 mquant = v->pq; /* Loosy initialization */
2825 s->mb_intra = 0;
2826
2827 if (v->dmb_is_raw)
2828 direct = get_bits1(gb);
2829 else
2830 direct = v->direct_mb_plane[mb_pos];
2831 if (v->skip_is_raw)
2832 skipped = get_bits1(gb);
2833 else
2834 skipped = v->s.mbskip_table[mb_pos];
2835
2836 s->dsp.clear_blocks(s->block[0]);
2837 dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
2838 for(i = 0; i < 6; i++) {
2839 v->mb_type[0][s->block_index[i]] = 0;
2840 s->dc_val[0][s->block_index[i]] = 0;
2841 }
2842 s->current_picture.qscale_table[mb_pos] = 0;
2843
2844 if (!direct) {
2845 if (!skipped) {
2846 GET_MVDATA(dmv_x[0], dmv_y[0]);
2847 dmv_x[1] = dmv_x[0];
2848 dmv_y[1] = dmv_y[0];
2849 }
2850 if(skipped || !s->mb_intra) {
2851 bmvtype = decode012(gb);
2852 switch(bmvtype) {
2853 case 0:
2854 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
2855 break;
2856 case 1:
2857 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
2858 break;
2859 case 2:
2860 bmvtype = BMV_TYPE_INTERPOLATED;
2861 }
2862 }
2863 }
2864 if (skipped) {
2865 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
2866 return;
2867 }
2868 if (direct) {
2869 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2870 GET_MQUANT();
2871 s->mb_intra = 0;
2872 mb_has_coeffs = 0;
2873 s->current_picture.qscale_table[mb_pos] = mquant;
2874 if(!v->ttmbf)
2875 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
2876 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
2877 } else {
2878 if(!mb_has_coeffs && !s->mb_intra) {
2879 /* no coded blocks - effectively skipped */
2880 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
2881 return;
2882 }
2883 if(s->mb_intra && !mb_has_coeffs) {
2884 GET_MQUANT();
2885 s->current_picture.qscale_table[mb_pos] = mquant;
2886 s->ac_pred = get_bits1(gb);
2887 cbp = 0;
2888 } else {
2889 if(bmvtype == BMV_TYPE_INTERPOLATED) {
2890 GET_MVDATA(dmv_x[1], dmv_y[1]);
2891 if(!mb_has_coeffs) {
2892 /* interpolated skipped block */
2893 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
2894 return;
2895 }
2896 }
2897 if(!s->mb_intra)
2898 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
2899 if(s->mb_intra)
2900 s->ac_pred = get_bits1(gb);
2901 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2902 GET_MQUANT();
2903 s->current_picture.qscale_table[mb_pos] = mquant;
2904 if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2905 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
2906 }
2907 }
2908 dst_idx = 0;
2909 for (i=0; i<6; i++)
2910 {
2911 s->dc_val[0][s->block_index[i]] = 0;
2912 dst_idx += i >> 2;
2913 val = ((cbp >> (5 - i)) & 1);
2914 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2915 v->mb_type[0][s->block_index[i]] = s->mb_intra;
2916 if(s->mb_intra) {
2917 /* check if prediction blocks A and C are available */
2918 v->a_avail = v->c_avail = 0;
2919 if(i == 2 || i == 3 || !s->first_slice_line)
2920 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2921 if(i == 1 || i == 3 || s->mb_x)
2922 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2923
2924 vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2925 if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
2926 s->dsp.vc1_inv_trans_8x8(s->block[i]);
2927 if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
2928 for(j = 0; j < 64; j++) s->block[i][j] += 128;
2929 s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2930 } else if(val) {
2931 vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2932 if(!v->ttmbf && ttmb < 8) ttmb = -1;
2933 first_block = 0;
2934 if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
2935 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2936 }
2937 }
2938 }
2939
2940 /** Decode blocks of I-frame
2941 */
2942 static void vc1_decode_i_blocks(VC1Context *v)
2943 {
2944 int k, j;
2945 MpegEncContext *s = &v->s;
2946 int cbp, val;
2947 uint8_t *coded_val;
2948 int mb_pos;
2949
2950 /* select codingmode used for VLC tables selection */
2951 switch(v->y_ac_table_index){
2952 case 0:
2953 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2954 break;
2955 case 1:
2956 v->codingset = CS_HIGH_MOT_INTRA;
2957 break;
2958 case 2:
2959 v->codingset = CS_MID_RATE_INTRA;
2960 break;
2961 }
2962
2963 switch(v->c_ac_table_index){
2964 case 0:
2965 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2966 break;
2967 case 1:
2968 v->codingset2 = CS_HIGH_MOT_INTER;
2969 break;
2970 case 2:
2971 v->codingset2 = CS_MID_RATE_INTER;
2972 break;
2973 }
2974
2975 /* Set DC scale - y and c use the same */
2976 s->y_dc_scale = s->y_dc_scale_table[v->pq];
2977 s->c_dc_scale = s->c_dc_scale_table[v->pq];
2978
2979 //do frame decode
2980 s->mb_x = s->mb_y = 0;
2981 s->mb_intra = 1;
2982 s->first_slice_line = 1;
2983 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2984 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2985 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2986 ff_init_block_index(s);
2987 ff_update_block_index(s);
2988 s->dsp.clear_blocks(s->block[0]);
2989 mb_pos = s->mb_x + s->mb_y * s->mb_width;
2990 s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2991 s->current_picture.qscale_table[mb_pos] = v->pq;
2992
2993 // do actual MB decoding and displaying
2994 cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2995 v->s.ac_pred = get_bits(&v->s.gb, 1);
2996
2997 for(k = 0; k < 6; k++) {
2998 val = ((cbp >> (5 - k)) & 1);
2999
3000 if (k < 4) {
3001 int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3002 val = val ^ pred;
3003 *coded_val = val;
3004 }
3005 cbp |= val << (5 - k);
3006
3007 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
3008
3009 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3010 if(v->pq >= 9 && v->overlap) {
3011 for(j = 0; j < 64; j++) s->block[k][j] += 128;
3012 }
3013 }
3014
3015 vc1_put_block(v, s->block);
3016 if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
3017 if(!s->first_slice_line) {
3018 s->dsp.vc1_v_overlap(s->dest[0], s->linesize, 0);
3019 s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize, 0);
3020 if(!(s->flags & CODEC_FLAG_GRAY)) {
3021 s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize, s->mb_y&1);
3022 s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize, s->mb_y&1);
3023 }
3024 }
3025 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 1);
3026 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
3027 if(s->mb_x) {
3028 s->dsp.vc1_h_overlap(s->dest[0], s->linesize, 0);
3029 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize, 0);
3030 if(!(s->flags & CODEC_FLAG_GRAY)) {
3031 s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize, s->mb_x&1);
3032 s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize, s->mb_x&1);
3033 }
3034 }
3035 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize, 1);
3036 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize, 1);
3037 }
3038
3039 if(get_bits_count(&s->gb) > v->bits) {
3040 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3041 return;
3042 }
3043 }
3044 ff_draw_horiz_band(s, s->mb_y * 16, 16);
3045 s->first_slice_line = 0;
3046 }
3047 }
3048
3049 static void vc1_decode_p_blocks(VC1Context *v)
3050 {
3051 MpegEncContext *s = &v->s;
3052
3053 /* select codingmode used for VLC tables selection */
3054 switch(v->c_ac_table_index){
3055 case 0:
3056 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3057 break;
3058 case 1:
3059 v->codingset = CS_HIGH_MOT_INTRA;
3060 break;
3061 case 2:
3062 v->codingset = CS_MID_RATE_INTRA;
3063 break;
3064 }
3065
3066 switch(v->c_ac_table_index){
3067 case 0:
3068 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3069 break;
3070 case 1:
3071 v->codingset2 = CS_HIGH_MOT_INTER;
3072 break;
3073 case 2:
3074 v->codingset2 = CS_MID_RATE_INTER;
3075 break;
3076 }
3077
3078 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3079 s->first_slice_line = 1;
3080 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3081 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3082 ff_init_block_index(s);
3083 ff_update_block_index(s);
3084 s->dsp.clear_blocks(s->block[0]);
3085
3086 vc1_decode_p_mb(v);
3087 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
3088 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
3089 return;
3090 }
3091 }
3092 ff_draw_horiz_band(s, s->mb_y * 16, 16);
3093 s->first_slice_line = 0;
3094 }
3095 }
3096
3097 static void vc1_decode_b_blocks(VC1Context *v)
3098 {
3099 MpegEncContext *s = &v->s;
3100
3101 /* select codingmode used for VLC tables selection */
3102 switch(v->c_ac_table_index){
3103 case 0:
3104 v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3105 break;
3106 case 1:
3107 v->codingset = CS_HIGH_MOT_INTRA;
3108 break;
3109 case 2:
3110 v->codingset = CS_MID_RATE_INTRA;
3111 break;
3112 }
3113
3114 switch(v->c_ac_table_index){
3115 case 0:
3116 v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3117 break;
3118 case 1:
3119 v->codingset2 = CS_HIGH_MOT_INTER;
3120 break;
3121 case 2:
3122 v->codingset2 = CS_MID_RATE_INTER;
3123 break;
3124 }
3125
3126 ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3127 s->first_slice_line = 1;
3128 for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3129 for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3130 ff_init_block_index(s);
3131 ff_update_block_index(s);
3132 s->dsp.clear_blocks(s->block[0]);
3133
3134 vc1_decode_b_mb(v);
3135 if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
3136 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
3137 return;
3138 }
3139 }
3140 ff_draw_horiz_band(s, s->mb_y * 16, 16);
3141 s->first_slice_line = 0;
3142 }
3143 }
3144
3145 static void vc1_decode_blocks(VC1Context *v)
3146 {
3147
3148 v->s.esc3_level_length = 0;
3149
3150 switch(v->s.pict_type) {
3151 case I_TYPE:
3152 vc1_decode_i_blocks(v);
3153 break;
3154 case P_TYPE:
3155 vc1_decode_p_blocks(v);
3156 break;
3157 case B_TYPE:
3158 vc1_decode_b_blocks(v);
3159 break;
3160 }
3161 }
3162
3163
3164 /** Initialize a VC1/WMV3 decoder
3165 * @todo TODO: Handle VC-1 IDUs (Transport level?)
3166 * @todo TODO: Decypher remaining bits in extra_data
3167 */
3168 static int vc1_decode_init(AVCodecContext *avctx)
3169 {
3170 VC1Context *v = avctx->priv_data;
3171 MpegEncContext *s = &v->s;
3172 GetBitContext gb;
3173
3174 if (!avctx->extradata_size || !avctx->extradata) return -1;
3175 if (!(avctx->flags & CODEC_FLAG_GRAY))
3176 avctx->pix_fmt = PIX_FMT_YUV420P;
3177 else
3178 avctx->pix_fmt = PIX_FMT_GRAY8;
3179 v->s.avctx = avctx;
3180 avctx->flags |= CODEC_FLAG_EMU_EDGE;
3181 v->s.flags |= CODEC_FLAG_EMU_EDGE;
3182
3183 if(ff_h263_decode_init(avctx) < 0)
3184 return -1;
3185 if (vc1_init_common(v) < 0) return -1;
3186
3187 avctx->coded_width = avctx->width;
3188 avctx->coded_height = avctx->height;
3189 if (avctx->codec_id == CODEC_ID_WMV3)
3190 {
3191 int count = 0;
3192
3193 // looks like WMV3 has a sequence header stored in the extradata
3194 // advanced sequence header may be before the first frame
3195 // the last byte of the extradata is a version number, 1 for the
3196 // samples we can decode
3197
3198 init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
3199
3200 if (decode_sequence_header(avctx, &gb) < 0)
3201 return -1;
3202
3203 count = avctx->extradata_size*8 - get_bits_count(&gb);
3204 if (count>0)
3205 {
3206 av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
3207 count, get_bits(&gb, count));
3208 }
3209 else if (count < 0)
3210 {
3211 av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
3212 }
3213 }
3214 avctx->has_b_frames= !!(avctx->max_b_frames);
3215
3216 s->mb_width = (avctx->coded_width+15)>>4;
3217 s->mb_height = (avctx->coded_height+15)>>4;
3218
3219 /* Allocate mb bitplanes */
3220 v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
3221 v->direct_mb_plane = av_malloc(s->mb_stride * s->mb_height);
3222
3223 /* allocate block type info in that way so it could be used with s->block_index[] */
3224 v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
3225 v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
3226 v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
3227 v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
3228
3229 /* Init coded blocks info */
3230 if (v->profile == PROFILE_ADVANCED)
3231 {
3232 // if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
3233 // return -1;
3234 // if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
3235 // return -1;
3236 }
3237
3238 return 0;
3239 }
3240
3241
3242 /** Decode a VC1/WMV3 frame
3243 * @todo TODO: Handle VC-1 IDUs (Transport level?)
3244 * @warning Initial try at using MpegEncContext stuff
3245 */
3246 static int vc1_decode_frame(AVCodecContext *avctx,
3247 void *data, int *data_size,
3248 uint8_t *buf, int buf_size)
3249 {
3250 VC1Context *v = avctx->priv_data;
3251 MpegEncContext *s = &v->s;
3252 AVFrame *pict = data;
3253
3254 /* no supplementary picture */
3255 if (buf_size == 0) {
3256 /* special case for last picture */
3257 if (s->low_delay==0 && s->next_picture_ptr) {
3258 *pict= *(AVFrame*)s->next_picture_ptr;
3259 s->next_picture_ptr= NULL;
3260
3261 *data_size = sizeof(AVFrame);
3262 }
3263
3264 return 0;
3265 }
3266
3267 //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
3268 if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
3269 int i= ff_find_unused_picture(s, 0);
3270 s->current_picture_ptr= &s->picture[i];
3271 }
3272
3273 avctx->has_b_frames= !s->low_delay;
3274
3275 init_get_bits(&s->gb, buf, buf_size*8);
3276 // do parse frame header
3277 if(vc1_parse_frame_header(v, &s->gb) == -1)
3278 return -1;
3279
3280 if(s->pict_type != I_TYPE && !v->res_rtm_flag)return -1;
3281 if(s->pict_type == B_TYPE)return -1;
3282
3283 // for hurry_up==5
3284 s->current_picture.pict_type= s->pict_type;
3285 s->current_picture.key_frame= s->pict_type == I_TYPE;
3286
3287 /* skip B-frames if we don't have reference frames */
3288 if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return -1;//buf_size;
3289 /* skip b frames if we are in a hurry */
3290 if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
3291 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
3292 || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
3293 || avctx->skip_frame >= AVDISCARD_ALL)
3294 return buf_size;
3295 /* skip everything if we are in a hurry>=5 */
3296 if(avctx->hurry_up>=5) return -1;//buf_size;
3297
3298 if(s->next_p_frame_damaged){
3299 if(s->pict_type==B_TYPE)
3300 return buf_size;
3301 else
3302 s->next_p_frame_damaged=0;
3303 }
3304
3305 if(MPV_frame_start(s, avctx) < 0)
3306 return -1;
3307
3308 ff_er_frame_start(s);
3309
3310 v->bits = buf_size * 8;
3311 vc1_decode_blocks(v);
3312 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
3313 // if(get_bits_count(&s->gb) > buf_size * 8)
3314 // return -1;
3315 ff_er_frame_end(s);
3316
3317 MPV_frame_end(s);
3318
3319 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
3320 assert(s->current_picture.pict_type == s->pict_type);
3321 if (s->pict_type == B_TYPE || s->low_delay) {
3322 *pict= *(AVFrame*)s->current_picture_ptr;
3323 } else if (s->last_picture_ptr != NULL) {
3324 *pict= *(AVFrame*)s->last_picture_ptr;
3325 }
3326
3327 if(s->last_picture_ptr || s->low_delay){
3328 *data_size = sizeof(AVFrame);
3329 ff_print_debug_info(s, pict);
3330 }
3331
3332 /* Return the Picture timestamp as the frame number */
3333 /* we substract 1 because it is added on utils.c */
3334 avctx->frame_number = s->picture_number - 1;
3335
3336 return buf_size;
3337 }
3338
3339
3340 /** Close a VC1/WMV3 decoder
3341 * @warning Initial try at using MpegEncContext stuff
3342 */
3343 static int vc1_decode_end(AVCodecContext *avctx)
3344 {
3345 VC1Context *v = avctx->priv_data;
3346
3347 av_freep(&v->hrd_rate);
3348 av_freep(&v->hrd_buffer);
3349 MPV_common_end(&v->s);
3350 av_freep(&v->mv_type_mb_plane);
3351 av_freep(&v->direct_mb_plane);
3352 av_freep(&v->mb_type_base);
3353 return 0;
3354 }
3355
3356
3357 AVCodec vc1_decoder = {
3358 "vc1",
3359 CODEC_TYPE_VIDEO,
3360 CODEC_ID_VC1,
3361 sizeof(VC1Context),
3362 vc1_decode_init,
3363 NULL,
3364 vc1_decode_end,
3365 vc1_decode_frame,
3366 CODEC_CAP_DELAY,
3367 NULL
3368 };
3369
3370 AVCodec wmv3_decoder = {
3371 "wmv3",
3372 CODEC_TYPE_VIDEO,
3373 CODEC_ID_WMV3,
3374 sizeof(VC1Context),
3375 vc1_decode_init,
3376 NULL,
3377 vc1_decode_end,
3378 vc1_decode_frame,
3379 CODEC_CAP_DELAY,
3380 NULL
3381 };
ffmpeg with support for matroska ordered chapters