ffmpeg / libavcodec / vc1.c @ 3f6d6af6
History  View  Annotate  Download (84.9 KB)
1 
/*


2 
* VC1 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 021101301 USA

19 
*

20 
*/

21  
22 
/**

23 
* @file vc1.c

24 
* VC1 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, ///< Nonuniform 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 = 3 //XXX: ?? 
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 
/** MV P mode  the 5th element is only used for mode 1 */

141 
static const uint8_t mv_pmode_table[2][5] = { 
142 
{ MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV }, 
143 
{ MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN } 
144 
}; 
145  
146 
/** One more frame type */

147 
#define BI_TYPE 7 
148  
149 
static const int fps_nr[5] = { 24, 25, 30, 50, 60 }, 
150 
fps_dr[2] = { 1000, 1001 }; 
151 
static const uint8_t pquant_table[3][32] = { 
152 
{ /* Implicit quantizer */

153 
0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 7, 8, 9, 10, 11, 12, 
154 
13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31 
155 
}, 
156 
{ /* Explicit quantizer, pquantizer uniform */

157 
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 
158 
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 
159 
}, 
160 
{ /* Explicit quantizer, pquantizer nonuniform */

161 
0, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 
162 
14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31 
163 
} 
164 
}; 
165  
166 
/** @name VC1 VLC tables and defines

167 
* @todo TODO move this into the context

168 
*/

169 
//@{

170 
#define VC1_BFRACTION_VLC_BITS 7 
171 
static VLC vc1_bfraction_vlc;

172 
#define VC1_IMODE_VLC_BITS 4 
173 
static VLC vc1_imode_vlc;

174 
#define VC1_NORM2_VLC_BITS 3 
175 
static VLC vc1_norm2_vlc;

176 
#define VC1_NORM6_VLC_BITS 9 
177 
static VLC vc1_norm6_vlc;

178 
/* Could be optimized, one table only needs 8 bits */

179 
#define VC1_TTMB_VLC_BITS 9 //12 
180 
static VLC vc1_ttmb_vlc[3]; 
181 
#define VC1_MV_DIFF_VLC_BITS 9 //15 
182 
static VLC vc1_mv_diff_vlc[4]; 
183 
#define VC1_CBPCY_P_VLC_BITS 9 //14 
184 
static VLC vc1_cbpcy_p_vlc[4]; 
185 
#define VC1_4MV_BLOCK_PATTERN_VLC_BITS 6 
186 
static VLC vc1_4mv_block_pattern_vlc[4]; 
187 
#define VC1_TTBLK_VLC_BITS 5 
188 
static VLC vc1_ttblk_vlc[3]; 
189 
#define VC1_SUBBLKPAT_VLC_BITS 6 
190 
static VLC vc1_subblkpat_vlc[3]; 
191  
192 
static VLC vc1_ac_coeff_table[8]; 
193 
//@}

194  
195 
enum CodingSet {

196 
CS_HIGH_MOT_INTRA = 0,

197 
CS_HIGH_MOT_INTER, 
198 
CS_LOW_MOT_INTRA, 
199 
CS_LOW_MOT_INTER, 
200 
CS_MID_RATE_INTRA, 
201 
CS_MID_RATE_INTER, 
202 
CS_HIGH_RATE_INTRA, 
203 
CS_HIGH_RATE_INTER 
204 
}; 
205  
206 
/** The VC1 Context

207 
* @fixme Change size wherever another size is more efficient

208 
* Many members are only used for Advanced Profile

209 
*/

210 
typedef struct VC1Context{ 
211 
MpegEncContext s; 
212  
213 
int bits;

214  
215 
/** Simple/Main Profile sequence header */

216 
//@{

217 
int res_sm; ///< reserved, 2b 
218 
int res_x8; ///< reserved 
219 
int multires; ///< framelevel RESPIC syntax element present 
220 
int res_fasttx; ///< reserved, always 1 
221 
int res_transtab; ///< reserved, always 0 
222 
int rangered; ///< RANGEREDFRM (range reduction) syntax element present 
223 
///< at frame level

224 
int res_rtm_flag; ///< reserved, set to 1 
225 
int reserved; ///< reserved 
226 
//@}

227  
228 
/** Advanced Profile */

229 
//@{

230 
int level; ///< 3bits, for Advanced/Simple Profile, provided by TS layer 
231 
int chromaformat; ///< 2bits, 2=4:2:0, only defined 
232 
int postprocflag; ///< Perframe processing suggestion flag present 
233 
int broadcast; ///< TFF/RFF present 
234 
int interlace; ///< Progressive/interlaced (RPTFTM syntax element) 
235 
int tfcntrflag; ///< TFCNTR present 
236 
int panscanflag; ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present 
237 
int extended_dmv; ///< Additional extended dmv range at P/B framelevel 
238 
int color_prim; ///< 8bits, chroma coordinates of the color primaries 
239 
int transfer_char; ///< 8bits, Optoelectronic transfer characteristics 
240 
int matrix_coef; ///< 8bits, Color primaries>YCbCr transform matrix 
241 
int hrd_param_flag; ///< Presence of Hypothetical Reference 
242 
///< Decoder parameters

243 
//@}

244  
245 
/** Sequence header data for all Profiles

246 
* TODO: choose between ints, uint8_ts and monobit flags

247 
*/

248 
//@{

249 
int profile; ///< 2bits, Profile 
250 
int frmrtq_postproc; ///< 3bits, 
251 
int bitrtq_postproc; ///< 5bits, quantized frameratebased postprocessing strength 
252 
int fastuvmc; ///< Rounding of qpel vector to hpel ? (not in Simple) 
253 
int extended_mv; ///< Ext MV in P/B (not in Simple) 
254 
int dquant; ///< How qscale varies with MBs, 2bits (not in Simple) 
255 
int vstransform; ///< variablesize [48]x[48] transform type + info 
256 
int overlap; ///< overlapped transforms in use 
257 
int quantizer_mode; ///< 2bits, quantizer mode used for sequence, see QUANT_* 
258 
int finterpflag; ///< INTERPFRM present 
259 
//@}

260  
261 
/** Frame decoding info for all profiles */

262 
//@{

263 
uint8_t mv_mode; ///< MV coding monde

264 
uint8_t mv_mode2; ///< Secondary MV coding mode (B frames)

265 
int k_x; ///< Number of bits for MVs (depends on MV range) 
266 
int k_y; ///< Number of bits for MVs (depends on MV range) 
267 
int range_x, range_y; ///< MV range 
268 
uint8_t pq, altpq; ///< Current/alternate frame quantizer scale

269 
/** pquant parameters */

270 
//@{

271 
uint8_t dquantfrm; 
272 
uint8_t dqprofile; 
273 
uint8_t dqsbedge; 
274 
uint8_t dqbilevel; 
275 
//@}

276 
/** AC coding set indexes

277 
* @see 8.1.1.10, p(1)10

278 
*/

279 
//@{

280 
int c_ac_table_index; ///< Chroma index from ACFRM element 
281 
int y_ac_table_index; ///< Luma index from AC2FRM element 
282 
//@}

283 
int ttfrm; ///< Transform type info present at frame level 
284 
uint8_t ttmbf; ///< Transform type flag

285 
int ttmb; ///< Transform type 
286 
uint8_t ttblk4x4; ///< Value of ttblk which indicates a 4x4 transform

287 
int codingset; ///< index of current table set from 11.8 to use for luma block decoding 
288 
int codingset2; ///< index of current table set from 11.8 to use for chroma block decoding 
289 
int pqindex; ///< raw pqindex used in coding set selection 
290 
int a_avail, c_avail;

291  
292  
293 
/** Luma compensation parameters */

294 
//@{

295 
uint8_t lumscale; 
296 
uint8_t lumshift; 
297 
//@}

298 
int16_t bfraction; ///< Relative position % anchors=> how to scale MVs

299 
uint8_t halfpq; ///< Uniform quant over image and qp+.5

300 
uint8_t respic; ///< Framelevel flag for resized images

301 
int buffer_fullness; ///< HRD info 
302 
/** Ranges:

303 
* # 0 > [64n 63.f] x [32, 31.f]

304 
* # 1 > [128, 127.f] x [64, 63.f]

305 
* # 2 > [512, 511.f] x [128, 127.f]

306 
* # 3 > [1024, 1023.f] x [256, 255.f]

307 
*/

308 
uint8_t mvrange; 
309 
uint8_t pquantizer; ///< Uniform (over sequence) quantizer in use

310 
uint8_t *previous_line_cbpcy; ///< To use for predicted CBPCY

311 
VLC *cbpcy_vlc; ///< CBPCY VLC table

312 
int tt_index; ///< Index for Transform Type tables 
313 
uint8_t* mv_type_mb_plane; ///< bitplane for mv_type == (4MV)

314 
uint8_t* skip_mb_plane; ///< bitplane for skipped MBs

315 
// BitPlane direct_mb_plane; ///< bitplane for "direct" MBs

316 
int mv_type_is_raw; ///< mv type mb plane is not coded 
317 
int skip_is_raw; ///< skip mb plane is not coded 
318  
319 
/** Frame decoding info for S/M profiles only */

320 
//@{

321 
uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample128)*2+128)

322 
uint8_t interpfrm; 
323 
//@}

324  
325 
/** Frame decoding info for Advanced profile */

326 
//@{

327 
uint8_t fcm; ///< 0>Progressive, 2>FrameInterlace, 3>FieldInterlace

328 
uint8_t numpanscanwin; 
329 
uint8_t tfcntr; 
330 
uint8_t rptfrm, tff, rff; 
331 
uint16_t topleftx; 
332 
uint16_t toplefty; 
333 
uint16_t bottomrightx; 
334 
uint16_t bottomrighty; 
335 
uint8_t uvsamp; 
336 
uint8_t postproc; 
337 
int hrd_num_leaky_buckets;

338 
uint8_t bit_rate_exponent; 
339 
uint8_t buffer_size_exponent; 
340 
// BitPlane ac_pred_plane; ///< AC prediction flags bitplane

341 
// BitPlane over_flags_plane; ///< Overflags bitplane

342 
uint8_t condover; 
343 
uint16_t *hrd_rate, *hrd_buffer; 
344 
uint8_t *hrd_fullness; 
345 
uint8_t range_mapy_flag; 
346 
uint8_t range_mapuv_flag; 
347 
uint8_t range_mapy; 
348 
uint8_t range_mapuv; 
349 
//@}

350 
} VC1Context; 
351  
352 
/**

353 
* Get unary code of limited length

354 
* @fixme FIXME Slow and ugly

355 
* @param gb GetBitContext

356 
* @param[in] stop The bitstop value (unary code of 1's or 0's)

357 
* @param[in] len Maximum length

358 
* @return Unary length/index

359 
*/

360 
static int get_prefix(GetBitContext *gb, int stop, int len) 
361 
{ 
362 
#if 1 
363 
int i;

364  
365 
for(i = 0; i < len && get_bits1(gb) != stop; i++); 
366 
return i;

367 
/* int i = 0, tmp = !stop;

368 

369 
while (i != len && tmp != stop)

370 
{

371 
tmp = get_bits(gb, 1);

372 
i++;

373 
}

374 
if (i == len && tmp != stop) return len+1;

375 
return i;*/

376 
#else

377 
unsigned int buf; 
378 
int log;

379  
380 
OPEN_READER(re, gb); 
381 
UPDATE_CACHE(re, gb); 
382 
buf=GET_CACHE(re, gb); //Still not sure

383 
if (stop) buf = ~buf;

384  
385 
log= av_log2(buf); //FIXME: ?

386 
if (log < limit){

387 
LAST_SKIP_BITS(re, gb, log+1);

388 
CLOSE_READER(re, gb); 
389 
return log;

390 
} 
391  
392 
LAST_SKIP_BITS(re, gb, limit); 
393 
CLOSE_READER(re, gb); 
394 
return limit;

395 
#endif

396 
} 
397  
398 
static inline int decode210(GetBitContext *gb){ 
399 
int n;

400 
n = get_bits1(gb); 
401 
if (n == 1) 
402 
return 0; 
403 
else

404 
return 2  get_bits1(gb); 
405 
} 
406  
407 
/**

408 
* Init VC1 specific tables and VC1Context members

409 
* @param v The VC1Context to initialize

410 
* @return Status

411 
*/

412 
static int vc1_init_common(VC1Context *v) 
413 
{ 
414 
static int done = 0; 
415 
int i = 0; 
416  
417 
v>hrd_rate = v>hrd_buffer = NULL;

418  
419 
/* VLC tables */

420 
if(!done)

421 
{ 
422 
done = 1;

423 
init_vlc(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,

424 
vc1_bfraction_bits, 1, 1, 
425 
vc1_bfraction_codes, 1, 1, 1); 
426 
init_vlc(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,

427 
vc1_norm2_bits, 1, 1, 
428 
vc1_norm2_codes, 1, 1, 1); 
429 
init_vlc(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,

430 
vc1_norm6_bits, 1, 1, 
431 
vc1_norm6_codes, 2, 2, 1); 
432 
init_vlc(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,

433 
vc1_imode_bits, 1, 1, 
434 
vc1_imode_codes, 1, 1, 1); 
435 
for (i=0; i<3; i++) 
436 
{ 
437 
init_vlc(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,

438 
vc1_ttmb_bits[i], 1, 1, 
439 
vc1_ttmb_codes[i], 2, 2, 1); 
440 
init_vlc(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,

441 
vc1_ttblk_bits[i], 1, 1, 
442 
vc1_ttblk_codes[i], 1, 1, 1); 
443 
init_vlc(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,

444 
vc1_subblkpat_bits[i], 1, 1, 
445 
vc1_subblkpat_codes[i], 1, 1, 1); 
446 
} 
447 
for(i=0; i<4; i++) 
448 
{ 
449 
init_vlc(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,

450 
vc1_4mv_block_pattern_bits[i], 1, 1, 
451 
vc1_4mv_block_pattern_codes[i], 1, 1, 1); 
452 
init_vlc(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,

453 
vc1_cbpcy_p_bits[i], 1, 1, 
454 
vc1_cbpcy_p_codes[i], 2, 2, 1); 
455 
init_vlc(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,

456 
vc1_mv_diff_bits[i], 1, 1, 
457 
vc1_mv_diff_codes[i], 2, 2, 1); 
458 
} 
459 
for(i=0; i<8; i++) 
460 
init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i], 
461 
&vc1_ac_tables[i][0][1], 8, 4, 
462 
&vc1_ac_tables[i][0][0], 8, 4, 1); 
463 
init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,

464 
&ff_msmp4_mb_i_table[0][1], 4, 2, 
465 
&ff_msmp4_mb_i_table[0][0], 4, 2, 1); 
466 
} 
467  
468 
/* Other defaults */

469 
v>pq = 1;

470 
v>mvrange = 0; /* 7.1.1.18, p80 */ 
471  
472 
return 0; 
473 
} 
474  
475 
/***********************************************************************/

476 
/**

477 
* @defgroup bitplane VC9 Bitplane decoding

478 
* @see 8.7, p56

479 
* @{

480 
*/

481  
482 
/** @addtogroup bitplane

483 
* Imode types

484 
* @{

485 
*/

486 
enum Imode {

487 
IMODE_RAW, 
488 
IMODE_NORM2, 
489 
IMODE_DIFF2, 
490 
IMODE_NORM6, 
491 
IMODE_DIFF6, 
492 
IMODE_ROWSKIP, 
493 
IMODE_COLSKIP 
494 
}; 
495 
/** @} */ //imode defines 
496  
497 
/** Decode rows by checking if they are skipped

498 
* @param plane Buffer to store decoded bits

499 
* @param[in] width Width of this buffer

500 
* @param[in] height Height of this buffer

501 
* @param[in] stride of this buffer

502 
*/

503 
static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){ 
504 
int x, y;

505  
506 
for (y=0; y<height; y++){ 
507 
if (!get_bits(gb, 1)) //rowskip 
508 
memset(plane, 0, width);

509 
else

510 
for (x=0; x<width; x++) 
511 
plane[x] = get_bits(gb, 1);

512 
plane += stride; 
513 
} 
514 
} 
515  
516 
/** Decode columns by checking if they are skipped

517 
* @param plane Buffer to store decoded bits

518 
* @param[in] width Width of this buffer

519 
* @param[in] height Height of this buffer

520 
* @param[in] stride of this buffer

521 
* @fixme FIXME: Optimize

522 
*/

523 
static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){ 
524 
int x, y;

525  
526 
for (x=0; x<width; x++){ 
527 
if (!get_bits(gb, 1)) //colskip 
528 
for (y=0; y<height; y++) 
529 
plane[y*stride] = 0;

530 
else

531 
for (y=0; y<height; y++) 
532 
plane[y*stride] = get_bits(gb, 1);

533 
plane ++; 
534 
} 
535 
} 
536  
537 
/** Decode a bitplane's bits

538 
* @param bp Bitplane where to store the decode bits

539 
* @param v VC1 context for bit reading and logging

540 
* @return Status

541 
* @fixme FIXME: Optimize

542 
* @todo TODO: Decide if a struct is needed

543 
*/

544 
static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v) 
545 
{ 
546 
GetBitContext *gb = &v>s.gb; 
547  
548 
int imode, x, y, code, offset;

549 
uint8_t invert, *planep = data; 
550 
int width, height, stride;

551  
552 
width = v>s.mb_width; 
553 
height = v>s.mb_height; 
554 
stride = v>s.mb_stride; 
555 
invert = get_bits(gb, 1);

556 
imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);

557  
558 
*raw_flag = 0;

559 
switch (imode)

560 
{ 
561 
case IMODE_RAW:

562 
//Data is actually read in the MB layer (same for all tests == "raw")

563 
*raw_flag = 1; //invert ignored 
564 
return invert;

565 
case IMODE_DIFF2:

566 
case IMODE_NORM2:

567 
if ((height * width) & 1) 
568 
{ 
569 
*planep++ = get_bits(gb, 1);

570 
offset = 1;

571 
} 
572 
else offset = 0; 
573 
// decode bitplane as one long line

574 
for (y = offset; y < height * width; y += 2) { 
575 
code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);

576 
*planep++ = code & 1;

577 
offset++; 
578 
if(offset == width) {

579 
offset = 0;

580 
planep += stride  width; 
581 
} 
582 
*planep++ = code >> 1;

583 
offset++; 
584 
if(offset == width) {

585 
offset = 0;

586 
planep += stride  width; 
587 
} 
588 
} 
589 
break;

590 
case IMODE_DIFF6:

591 
case IMODE_NORM6:

592 
if(!(height % 3) && (width % 3)) { // use 2x3 decoding 
593 
for(y = 0; y < height; y+= 3) { 
594 
for(x = width & 1; x < width; x += 2) { 
595 
code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);

596 
if(code < 0){ 
597 
av_log(v>s.avctx, AV_LOG_DEBUG, "invalid NORM6 VLC\n");

598 
return 1; 
599 
} 
600 
planep[x + 0] = (code >> 0) & 1; 
601 
planep[x + 1] = (code >> 1) & 1; 
602 
planep[x + 0 + stride] = (code >> 2) & 1; 
603 
planep[x + 1 + stride] = (code >> 3) & 1; 
604 
planep[x + 0 + stride * 2] = (code >> 4) & 1; 
605 
planep[x + 1 + stride * 2] = (code >> 5) & 1; 
606 
} 
607 
planep += stride * 3;

608 
} 
609 
if(width & 1) decode_colskip(data, 1, height, stride, &v>s.gb); 
610 
} else { // 3x2 
611 
for(y = height & 1; y < height; y += 2) { 
612 
for(x = width % 3; x < width; x += 3) { 
613 
code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);

614 
if(code < 0){ 
615 
av_log(v>s.avctx, AV_LOG_DEBUG, "invalid NORM6 VLC\n");

616 
return 1; 
617 
} 
618 
planep[x + 0] = (code >> 0) & 1; 
619 
planep[x + 1] = (code >> 1) & 1; 
620 
planep[x + 2] = (code >> 2) & 1; 
621 
planep[x + 0 + stride] = (code >> 3) & 1; 
622 
planep[x + 1 + stride] = (code >> 4) & 1; 
623 
planep[x + 2 + stride] = (code >> 5) & 1; 
624 
} 
625 
planep += stride * 2;

626 
} 
627 
x = width % 3;

628 
if(x) decode_colskip(data , x, height , stride, &v>s.gb);

629 
if(height & 1) decode_rowskip(data+x, width  x, 1, stride, &v>s.gb); 
630 
} 
631 
break;

632 
case IMODE_ROWSKIP:

633 
decode_rowskip(data, width, height, stride, &v>s.gb); 
634 
break;

635 
case IMODE_COLSKIP:

636 
decode_colskip(data, width, height, stride, &v>s.gb); 
637 
break;

638 
default: break; 
639 
} 
640  
641 
/* Applying diff operator */

642 
if (imode == IMODE_DIFF2  imode == IMODE_DIFF6)

643 
{ 
644 
planep = data; 
645 
planep[0] ^= invert;

646 
for (x=1; x<width; x++) 
647 
planep[x] ^= planep[x1];

648 
for (y=1; y<height; y++) 
649 
{ 
650 
planep += stride; 
651 
planep[0] ^= planep[stride];

652 
for (x=1; x<width; x++) 
653 
{ 
654 
if (planep[x1] != planep[xstride]) planep[x] ^= invert; 
655 
else planep[x] ^= planep[x1]; 
656 
} 
657 
} 
658 
} 
659 
else if (invert) 
660 
{ 
661 
planep = data; 
662 
for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride 
663 
} 
664 
return (imode<<1) + invert; 
665 
} 
666  
667 
/** @} */ //Bitplane group 
668  
669 
/***********************************************************************/

670 
/** VOP Dquant decoding

671 
* @param v VC1 Context

672 
*/

673 
static int vop_dquant_decoding(VC1Context *v) 
674 
{ 
675 
GetBitContext *gb = &v>s.gb; 
676 
int pqdiff;

677  
678 
//variable size

679 
if (v>dquant == 2) 
680 
{ 
681 
pqdiff = get_bits(gb, 3);

682 
if (pqdiff == 7) v>altpq = get_bits(gb, 5); 
683 
else v>altpq = v>pq + pqdiff + 1; 
684 
} 
685 
else

686 
{ 
687 
v>dquantfrm = get_bits(gb, 1);

688 
if ( v>dquantfrm )

689 
{ 
690 
v>dqprofile = get_bits(gb, 2);

691 
switch (v>dqprofile)

692 
{ 
693 
case DQPROFILE_SINGLE_EDGE:

694 
case DQPROFILE_DOUBLE_EDGES:

695 
v>dqsbedge = get_bits(gb, 2);

696 
break;

697 
case DQPROFILE_ALL_MBS:

698 
v>dqbilevel = get_bits(gb, 1);

699 
default: break; //Forbidden ? 
700 
} 
701 
if (!v>dqbilevel  v>dqprofile != DQPROFILE_ALL_MBS)

702 
{ 
703 
pqdiff = get_bits(gb, 3);

704 
if (pqdiff == 7) v>altpq = get_bits(gb, 5); 
705 
else v>altpq = v>pq + pqdiff + 1; 
706 
} 
707 
} 
708 
} 
709 
return 0; 
710 
} 
711  
712  
713 
/** Do inverse transform

714 
*/

715 
static void vc1_inv_trans(DCTELEM block[64], int M, int N) 
716 
{ 
717 
int i;

718 
register int t1,t2,t3,t4,t5,t6,t7,t8; 
719 
DCTELEM *src, *dst; 
720  
721 
src = block; 
722 
dst = block; 
723 
if(M==4){ 
724 
for(i = 0; i < N; i++){ 
725 
t1 = 17 * (src[0] + src[2]); 
726 
t2 = 17 * (src[0]  src[2]); 
727 
t3 = 22 * src[1]; 
728 
t4 = 22 * src[3]; 
729 
t5 = 10 * src[1]; 
730 
t6 = 10 * src[3]; 
731  
732 
dst[0] = (t1 + t3 + t6 + 4) >> 3; 
733 
dst[1] = (t2  t4 + t5 + 4) >> 3; 
734 
dst[2] = (t2 + t4  t5 + 4) >> 3; 
735 
dst[3] = (t1  t3  t6 + 4) >> 3; 
736  
737 
src += 8;

738 
dst += 8;

739 
} 
740 
}else{

741 
for(i = 0; i < N; i++){ 
742 
t1 = 12 * (src[0] + src[4]); 
743 
t2 = 12 * (src[0]  src[4]); 
744 
t3 = 16 * src[2] + 6 * src[6]; 
745 
t4 = 6 * src[2]  16 * src[6]; 
746  
747 
t5 = t1 + t3; 
748 
t6 = t2 + t4; 
749 
t7 = t2  t4; 
750 
t8 = t1  t3; 
751  
752 
t1 = 16 * src[1] + 15 * src[3] + 9 * src[5] + 4 * src[7]; 
753 
t2 = 15 * src[1]  4 * src[3]  16 * src[5]  9 * src[7]; 
754 
t3 = 9 * src[1]  16 * src[3] + 4 * src[5] + 15 * src[7]; 
755 
t4 = 4 * src[1]  9 * src[3] + 15 * src[5]  16 * src[7]; 
756  
757 
dst[0] = (t5 + t1 + 4) >> 3; 
758 
dst[1] = (t6 + t2 + 4) >> 3; 
759 
dst[2] = (t7 + t3 + 4) >> 3; 
760 
dst[3] = (t8 + t4 + 4) >> 3; 
761 
dst[4] = (t8  t4 + 4) >> 3; 
762 
dst[5] = (t7  t3 + 4) >> 3; 
763 
dst[6] = (t6  t2 + 4) >> 3; 
764 
dst[7] = (t5  t1 + 4) >> 3; 
765  
766 
src += 8;

767 
dst += 8;

768 
} 
769 
} 
770  
771 
src = block; 
772 
dst = block; 
773 
if(N==4){ 
774 
for(i = 0; i < M; i++){ 
775 
t1 = 17 * (src[ 0] + src[16]); 
776 
t2 = 17 * (src[ 0]  src[16]); 
777 
t3 = 22 * src[ 8]; 
778 
t4 = 22 * src[24]; 
779 
t5 = 10 * src[ 8]; 
780 
t6 = 10 * src[24]; 
781  
782 
dst[ 0] = (t1 + t3 + t6 + 64) >> 7; 
783 
dst[ 8] = (t2  t4 + t5 + 64) >> 7; 
784 
dst[16] = (t2 + t4  t5 + 64) >> 7; 
785 
dst[24] = (t1  t3  t6 + 64) >> 7; 
786  
787 
src ++; 
788 
dst ++; 
789 
} 
790 
}else{

791 
for(i = 0; i < M; i++){ 
792 
t1 = 12 * (src[ 0] + src[32]); 
793 
t2 = 12 * (src[ 0]  src[32]); 
794 
t3 = 16 * src[16] + 6 * src[48]; 
795 
t4 = 6 * src[16]  16 * src[48]; 
796  
797 
t5 = t1 + t3; 
798 
t6 = t2 + t4; 
799 
t7 = t2  t4; 
800 
t8 = t1  t3; 
801  
802 
t1 = 16 * src[ 8] + 15 * src[24] + 9 * src[40] + 4 * src[56]; 
803 
t2 = 15 * src[ 8]  4 * src[24]  16 * src[40]  9 * src[56]; 
804 
t3 = 9 * src[ 8]  16 * src[24] + 4 * src[40] + 15 * src[56]; 
805 
t4 = 4 * src[ 8]  9 * src[24] + 15 * src[40]  16 * src[56]; 
806  
807 
dst[ 0] = (t5 + t1 + 64) >> 7; 
808 
dst[ 8] = (t6 + t2 + 64) >> 7; 
809 
dst[16] = (t7 + t3 + 64) >> 7; 
810 
dst[24] = (t8 + t4 + 64) >> 7; 
811 
dst[32] = (t8  t4 + 64 + 1) >> 7; 
812 
dst[40] = (t7  t3 + 64 + 1) >> 7; 
813 
dst[48] = (t6  t2 + 64 + 1) >> 7; 
814 
dst[56] = (t5  t1 + 64 + 1) >> 7; 
815  
816 
src++; 
817 
dst++; 
818 
} 
819 
} 
820 
} 
821  
822 
/** Apply overlap transform

823 
* @todo optimize

824 
* @todo move to DSPContext

825 
*/

826 
static void vc1_overlap_block(MpegEncContext *s, DCTELEM block[64], int n, int do_hor, int do_vert) 
827 
{ 
828 
int i;

829  
830 
if(do_hor) { //TODO 
831 
} 
832 
if(do_vert) { //TODO 
833 
} 
834  
835 
for(i = 0; i < 64; i++) 
836 
block[i] += 128;

837 
} 
838  
839  
840 
static void vc1_v_overlap(uint8_t* src, int stride) 
841 
{ 
842 
int i;

843 
int a, b, c, d;

844 
for(i = 0; i < 8; i++) { 
845 
a = src[2*stride];

846 
b = src[stride]; 
847 
c = src[0];

848 
d = src[stride]; 
849  
850 
src[2*stride] = (7*a + d) >> 3; 
851 
src[stride] = (a + 7*b + c + d) >> 3; 
852 
src[0] = (a + b + 7*c  d) >> 3; 
853 
src[stride] = (a + 7*d) >> 3; 
854 
src++; 
855 
} 
856 
} 
857  
858 
static void vc1_h_overlap(uint8_t* src, int stride) 
859 
{ 
860 
int i;

861 
int a, b, c, d;

862 
for(i = 0; i < 8; i++) { 
863 
a = src[2];

864 
b = src[1];

865 
c = src[0];

866 
d = src[1];

867  
868 
src[2] = (7*a + d) >> 3; 
869 
src[1] = (a + 7*b + c + d) >> 3; 
870 
src[0] = (a + b + 7*c  d) >> 3; 
871 
src[1] = (a + 7*d) >> 3; 
872 
src += stride; 
873 
} 
874 
} 
875  
876 
/** Put block onto picture

877 
* @todo move to DSPContext

878 
*/

879 
static void vc1_put_block(VC1Context *v, DCTELEM block[6][64]) 
880 
{ 
881 
uint8_t *Y; 
882 
int ys, us, vs;

883 
DSPContext *dsp = &v>s.dsp; 
884  
885 
ys = v>s.current_picture.linesize[0];

886 
us = v>s.current_picture.linesize[1];

887 
vs = v>s.current_picture.linesize[2];

888 
Y = v>s.dest[0];

889  
890 
dsp>put_pixels_clamped(block[0], Y, ys);

891 
dsp>put_pixels_clamped(block[1], Y + 8, ys); 
892 
Y += ys * 8;

893 
dsp>put_pixels_clamped(block[2], Y, ys);

894 
dsp>put_pixels_clamped(block[3], Y + 8, ys); 
895  
896 
dsp>put_pixels_clamped(block[4], v>s.dest[1], us); 
897 
dsp>put_pixels_clamped(block[5], v>s.dest[2], vs); 
898 
} 
899  
900 
/* clip motion vector as specified in 8.3.6.5 */

901 
#define CLIP_RANGE(mv, src, lim, bs) \

902 
if(mv < bs) mv = bs  src * bs; \

903 
if(mv > lim) mv = lim  src * bs;

904  
905 
/** Do motion compensation over 1 macroblock

906 
* Mostly adapted hpel_motion and qpel_motion from mpegvideo.c

907 
*/

908 
static void vc1_mc_1mv(VC1Context *v) 
909 
{ 
910 
MpegEncContext *s = &v>s; 
911 
DSPContext *dsp = &v>s.dsp; 
912 
uint8_t *srcY, *srcU, *srcV; 
913 
int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;

914  
915 
if(!v>s.last_picture.data[0])return; 
916  
917 
mx = s>mv[0][0][0]; 
918 
my = s>mv[0][0][1]; 
919 
uvmx = (mx + ((mx & 3) == 3)) >> 1; 
920 
uvmy = (my + ((my & 3) == 3)) >> 1; 
921 
srcY = s>last_picture.data[0];

922 
srcU = s>last_picture.data[1];

923 
srcV = s>last_picture.data[2];

924  
925 
if(v>fastuvmc) { // XXX: 8.3.5.4.5 specifies something different 
926 
uvmx = (uvmx + 1) & ~1; 
927 
uvmy = (uvmy + 1) & ~1; 
928 
} 
929  
930 
src_x = s>mb_x * 16 + (mx >> 2); 
931 
src_y = s>mb_y * 16 + (my >> 2); 
932 
uvsrc_x = s>mb_x * 8 + (uvmx >> 2); 
933 
uvsrc_y = s>mb_y * 8 + (uvmy >> 2); 
934  
935 
CLIP_RANGE( src_x, s>mb_x, s>mb_width * 16, 16); 
936 
CLIP_RANGE( src_y, s>mb_y, s>mb_height * 16, 16); 
937 
CLIP_RANGE(uvsrc_x, s>mb_x, s>mb_width * 8, 8); 
938 
CLIP_RANGE(uvsrc_y, s>mb_y, s>mb_height * 8, 8); 
939  
940 
srcY += src_y * s>linesize + src_x; 
941 
srcU += uvsrc_y * s>uvlinesize + uvsrc_x; 
942 
srcV += uvsrc_y * s>uvlinesize + uvsrc_x; 
943  
944 
if((unsigned)src_x > s>h_edge_pos  (mx&3)  16 
945 
 (unsigned)src_y > s>v_edge_pos  (my&3)  16){ 
946 
uint8_t *uvbuf= s>edge_emu_buffer + 18 * s>linesize;

947  
948 
ff_emulated_edge_mc(s>edge_emu_buffer, srcY, s>linesize, 16+1, 16+1, 
949 
src_x, src_y, s>h_edge_pos, s>v_edge_pos); 
950 
srcY = s>edge_emu_buffer; 
951 
ff_emulated_edge_mc(uvbuf , srcU, s>uvlinesize, 8+1, 8+1, 
952 
uvsrc_x, uvsrc_y, s>h_edge_pos >> 1, s>v_edge_pos >> 1); 
953 
ff_emulated_edge_mc(uvbuf + 16, srcV, s>uvlinesize, 8+1, 8+1, 
954 
uvsrc_x, uvsrc_y, s>h_edge_pos >> 1, s>v_edge_pos >> 1); 
955 
srcU = uvbuf; 
956 
srcV = uvbuf + 16;

957 
} 
958  
959 
if(!s>quarter_sample) { // hpel mc 
960 
mx >>= 1;

961 
my >>= 1;

962 
dxy = ((my & 1) << 1)  (mx & 1); 
963 
uvdxy = 0;

964  
965 
dsp>put_no_rnd_pixels_tab[0][dxy](s>dest[0], srcY, s>linesize, 16); 
966 
} else {

967 
dxy = ((my & 3) << 2)  (mx & 3); 
968 
uvdxy = ((uvmy & 1) << 1)  (uvmx & 1); 
969  
970 
dsp>put_no_rnd_qpel_pixels_tab[0][dxy](s>dest[0], srcY, s>linesize); 
971 
} 
972 
dsp>put_no_rnd_pixels_tab[1][uvdxy](s>dest[1], srcU, s>uvlinesize, 8); 
973 
dsp>put_no_rnd_pixels_tab[1][uvdxy](s>dest[2], srcV, s>uvlinesize, 8); 
974 
// dsp>put_mspel_pixels_tab[uvdxy](s>dest[1], srcU, s>uvlinesize);

975 
// dsp>put_mspel_pixels_tab[uvdxy](s>dest[2], srcV, s>uvlinesize);

976 
} 
977  
978 
/**

979 
* Decode Simple/Main Profiles sequence header

980 
* @see Figure 78, p1617

981 
* @param avctx Codec context

982 
* @param gb GetBit context initialized from Codec context extra_data

983 
* @return Status

984 
*/

985 
static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb) 
986 
{ 
987 
VC1Context *v = avctx>priv_data; 
988  
989 
av_log(avctx, AV_LOG_INFO, "Header: %0X\n", show_bits(gb, 32)); 
990 
v>profile = get_bits(gb, 2);

991 
if (v>profile == 2) 
992 
{ 
993 
av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");

994 
return 1; 
995 
} 
996  
997 
if (v>profile == PROFILE_ADVANCED)

998 
{ 
999 
v>level = get_bits(gb, 3);

1000 
if(v>level >= 5) 
1001 
{ 
1002 
av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v>level);

1003 
} 
1004 
v>chromaformat = get_bits(gb, 2);

1005 
if (v>chromaformat != 1) 
1006 
{ 
1007 
av_log(avctx, AV_LOG_ERROR, 
1008 
"Only 4:2:0 chroma format supported\n");

1009 
return 1; 
1010 
} 
1011 
} 
1012 
else

1013 
{ 
1014 
v>res_sm = get_bits(gb, 2); //reserved 
1015 
if (v>res_sm)

1016 
{ 
1017 
av_log(avctx, AV_LOG_ERROR, 
1018 
"Reserved RES_SM=%i is forbidden\n", v>res_sm);

1019 
return 1; 
1020 
} 
1021 
} 
1022  
1023 
// (fps2)/4 (>30)

1024 
v>frmrtq_postproc = get_bits(gb, 3); //common 
1025 
// (bitrate32kbps)/64kbps

1026 
v>bitrtq_postproc = get_bits(gb, 5); //common 
1027 
v>s.loop_filter = get_bits(gb, 1); //common 
1028 
if(v>s.loop_filter == 1 && v>profile == PROFILE_SIMPLE) 
1029 
{ 
1030 
av_log(avctx, AV_LOG_ERROR, 
1031 
"LOOPFILTER shell not be enabled in simple profile\n");

1032 
} 
1033  
1034 
if (v>profile < PROFILE_ADVANCED)

1035 
{ 
1036 
v>res_x8 = get_bits(gb, 1); //reserved 
1037 
if (v>res_x8)

1038 
{ 
1039 
av_log(avctx, AV_LOG_ERROR, 
1040 
"1 for reserved RES_X8 is forbidden\n");

1041 
//return 1;

1042 
} 
1043 
v>multires = get_bits(gb, 1);

1044 
v>res_fasttx = get_bits(gb, 1);

1045 
if (!v>res_fasttx)

1046 
{ 
1047 
av_log(avctx, AV_LOG_ERROR, 
1048 
"0 for reserved RES_FASTTX is forbidden\n");

1049 
//return 1;

1050 
} 
1051 
} 
1052  
1053 
v>fastuvmc = get_bits(gb, 1); //common 
1054 
if (!v>profile && !v>fastuvmc)

1055 
{ 
1056 
av_log(avctx, AV_LOG_ERROR, 
1057 
"FASTUVMC unavailable in Simple Profile\n");

1058 
return 1; 
1059 
} 
1060 
v>extended_mv = get_bits(gb, 1); //common 
1061 
if (!v>profile && v>extended_mv)

1062 
{ 
1063 
av_log(avctx, AV_LOG_ERROR, 
1064 
"Extended MVs unavailable in Simple Profile\n");

1065 
return 1; 
1066 
} 
1067 
v>dquant = get_bits(gb, 2); //common 
1068 
v>vstransform = get_bits(gb, 1); //common 
1069  
1070 
if (v>profile < PROFILE_ADVANCED)

1071 
{ 
1072 
v>res_transtab = get_bits(gb, 1);

1073 
if (v>res_transtab)

1074 
{ 
1075 
av_log(avctx, AV_LOG_ERROR, 
1076 
"1 for reserved RES_TRANSTAB is forbidden\n");

1077 
return 1; 
1078 
} 
1079 
} 
1080  
1081 
v>overlap = get_bits(gb, 1); //common 
1082  
1083 
if (v>profile < PROFILE_ADVANCED)

1084 
{ 
1085 
v>s.resync_marker = get_bits(gb, 1);

1086 
v>rangered = get_bits(gb, 1);

1087 
if (v>rangered && v>profile == PROFILE_SIMPLE)

1088 
{ 
1089 
av_log(avctx, AV_LOG_INFO, 
1090 
"RANGERED should be set to 0 in simple profile\n");

1091 
} 
1092 
} 
1093  
1094 
v>s.max_b_frames = avctx>max_b_frames = get_bits(gb, 3); //common 
1095 
v>quantizer_mode = get_bits(gb, 2); //common 
1096  
1097 
if (v>profile < PROFILE_ADVANCED)

1098 
{ 
1099 
v>finterpflag = get_bits(gb, 1); //common 
1100 
v>res_rtm_flag = get_bits(gb, 1); //reserved 
1101 
if (!v>res_rtm_flag)

1102 
{ 
1103 
av_log(avctx, AV_LOG_ERROR, 
1104 
"0 for reserved RES_RTM_FLAG is forbidden\n");

1105 
//return 1;

1106 
} 
1107 
av_log(avctx, AV_LOG_DEBUG, 
1108 
"Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"

1109 
"LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"

1110 
"Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"

1111 
"DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",

1112 
v>profile, v>frmrtq_postproc, v>bitrtq_postproc, 
1113 
v>s.loop_filter, v>multires, v>fastuvmc, v>extended_mv, 
1114 
v>rangered, v>vstransform, v>overlap, v>s.resync_marker, 
1115 
v>dquant, v>quantizer_mode, avctx>max_b_frames 
1116 
); 
1117 
return 0; 
1118 
} 
1119 
return 1; 
1120 
} 
1121  
1122  
1123 
static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb) 
1124 
{ 
1125 
int pqindex, lowquant, status;

1126  
1127 
if(v>finterpflag) v>interpfrm = get_bits(gb, 1); 
1128 
skip_bits(gb, 2); //framecnt unused 
1129 
v>rangeredfrm = 0;

1130 
if (v>rangered) v>rangeredfrm = get_bits(gb, 1); 
1131 
v>s.pict_type = get_bits(gb, 1);

1132 
if (v>s.avctx>max_b_frames) {

1133 
if (!v>s.pict_type) {

1134 
if (get_bits(gb, 1)) v>s.pict_type = I_TYPE; 
1135 
else v>s.pict_type = B_TYPE;

1136 
} else v>s.pict_type = P_TYPE;

1137 
} else v>s.pict_type = v>s.pict_type ? P_TYPE : I_TYPE;

1138  
1139 
if(v>s.pict_type == I_TYPE)

1140 
get_bits(gb, 7); // skip buffer fullness 
1141  
1142 
/* Quantizer stuff */

1143 
pqindex = get_bits(gb, 5);

1144 
if (v>quantizer_mode == QUANT_FRAME_IMPLICIT)

1145 
v>pq = pquant_table[0][pqindex];

1146 
else

1147 
v>pq = pquant_table[v>quantizer_mode1][pqindex];

1148  
1149 
if (v>quantizer_mode == QUANT_FRAME_IMPLICIT)

1150 
v>pquantizer = pqindex < 9;

1151 
if (v>quantizer_mode == QUANT_UNIFORM  v>quantizer_mode == QUANT_NON_UNIFORM)

1152 
v>pquantizer = v>quantizer_mode == QUANT_UNIFORM; 
1153 
v>pqindex = pqindex; 
1154 
if (pqindex < 9) v>halfpq = get_bits(gb, 1); 
1155 
else v>halfpq = 0; 
1156 
if (v>quantizer_mode == QUANT_FRAME_EXPLICIT)

1157 
v>pquantizer = get_bits(gb, 1);

1158 
v>dquantfrm = 0;

1159  
1160 
//av_log(v>s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",

1161 
// (v>s.pict_type == P_TYPE) ? 'P' : ((v>s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v>pq, v>halfpq, v>rangeredfrm);

1162  
1163 
//TODO: complete parsing for P/B/BI frames

1164 
switch(v>s.pict_type) {

1165 
case P_TYPE:

1166 
if (v>pq < 5) v>tt_index = 0; 
1167 
else if(v>pq < 13) v>tt_index = 1; 
1168 
else v>tt_index = 2; 
1169  
1170 
if (v>extended_mv == 1) v>mvrange = get_prefix(gb, 0, 3); 
1171 
v>k_x = v>mvrange + 9 + (v>mvrange >> 1); //k_x can be 9 10 12 13 
1172 
v>k_y = v>mvrange + 8; //k_y can be 8 9 10 11 
1173 
v>range_x = 1 << (v>k_x  1); 
1174 
v>range_y = 1 << (v>k_y  1); 
1175 
if (v>profile == PROFILE_ADVANCED)

1176 
{ 
1177 
if (v>postprocflag) v>postproc = get_bits(gb, 1); 
1178 
} 
1179 
else

1180 
if (v>multires) v>respic = get_bits(gb, 2); 
1181 
lowquant = (v>pq > 12) ? 0 : 1; 
1182 
v>mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)]; 
1183 
if (v>mv_mode == MV_PMODE_INTENSITY_COMP)

1184 
{ 
1185 
v>mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)]; 
1186 
v>lumscale = get_bits(gb, 6);

1187 
v>lumshift = get_bits(gb, 6);

1188 
} 
1189 
if(v>mv_mode == MV_PMODE_1MV_HPEL  v>mv_mode == MV_PMODE_1MV_HPEL_BILIN)

1190 
v>s.quarter_sample = 0;

1191 
else

1192 
v>s.quarter_sample = 1;

1193  
1194 
if(v>mv_mode != MV_PMODE_1MV && v>mv_mode != MV_PMODE_1MV_HPEL && v>mv_mode != MV_PMODE_1MV_HPEL_BILIN) {

1195 
av_log(v>s.avctx, AV_LOG_ERROR, "Only 1MV Pframes are supported by now\n");

1196 
return 1; 
1197 
} 
1198 
if ((v>mv_mode == MV_PMODE_INTENSITY_COMP &&

1199 
v>mv_mode2 == MV_PMODE_MIXED_MV) 
1200 
 v>mv_mode == MV_PMODE_MIXED_MV) 
1201 
{ 
1202 
status = bitplane_decoding(v>mv_type_mb_plane, &v>mv_type_is_raw, v); 
1203 
if (status < 0) return 1; 
1204 
av_log(v>s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "

1205 
"Imode: %i, Invert: %i\n", status>>1, status&1); 
1206 
} else {

1207 
v>mv_type_is_raw = 0;

1208 
memset(v>mv_type_mb_plane, 0, v>s.mb_stride * v>s.mb_height);

1209 
} 
1210 
status = bitplane_decoding(v>skip_mb_plane, &v>skip_is_raw, v); 
1211 
if (status < 0) return 1; 
1212 
av_log(v>s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "

1213 
"Imode: %i, Invert: %i\n", status>>1, status&1); 
1214  
1215 
/* Hopefully this is correct for P frames */

1216 
v>s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables 
1217 
v>cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];

1218  
1219 
if (v>dquant)

1220 
{ 
1221 
av_log(v>s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");

1222 
vop_dquant_decoding(v); 
1223 
} 
1224  
1225 
v>ttfrm = 0; //FIXME Is that so ? 
1226 
if (v>vstransform)

1227 
{ 
1228 
v>ttmbf = get_bits(gb, 1);

1229 
if (v>ttmbf)

1230 
{ 
1231 
v>ttfrm = get_bits(gb, 2);

1232 
} 
1233 
} 
1234 
break;

1235 
case B_TYPE:

1236 
break;

1237 
} 
1238  
1239 
/* AC Syntax */

1240 
v>c_ac_table_index = decode012(gb); 
1241 
if (v>s.pict_type == I_TYPE  v>s.pict_type == BI_TYPE)

1242 
{ 
1243 
v>y_ac_table_index = decode012(gb); 
1244 
} 
1245 
/* DC Syntax */

1246 
v>s.dc_table_index = get_bits(gb, 1);

1247  
1248 
return 0; 
1249 
} 
1250  
1251 
/***********************************************************************/

1252 
/**

1253 
* @defgroup block VC1 Blocklevel functions

1254 
* @see 7.1.4, p91 and 8.1.1.7, p(1)04

1255 
* @todo TODO: Integrate to MpegEncContext facilities

1256 
* @{

1257 
*/

1258  
1259 
/**

1260 
* @def GET_MQUANT

1261 
* @brief Get macroblocklevel quantizer scale

1262 
* @warning XXX: qdiff to the frame quant, not previous quant ?

1263 
* @fixme XXX: Don't know how to initialize mquant otherwise in last case

1264 
*/

1265 
#define GET_MQUANT() \

1266 
if (v>dquantfrm) \

1267 
{ \ 
1268 
if (v>dqprofile == DQPROFILE_ALL_MBS) \

1269 
{ \ 
1270 
if (v>dqbilevel) \

1271 
{ \ 
1272 
mquant = (get_bits(gb, 1)) ? v>pq : v>altpq; \

1273 
} \ 
1274 
else \

1275 
{ \ 
1276 
mqdiff = get_bits(gb, 3); \

1277 
if (mqdiff != 7) mquant = v>pq + mqdiff; \ 
1278 
else mquant = get_bits(gb, 5); \ 
1279 
} \ 
1280 
} \ 
1281 
else mquant = v>pq; \

1282 
} 
1283  
1284 
/**

1285 
* @def GET_MVDATA(_dmv_x, _dmv_y)

1286 
* @brief Get MV differentials

1287 
* @see MVDATA decoding from 8.3.5.2, p(1)20

1288 
* @param _dmv_x Horizontal differential for decoded MV

1289 
* @param _dmv_y Vertical differential for decoded MV

1290 
* @todo TODO: Use MpegEncContext arrays to store them

1291 
*/

1292 
#define GET_MVDATA(_dmv_x, _dmv_y) \

1293 
index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s>mv_table_index].table,\

1294 
VC1_MV_DIFF_VLC_BITS, 2); \

1295 
if (index > 36) \ 
1296 
{ \ 
1297 
mb_has_coeffs = 1; \

1298 
index = 37; \

1299 
} \ 
1300 
else mb_has_coeffs = 0; \ 
1301 
s>mb_intra = 0; \

1302 
if (!index) { _dmv_x = _dmv_y = 0; } \ 
1303 
else if (index == 35) \ 
1304 
{ \ 
1305 
_dmv_x = get_bits(gb, v>k_x  1 + s>quarter_sample); \

1306 
_dmv_y = get_bits(gb, v>k_y  1 + s>quarter_sample); \

1307 
} \ 
1308 
else if (index == 36) \ 
1309 
{ \ 
1310 
_dmv_x = 0; \

1311 
_dmv_y = 0; \

1312 
s>mb_intra = 1; \

1313 
} \ 
1314 
else \

1315 
{ \ 
1316 
index1 = index%6; \

1317 
if (!s>quarter_sample && index1 == 5) val = 1; \ 
1318 
else val = 0; \ 
1319 
if(size_table[index1]  val > 0) \ 
1320 
val = get_bits(gb, size_table[index1]  val); \ 
1321 
else val = 0; \ 
1322 
sign = 0  (val&1); \ 
1323 
_dmv_x = (sign ^ ((val>>1) + offset_table[index1]))  sign; \

1324 
\ 
1325 
index1 = index/6; \

1326 
if (!s>quarter_sample && index1 == 5) val = 1; \ 
1327 
else val = 0; \ 
1328 
if(size_table[index1]  val > 0) \ 
1329 
val = get_bits(gb, size_table[index1]  val); \ 
1330 
else val = 0; \ 
1331 
sign = 0  (val&1); \ 
1332 
_dmv_y = (sign ^ ((val>>1) + offset_table[index1]))  sign; \

1333 
} 
1334  
1335 
/** Predict and set motion vector

1336 
*/

1337 
static inline void vc1_pred_mv(MpegEncContext *s, int dmv_x, int dmv_y, int mv1, int r_x, int r_y) 
1338 
{ 
1339 
int xy, wrap, off;

1340 
int16_t *A, *B, *C; 
1341 
int px, py;

1342 
int sum;

1343 
int mb_pos = s>mb_x + s>mb_y * s>mb_stride;

1344  
1345 
/* scale MV difference to be quadpel */

1346 
dmv_x <<= 1  s>quarter_sample;

1347 
dmv_y <<= 1  s>quarter_sample;

1348  
1349 
wrap = s>b8_stride; 
1350 
xy = s>block_index[0];

1351  
1352 
C = s>current_picture.motion_val[0][xy  (1 << mv1)]; 
1353 
A = s>current_picture.motion_val[0][xy  (wrap << mv1)];

1354 
off = (s>mb_x == (s>mb_width  1)) ? 1 : 1; 
1355 
B = s>current_picture.motion_val[0][xy + ((off  wrap) << mv1)];

1356  
1357 
if(!s>first_slice_line) { // predictor A is not out of bounds 
1358 
if(s>mb_width == 1) { 
1359 
px = A[0];

1360 
py = A[1];

1361 
} else {

1362 
px = mid_pred(A[0], B[0], C[0]); 
1363 
py = mid_pred(A[1], B[1], C[1]); 
1364 
} 
1365 
} else if(s>mb_x) { // predictor C is not out of bounds 
1366 
px = C[0];

1367 
py = C[1];

1368 
} else {

1369 
px = py = 0;

1370 
} 
1371 
if(s>mb_intra) px = py = 0; 
1372  
1373 
/* Pullback MV as specified in 8.3.5.3.4 */

1374 
{ 
1375 
int qx, qy, X, Y;

1376 
qx = s>mb_x << 6; //FIXME: add real block coords for 4MV mode 
1377 
qy = s>mb_y << 6;

1378 
X = (s>mb_width << 6)  4; 
1379 
Y = (s>mb_height << 6)  4; 
1380 
if(mv1) {

1381 
if(qx + px < 60) px = 60  qx; 
1382 
if(qy + py < 60) py = 60  qy; 
1383 
} else {

1384 
if(qx + px < 28) px = 28  qx; 
1385 
if(qy + py < 28) py = 28  qy; 
1386 
} 
1387 
if(qx + px > X) px = X  qx;

1388 
if(qy + py > Y) py = Y  qy;

1389 
} 
1390 
/* Calculate hybrid prediction as specified in 8.3.5.3.5 */

1391 
if(!s>mb_intra && !s>first_slice_line && s>mb_x) {

1392 
if(IS_INTRA(s>current_picture.mb_type[mb_pos  s>mb_stride]))

1393 
sum = ABS(px) + ABS(py); 
1394 
else

1395 
sum = ABS(px  A[0]) + ABS(py  A[1]); 
1396 
if(sum > 32) { 
1397 
if(get_bits1(&s>gb)) {

1398 
px = A[0];

1399 
py = A[1];

1400 
} else {

1401 
px = C[0];

1402 
py = C[1];

1403 
} 
1404 
} else {

1405 
if(IS_INTRA(s>current_picture.mb_type[mb_pos  1])) 
1406 
sum = ABS(px) + ABS(py); 
1407 
else

1408 
sum = ABS(px  C[0]) + ABS(py  C[1]); 
1409 
if(sum > 32) { 
1410 
if(get_bits1(&s>gb)) {

1411 
px = A[0];

1412 
py = A[1];

1413 
} else {

1414 
px = C[0];

1415 
py = C[1];

1416 
} 
1417 
} 
1418 
} 
1419 
} 
1420 
/* store MV using signed modulus of MV range defined in 4.11 */

1421 
s>mv[0][0][0] = s>current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1)  1))  r_x; 
1422 
s>mv[0][0][1] = s>current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1)  1))  r_y; 
1423 
} 
1424  
1425 
/** Get predicted DC value for Iframes only

1426 
* prediction dir: left=0, top=1

1427 
* @param s MpegEncContext

1428 
* @param[in] n block index in the current MB

1429 
* @param dc_val_ptr Pointer to DC predictor

1430 
* @param dir_ptr Prediction direction for use in AC prediction

1431 
*/

1432 
static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n, 
1433 
int16_t **dc_val_ptr, int *dir_ptr)

1434 
{ 
1435 
int a, b, c, wrap, pred, scale;

1436 
int16_t *dc_val; 
1437 
static const uint16_t dcpred[32] = { 
1438 
1, 1024, 512, 341, 256, 205, 171, 146, 128, 
1439 
114, 102, 93, 85, 79, 73, 68, 64, 
1440 
60, 57, 54, 51, 49, 47, 45, 43, 
1441 
41, 39, 38, 37, 35, 34, 33 
1442 
}; 
1443  
1444 
/* find prediction  wmv3_dc_scale always used here in fact */

1445 
if (n < 4) scale = s>y_dc_scale; 
1446 
else scale = s>c_dc_scale;

1447  
1448 
wrap = s>block_wrap[n]; 
1449 
dc_val= s>dc_val[0] + s>block_index[n];

1450  
1451 
/* B A

1452 
* C X

1453 
*/

1454 
c = dc_val[  1];

1455 
b = dc_val[  1  wrap];

1456 
a = dc_val[  wrap]; 
1457  
1458 
if (pq < 9  !overlap) 
1459 
{ 
1460 
/* Set outer values */

1461 
if (!s>mb_y && (n!=2 && n!=3)) b=a=dcpred[scale]; 
1462 
if (s>mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale]; 
1463 
} 
1464 
else

1465 
{ 
1466 
/* Set outer values */

1467 
if (!s>mb_y && (n!=2 && n!=3)) b=a=0; 
1468 
if (s>mb_x == 0 && (n!=1 && n!=3)) b=c=0; 
1469 
} 
1470  
1471 
if (abs(a  b) <= abs(b  c)) {

1472 
pred = c; 
1473 
*dir_ptr = 1;//left 
1474 
} else {

1475 
pred = a; 
1476 
*dir_ptr = 0;//top 
1477 
} 
1478  
1479 
/* update predictor */

1480 
*dc_val_ptr = &dc_val[0];

1481 
return pred;

1482 
} 
1483  
1484  
1485 
/** Get predicted DC value

1486 
* prediction dir: left=0, top=1

1487 
* @param s MpegEncContext

1488 
* @param[in] n block index in the current MB

1489 
* @param dc_val_ptr Pointer to DC predictor

1490 
* @param dir_ptr Prediction direction for use in AC prediction

1491 
*/

1492 
static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n, 
1493 
int a_avail, int c_avail, 
1494 
int16_t **dc_val_ptr, int *dir_ptr)

1495 
{ 
1496 
int a, b, c, wrap, pred, scale;

1497 
int16_t *dc_val; 
1498 
int mb_pos = s>mb_x + s>mb_y * s>mb_stride;

1499 
int mb_pos2, q1, q2;

1500  
1501 
/* find prediction  wmv3_dc_scale always used here in fact */

1502 
if (n < 4) scale = s>y_dc_scale; 
1503 
else scale = s>c_dc_scale;

1504  
1505 
wrap = s>block_wrap[n]; 
1506 
dc_val= s>dc_val[0] + s>block_index[n];

1507  
1508 
/* B A

1509 
* C X

1510 
*/

1511 
c = dc_val[  1];

1512 
b = dc_val[  1  wrap];

1513 
a = dc_val[  wrap]; 
1514  
1515 
if(a_avail && c_avail) {

1516 
if(abs(a  b) <= abs(b  c)) {

1517 
pred = c; 
1518 
*dir_ptr = 1;//left 
1519 
} else {

1520 
pred = a; 
1521 
*dir_ptr = 0;//top 
1522 
} 
1523 
} else if(a_avail) { 
1524 
pred = a; 
1525 
*dir_ptr = 0;//top 
1526 
} else if(c_avail) { 
1527 
pred = c; 
1528 
*dir_ptr = 1;//left 
1529 
} else {

1530 
pred = 0;

1531 
*dir_ptr = 1;//left 
1532 
} 
1533  
1534 
/* scale coeffs if needed */

1535 
mb_pos2 = mb_pos  *dir_ptr  (1  *dir_ptr) * s>mb_stride;

1536 
q1 = s>current_picture.qscale_table[mb_pos]; 
1537 
q2 = s>current_picture.qscale_table[mb_pos2]; 
1538 
if(0 && q1 && q2 && q1 != q2) { 
1539 
q1 = s>y_dc_scale_table[q1]; 
1540 
q2 = s>y_dc_scale_table[q2]; 
1541 
pred = (pred * q2 * vc1_dqscale[q1  1] + 0x20000) >> 18; 
1542 
} 
1543  
1544 
/* update predictor */

1545 
*dc_val_ptr = &dc_val[0];

1546 
return pred;

1547 
} 
1548  
1549  
1550 
/**

1551 
* @defgroup std_mb VC1 Macroblocklevel functions in Simple/Main Profiles

1552 
* @see 7.1.4, p91 and 8.1.1.7, p(1)04

1553 
* @todo TODO: Integrate to MpegEncContext facilities

1554 
* @{

1555 
*/

1556  
1557 
static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr) 
1558 
{ 
1559 
int xy, wrap, pred, a, b, c;

1560  
1561 
xy = s>block_index[n]; 
1562 
wrap = s>b8_stride; 
1563  
1564 
/* B C

1565 
* A X

1566 
*/

1567 
a = s>coded_block[xy  1 ];

1568 
b = s>coded_block[xy  1  wrap];

1569 
c = s>coded_block[xy  wrap]; 
1570  
1571 
if (b == c) {

1572 
pred = a; 
1573 
} else {

1574 
pred = c; 
1575 
} 
1576  
1577 
/* store value */

1578 
*coded_block_ptr = &s>coded_block[xy]; 
1579  
1580 
return pred;

1581 
} 
1582  
1583 
/**

1584 
* Decode one AC coefficient

1585 
* @param v The VC1 context

1586 
* @param last Last coefficient

1587 
* @param skip How much zero coefficients to skip

1588 
* @param value Decoded AC coefficient value

1589 
* @see 8.1.3.4

1590 
*/

1591 
static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset) 
1592 
{ 
1593 
GetBitContext *gb = &v>s.gb; 
1594 
int index, escape, run = 0, level = 0, lst = 0; 
1595  
1596 
index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);

1597 
if (index != vc1_ac_sizes[codingset]  1) { 
1598 
run = vc1_index_decode_table[codingset][index][0];

1599 
level = vc1_index_decode_table[codingset][index][1];

1600 
lst = index >= vc1_last_decode_table[codingset]; 
1601 
if(get_bits(gb, 1)) 
1602 
level = level; 
1603 
} else {

1604 
escape = decode210(gb); 
1605 
if (escape != 2) { 
1606 
index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);

1607 
run = vc1_index_decode_table[codingset][index][0];

1608 
level = vc1_index_decode_table[codingset][index][1];

1609 
lst = index >= vc1_last_decode_table[codingset]; 
1610 
if(escape == 0) { 
1611 
if(lst)

1612 
level += vc1_last_delta_level_table[codingset][run]; 
1613 
else

1614 
level += vc1_delta_level_table[codingset][run]; 
1615 
} else {

1616 
if(lst)

1617 
run += vc1_last_delta_run_table[codingset][level] + 1;

1618 
else

1619 
run += vc1_delta_run_table[codingset][level] + 1;

1620 
} 
1621 
if(get_bits(gb, 1)) 
1622 
level = level; 
1623 
} else {

1624 
int sign;

1625 
lst = get_bits(gb, 1);

1626 
if(v>s.esc3_level_length == 0) { 
1627 
if(v>pq < 8  v>dquantfrm) { // table 59 
1628 
v>s.esc3_level_length = get_bits(gb, 3);

1629 
if(!v>s.esc3_level_length)

1630 
v>s.esc3_level_length = get_bits(gb, 2) + 8; 
1631 
} else { //table 60 
1632 
v>s.esc3_level_length = get_prefix(gb, 1, 6) + 2; 
1633 
} 
1634 
v>s.esc3_run_length = 3 + get_bits(gb, 2); 
1635 
} 
1636 
run = get_bits(gb, v>s.esc3_run_length); 
1637 
sign = get_bits(gb, 1);

1638 
level = get_bits(gb, v>s.esc3_level_length); 
1639 
if(sign)

1640 
level = level; 
1641 
} 
1642 
} 
1643  
1644 
*last = lst; 
1645 
*skip = run; 
1646 
*value = level; 
1647 
} 
1648  
1649 
/** Decode intra block in intra frames  should be faster than decode_intra_block

1650 
* @param v VC1Context

1651 
* @param block block to decode

1652 
* @param coded are AC coeffs present or not

1653 
* @param codingset set of VLC to decode data

1654 
*/

1655 
static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset) 
1656 
{ 
1657 
GetBitContext *gb = &v>s.gb; 
1658 
MpegEncContext *s = &v>s; 
1659 
int dc_pred_dir = 0; /* Direction of the DC prediction used */ 
1660 
int run_diff, i;

1661 
int16_t *dc_val; 
1662 
int16_t *ac_val, *ac_val2; 
1663 
int dcdiff;

1664  
1665 
/* Get DC differential */

1666 
if (n < 4) { 
1667 
dcdiff = get_vlc2(&s>gb, ff_msmp4_dc_luma_vlc[s>dc_table_index].table, DC_VLC_BITS, 3);

1668 
} else {

1669 
dcdiff = get_vlc2(&s>gb, ff_msmp4_dc_chroma_vlc[s>dc_table_index].table, DC_VLC_BITS, 3);

1670 
} 
1671 
if (dcdiff < 0){ 
1672 
av_log(s>avctx, AV_LOG_ERROR, "Illegal DC VLC\n");

1673 
return 1; 
1674 
} 
1675 
if (dcdiff)

1676 
{ 
1677 
if (dcdiff == 119 /* ESC index value */) 
1678 
{ 
1679 
/* TODO: Optimize */

1680 
if (v>pq == 1) dcdiff = get_bits(gb, 10); 
1681 
else if (v>pq == 2) dcdiff = get_bits(gb, 9); 
1682 
else dcdiff = get_bits(gb, 8); 
1683 
} 
1684 
else

1685 
{ 
1686 
if (v>pq == 1) 
1687 
dcdiff = (dcdiff<<2) + get_bits(gb, 2)  3; 
1688 
else if (v>pq == 2) 
1689 
dcdiff = (dcdiff<<1) + get_bits(gb, 1)  1; 
1690 
} 
1691 
if (get_bits(gb, 1)) 
1692 
dcdiff = dcdiff; 
1693 
} 
1694  
1695 
/* Prediction */

1696 
dcdiff += vc1_i_pred_dc(&v>s, v>overlap, v>pq, n, &dc_val, &dc_pred_dir); 
1697 
*dc_val = dcdiff; 
1698  
1699 
/* Store the quantized DC coeff, used for prediction */

1700  
1701 
if (n < 4) { 
1702 
block[0] = dcdiff * s>y_dc_scale;

1703 
} else {

1704 
block[0] = dcdiff * s>c_dc_scale;

1705 
} 
1706 
/* Skip ? */

1707 
run_diff = 0;

1708 
i = 0;

1709 
if (!coded) {

1710 
goto not_coded;

1711 
} 
1712  
1713 
//AC Decoding

1714 
i = 1;

1715  
1716 
{ 
1717 
int last = 0, skip, value; 
1718 
const int8_t *zz_table;

1719 
int scale;

1720 
int k;

1721  
1722 
scale = v>pq * 2 + v>halfpq;

1723  
1724 
if(v>s.ac_pred) {

1725 
if(!dc_pred_dir)

1726 
zz_table = vc1_horizontal_zz; 
1727 
else

1728 
zz_table = vc1_vertical_zz; 
1729 
} else

1730 
zz_table = vc1_normal_zz; 
1731  
1732 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
1733 
ac_val2 = ac_val; 
1734 
if(dc_pred_dir) //left 
1735 
ac_val = 16;

1736 
else //top 
1737 
ac_val = 16 * s>block_wrap[n];

1738  
1739 
while (!last) {

1740 
vc1_decode_ac_coeff(v, &last, &skip, &value, codingset); 
1741 
i += skip; 
1742 
if(i > 63) 
1743 
break;

1744 
block[zz_table[i++]] = value; 
1745 
} 
1746  
1747 
/* apply AC prediction if needed */

1748 
if(s>ac_pred) {

1749 
if(dc_pred_dir) { //left 
1750 
for(k = 1; k < 8; k++) 
1751 
block[k << 3] += ac_val[k];

1752 
} else { //top 
1753 
for(k = 1; k < 8; k++) 
1754 
block[k] += ac_val[k + 8];

1755 
} 
1756 
} 
1757 
/* save AC coeffs for further prediction */

1758 
for(k = 1; k < 8; k++) { 
1759 
ac_val2[k] = block[k << 3];

1760 
ac_val2[k + 8] = block[k];

1761 
} 
1762  
1763 
/* scale AC coeffs */

1764 
for(k = 1; k < 64; k++) 
1765 
if(block[k]) {

1766 
block[k] *= scale; 
1767 
if(!v>pquantizer)

1768 
block[k] += (block[k] < 0) ? v>pq : v>pq;

1769 
} 
1770  
1771 
if(s>ac_pred) i = 63; 
1772 
} 
1773  
1774 
not_coded:

1775 
if(!coded) {

1776 
int k, scale;

1777 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
1778 
ac_val2 = ac_val; 
1779  
1780 
scale = v>pq * 2 + v>halfpq;

1781 
memset(ac_val2, 0, 16 * 2); 
1782 
if(dc_pred_dir) {//left 
1783 
ac_val = 16;

1784 
if(s>ac_pred)

1785 
memcpy(ac_val2, ac_val, 8 * 2); 
1786 
} else {//top 
1787 
ac_val = 16 * s>block_wrap[n];

1788 
if(s>ac_pred)

1789 
memcpy(ac_val2 + 8, ac_val + 8, 8 * 2); 
1790 
} 
1791  
1792 
/* apply AC prediction if needed */

1793 
if(s>ac_pred) {

1794 
if(dc_pred_dir) { //left 
1795 
for(k = 1; k < 8; k++) { 
1796 
block[k << 3] = ac_val[k] * scale;

1797 
if(!v>pquantizer)

1798 
block[k << 3] += (block[k << 3] < 0) ? v>pq : v>pq; 
1799 
} 
1800 
} else { //top 
1801 
for(k = 1; k < 8; k++) { 
1802 
block[k] = ac_val[k + 8] * scale;

1803 
if(!v>pquantizer)

1804 
block[k] += (block[k] < 0) ? v>pq : v>pq;

1805 
} 
1806 
} 
1807 
i = 63;

1808 
} 
1809 
} 
1810 
s>block_last_index[n] = i; 
1811  
1812 
return 0; 
1813 
} 
1814  
1815 
/** Decode intra block in inter frames  more generic version than vc1_decode_i_block

1816 
* @param v VC1Context

1817 
* @param block block to decode

1818 
* @param coded are AC coeffs present or not

1819 
* @param mquant block quantizer

1820 
* @param codingset set of VLC to decode data

1821 
*/

1822 
static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset) 
1823 
{ 
1824 
GetBitContext *gb = &v>s.gb; 
1825 
MpegEncContext *s = &v>s; 
1826 
int dc_pred_dir = 0; /* Direction of the DC prediction used */ 
1827 
int run_diff, i;

1828 
int16_t *dc_val; 
1829 
int16_t *ac_val, *ac_val2; 
1830 
int dcdiff;

1831 
int mb_pos = s>mb_x + s>mb_y * s>mb_stride;

1832 
int a_avail = v>a_avail, c_avail = v>c_avail;

1833  
1834 
/* XXX: Guard against dumb values of mquant */

1835 
mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant ); 
1836  
1837 
/* Set DC scale  y and c use the same */

1838 
s>y_dc_scale = s>y_dc_scale_table[mquant]; 
1839 
s>c_dc_scale = s>c_dc_scale_table[mquant]; 
1840  
1841 
/* Get DC differential */

1842 
if (n < 4) { 
1843 
dcdiff = get_vlc2(&s>gb, ff_msmp4_dc_luma_vlc[s>dc_table_index].table, DC_VLC_BITS, 3);

1844 
} else {

1845 
dcdiff = get_vlc2(&s>gb, ff_msmp4_dc_chroma_vlc[s>dc_table_index].table, DC_VLC_BITS, 3);

1846 
} 
1847 
if (dcdiff < 0){ 
1848 
av_log(s>avctx, AV_LOG_ERROR, "Illegal DC VLC\n");

1849 
return 1; 
1850 
} 
1851 
if (dcdiff)

1852 
{ 
1853 
if (dcdiff == 119 /* ESC index value */) 
1854 
{ 
1855 
/* TODO: Optimize */

1856 
if (mquant == 1) dcdiff = get_bits(gb, 10); 
1857 
else if (mquant == 2) dcdiff = get_bits(gb, 9); 
1858 
else dcdiff = get_bits(gb, 8); 
1859 
} 
1860 
else

1861 
{ 
1862 
if (mquant == 1) 
1863 
dcdiff = (dcdiff<<2) + get_bits(gb, 2)  3; 
1864 
else if (mquant == 2) 
1865 
dcdiff = (dcdiff<<1) + get_bits(gb, 1)  1; 
1866 
} 
1867 
if (get_bits(gb, 1)) 
1868 
dcdiff = dcdiff; 
1869 
} 
1870  
1871 
/* Prediction */

1872 
dcdiff += vc1_pred_dc(&v>s, v>overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir); 
1873 
*dc_val = dcdiff; 
1874  
1875 
/* Store the quantized DC coeff, used for prediction */

1876  
1877 
if (n < 4) { 
1878 
block[0] = dcdiff * s>y_dc_scale;

1879 
} else {

1880 
block[0] = dcdiff * s>c_dc_scale;

1881 
} 
1882 
/* Skip ? */

1883 
run_diff = 0;

1884 
i = 0;

1885 
if (!coded) {

1886 
goto not_coded;

1887 
} 
1888  
1889 
//AC Decoding

1890 
i = 1;

1891  
1892 
{ 
1893 
int last = 0, skip, value; 
1894 
const int8_t *zz_table;

1895 
int scale;

1896 
int k;

1897  
1898 
scale = mquant * 2;

1899  
1900 
zz_table = vc1_simple_progressive_8x8_zz; 
1901  
1902 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
1903 
ac_val2 = ac_val; 
1904 
if(dc_pred_dir) //left 
1905 
ac_val = 16;

1906 
else //top 
1907 
ac_val = 16 * s>block_wrap[n];

1908  
1909 
while (!last) {

1910 
vc1_decode_ac_coeff(v, &last, &skip, &value, codingset); 
1911 
i += skip; 
1912 
if(i > 63) 
1913 
break;

1914 
block[zz_table[i++]] = value; 
1915 
} 
1916  
1917 
/* apply AC prediction if needed */

1918 
if(s>ac_pred && (v>a_avail  v>c_avail)) {

1919 
/* scale predictors if needed*/

1920 
int mb_pos2, q1, q2;

1921  
1922 
mb_pos2 = mb_pos  dc_pred_dir  (1  dc_pred_dir) * s>mb_stride;

1923 
q1 = s>current_picture.qscale_table[mb_pos]; 
1924 
q2 = s>current_picture.qscale_table[mb_pos2]; 
1925  
1926 
if(!c_avail) {

1927 
memset(ac_val, 0, 8 * sizeof(ac_val[0])); 
1928 
dc_pred_dir = 0;

1929 
} 
1930 
if(!a_avail) {

1931 
memset(ac_val + 8, 0, 8 * sizeof(ac_val[0])); 
1932 
dc_pred_dir = 1;

1933 
} 
1934 
if(q2 && q1 != q2) {

1935 
q1 = q1 * 2  1; 
1936 
q2 = q2 * 2  1; 
1937  
1938 
if(dc_pred_dir) { //left 
1939 
for(k = 1; k < 8; k++) 
1940 
block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1  1] + 0x20000) >> 18; 
1941 
} else { //top 
1942 
for(k = 1; k < 8; k++) 
1943 
block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1  1] + 0x20000) >> 18; 
1944 
} 
1945 
} else {

1946 
if(dc_pred_dir) { //left 
1947 
for(k = 1; k < 8; k++) 
1948 
block[k << 3] += ac_val[k];

1949 
} else { //top 
1950 
for(k = 1; k < 8; k++) 
1951 
block[k] += ac_val[k + 8];

1952 
} 
1953 
} 
1954 
} 
1955 
/* save AC coeffs for further prediction */

1956 
for(k = 1; k < 8; k++) { 
1957 
ac_val2[k] = block[k << 3];

1958 
ac_val2[k + 8] = block[k];

1959 
} 
1960  
1961 
/* scale AC coeffs */

1962 
for(k = 1; k < 64; k++) 
1963 
if(block[k]) {

1964 
block[k] *= scale; 
1965 
if(!v>pquantizer)

1966 
block[k] += (block[k] < 0) ? mquant : mquant;

1967 
} 
1968  
1969 
if(s>ac_pred) i = 63; 
1970 
} 
1971  
1972 
not_coded:

1973 
if(!coded) {

1974 
int k, scale;

1975 
ac_val = s>ac_val[0][0] + s>block_index[n] * 16; 
1976 
ac_val2 = ac_val; 
1977  
1978 
if(!c_avail) {

1979 
memset(ac_val, 0, 8 * sizeof(ac_val[0])); 
1980 
dc_pred_dir = 0;

1981 
} 
1982 
if(!a_avail) {

1983 
memset(ac_val + 8, 0, 8 * sizeof(ac_val[0])); 
1984 
dc_pred_dir = 1;

1985 
} 
1986  
1987 
scale = mquant * 2;

1988 
memset(ac_val2, 0, 16 * 2); 
1989 
if(dc_pred_dir) {//left 
1990 
ac_val = 16;

1991 
if(s>ac_pred && (v>a_avail  v>c_avail))

1992 
memcpy(ac_val2, ac_val, 8 * 2); 
1993 
} else {//top 
1994 
ac_val = 16 * s>block_wrap[n];

1995 
if(s>ac_pred && (v>a_avail  v>c_avail))

1996 
memcpy(ac_val2 + 8, ac_val + 8, 8 * 2); 
1997 
} 
1998  
1999 
/* apply AC prediction if needed */

2000 
if(s>ac_pred && (v>a_avail  v>c_avail)) {

2001 
if(dc_pred_dir) { //left 
2002 
for(k = 1; k < 8; k++) { 
2003 
block[k << 3] = ac_val[k] * scale;

2004 
if(!v>pquantizer)

2005 
block[k << 3] += (block[k << 3] < 0) ? mquant : mquant; 
2006 
} 
2007 
} else { //top 
2008 
for(k = 1; k < 8; k++) { 
2009 
block[k] = ac_val[k + 8] * scale;

2010 
if(!v>pquantizer)

2011 
block[k] += (block[k] < 0) ? mquant : mquant;

2012 
} 
2013 
} 
2014 
i = 63;

2015 
} 
2016 
} 
2017 
s>block_last_index[n] = i; 
2018  
2019 
return 0; 
2020 
} 
2021  
2022 
/** Decode P block

2023 
*/

2024 
static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block) 
2025 
{ 
2026 
MpegEncContext *s = &v>s; 
2027 
GetBitContext *gb = &s>gb; 
2028 
int i, j;

2029 
int subblkpat = 0; 
2030 
int scale, off, idx, last, skip, value;

2031 
int ttblk = ttmb & 7; 
2032  
2033 
if(ttmb == 1) { 
2034 
ttblk = ttblk_to_tt[v>tt_index][get_vlc2(gb, vc1_ttblk_vlc[v>tt_index].table, VC1_TTBLK_VLC_BITS, 1)];

2035 
} 
2036 
if(ttblk == TT_4X4) {

2037 
subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v>tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1); 
2038 
} 
2039 
if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v>ttmbf  (ttmb != 1 && (ttmb & 8) && !first_block))) { 
2040 
subblkpat = decode012(gb); 
2041 
if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits 
2042 
if(ttblk == TT_8X4_TOP  ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;

2043 
if(ttblk == TT_4X8_RIGHT  ttblk == TT_4X8_LEFT) ttblk = TT_4X8;

2044 
} 
2045 
scale = 2 * mquant;

2046  
2047 
// convert transforms like 8X4_TOP to generic TT and SUBBLKPAT

2048 
if(ttblk == TT_8X4_TOP  ttblk == TT_8X4_BOTTOM) {

2049 
ttblk = TT_8X4; 
2050 
subblkpat = 2  (ttblk == TT_8X4_TOP);

2051 
} 
2052 
if(ttblk == TT_4X8_RIGHT  ttblk == TT_4X8_LEFT) {

2053 
ttblk = TT_4X8; 
2054 
subblkpat = 2  (ttblk == TT_4X8_LEFT);

2055 
} 
2056 
switch(ttblk) {

2057 
case TT_8X8:

2058 
i = 0;

2059 
last = 0;

2060 
while (!last) {

2061 
vc1_decode_ac_coeff(v, &last, &skip, &value, v>codingset2); 
2062 
i += skip; 
2063 
if(i > 63) 
2064 
break;

2065 
idx = vc1_simple_progressive_8x8_zz[i++]; 
2066 
block[idx] = value * scale; 
2067 
} 
2068 
vc1_inv_trans(block, 8, 8); 
2069 
break;

2070 
case TT_4X4:

2071 
for(j = 0; j < 4; j++) { 
2072 
last = subblkpat & (1 << (3  j)); 
2073 
i = 0;

2074 
off = (j & 1) * 4 + (j & 2) * 16; 
2075 
while (!last) {

2076 
vc1_decode_ac_coeff(v, &last, &skip, &value, v>codingset2); 
2077 
i += skip; 
2078 
if(i > 15) 
2079 
break;

2080 
idx = vc1_simple_progressive_4x4_zz[i++]; 
2081 
block[idx + off] = value * scale; 
2082 
} 
2083 
if(!(subblkpat & (1 << (3  j)))) 
2084 
vc1_inv_trans(block + off, 4, 4); 
2085 
} 
2086 
break;

2087 
case TT_8X4:

2088 
for(j = 0; j < 2; j++) { 
2089 
last = subblkpat & (1 << (1  j)); 
2090 
i = 0;

2091 
off = j * 32;

2092 
while (!last) {

2093 
vc1_decode_ac_coeff(v, &last, &skip, &value, v>codingset2); 
2094 
i += skip; 
2095 
if(i > 31) 
2096 
break;

2097 
idx = vc1_simple_progressive_8x4_zz[i++]; 
2098 
block[idx + off] = value * scale; 
2099 
} 
2100 
if(!(subblkpat & (1 << (1  j)))) 
2101 
vc1_inv_trans(block + off, 8, 4); 
2102 
} 
2103 
break;

2104 
case TT_4X8:

2105 
for(j = 0; j < 2; j++) { 
2106 
last = subblkpat & (1 << (1  j)); 
2107 
i = 0;

2108 
off = j * 4;

2109 
while (!last) {

2110 
vc1_decode_ac_coeff(v, &last, &skip, &value, v>codingset2); 
2111 
i += skip; 
2112 
if(i > 31) 
2113 
break;

2114 
idx = vc1_simple_progressive_4x8_zz[i++]; 
2115 
block[idx + off] = value * scale; 
2116 
} 
2117 
if(!(subblkpat & (1 << (1  j)))) 
2118 
vc1_inv_trans(block + off, 4, 8); 
2119 
} 
2120 
break;

2121 
} 
2122 
return 0; 
2123 
} 
2124  
2125  
2126 
/** Decode one Pframe MB (in Simple/Main profile)

2127 
* @todo TODO: Extend to AP

2128 
* @fixme FIXME: DC value for inter blocks not set

2129 
*/

2130 
static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64]) 
2131 
{ 
2132 
MpegEncContext *s = &v>s; 
2133 
GetBitContext *gb = &s>gb; 
2134 
int i, j;

2135 
int mb_pos = s>mb_x + s>mb_y * s>mb_stride;

2136 
int cbp; /* cbp decoding stuff */ 
2137 
int hybrid_pred; /* Prediction types */ 
2138 
int mqdiff, mquant; /* MB quantization */ 
2139 
int ttmb = v>ttmb; /* MB Transform type */ 
2140 
int status;

2141  
2142 
static const int size_table[6] = { 0, 2, 3, 4, 5, 8 }, 
2143 
offset_table[6] = { 0, 1, 3, 7, 15, 31 }; 
2144 
int mb_has_coeffs = 1; /* last_flag */ 
2145 
int dmv_x, dmv_y; /* Differential MV components */ 
2146 
int index, index1; /* LUT indices */ 
2147 
int val, sign; /* temp values */ 
2148 
int first_block = 1; 
2149 
int dst_idx, off;

2150 
int skipped, fourmv;

2151  
2152 
mquant = v>pq; /* Loosy initialization */

2153  
2154 
if (v>mv_type_is_raw)

2155 
fourmv = get_bits1(gb); 
2156 
else

2157 
fourmv = v>mv_type_mb_plane[mb_pos]; 
2158 
if (v>skip_is_raw)

2159 
skipped = get_bits1(gb); 
2160 
else

2161 
skipped = v>skip_mb_plane[mb_pos]; 
2162  
2163 
if (!fourmv) /* 1MV mode */ 
2164 
{ 
2165 
if (!skipped)

2166 
{ 
2167 
GET_MVDATA(dmv_x, dmv_y); 
2168  
2169 
s>current_picture.mb_type[mb_pos] = s>mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16; 
2170 
vc1_pred_mv(s, dmv_x, dmv_y, 1, v>range_x, v>range_y);

2171  
2172 
/* FIXME Set DC val for inter block ? */

2173 
if (s>mb_intra && !mb_has_coeffs)

2174 
{ 
2175 
GET_MQUANT(); 
2176 
s>ac_pred = get_bits(gb, 1);

2177 
cbp = 0;

2178 
} 
2179 
else if (mb_has_coeffs) 
2180 
{ 
2181 
if (s>mb_intra) s>ac_pred = get_bits(gb, 1); 
2182 
cbp = get_vlc2(&v>s.gb, v>cbpcy_vlc>table, VC1_CBPCY_P_VLC_BITS, 2);

2183 
GET_MQUANT(); 
2184 
} 
2185 
else

2186 
{ 
2187 
mquant = v>pq; 
2188 
cbp = 0;

2189 
} 
2190 
s>current_picture.qscale_table[mb_pos] = mquant; 
2191  
2192 
if (!v>ttmbf && !s>mb_intra && mb_has_coeffs)

2193 
ttmb = get_vlc2(gb, vc1_ttmb_vlc[v>tt_index].table, 
2194 
VC1_TTMB_VLC_BITS, 2);

2195 
s>dsp.clear_blocks(block[0]);

2196 
vc1_mc_1mv(v); 
2197 
dst_idx = 0;

2198 
for (i=0; i<6; i++) 
2199 
{ 
2200 
s>dc_val[0][s>block_index[i]] = 0; 
2201 
dst_idx += i >> 2;

2202 
val = ((cbp >> (5  i)) & 1); 
2203 
off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s>linesize); 
2204 
if(s>mb_intra) {

2205 
/* check if prediction blocks A and C are available */

2206 
v>a_avail = v>c_avail = 0;

2207 
if((i == 2  i == 3)  (s>mb_y && IS_INTRA(s>current_picture.mb_type[mb_pos  s>mb_stride]))) 
2208 
v>a_avail = 1;

2209 
if((i == 1  i == 3)  (s>mb_x && IS_INTRA(s>current_picture.mb_type[mb_pos  1]))) 
2210 
v>c_avail = 1;

2211  
2212 
vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v>codingset2:v>codingset);

2213 
vc1_inv_trans(block[i], 8, 8); 
2214 
for(j = 0; j < 64; j++) block[i][j] += 128; 
2215 
s>dsp.put_pixels_clamped(block[i], s>dest[dst_idx] + off, s>linesize >> ((i & 4) >> 2)); 
2216 
/* TODO: proper loop filtering */

2217 
if(v>pq >= 9 && v>overlap) { 
2218 
if(v>a_avail)

2219 
s>dsp.h263_v_loop_filter(s>dest[dst_idx] + off, s>linesize >> ((i & 4) >> 2), s>y_dc_scale); 
2220 
if(v>c_avail)

2221 
s>dsp.h263_h_loop_filter(s>dest[dst_idx] + off, s>linesize >> ((i & 4) >> 2), s>y_dc_scale); 
2222 
} 
2223 
} else if(val) { 
2224 
vc1_decode_p_block(v, block[i], i, mquant, ttmb, first_block); 
2225 
if(!v>ttmbf && ttmb < 8) ttmb = 1; 
2226 
first_block = 0;

2227 
s>dsp.add_pixels_clamped(block[i], s>dest[dst_idx] + off, (i&4)?s>uvlinesize:s>linesize);

2228 
} 
2229 
} 
2230 
} 
2231 
else //Skipped 
2232 
{ 
2233 
s>mb_intra = 0;

2234 
s>current_picture.mb_type[mb_pos] = MB_TYPE_SKIP; 
2235 
vc1_pred_mv(s, 0, 0, 1, v>range_x, v>range_y); 
2236 
vc1_mc_1mv(v); 
2237 
return 0; 
2238 
} 
2239 
} //1MV mode

2240 
else //4MV mode 
2241 
{//FIXME: looks not conforming to standard and is not even theoretically complete

2242 
if (!skipped /* unskipped MB */) 
2243 
{ 
2244 
int blk_intra[4], blk_coded[4]; 
2245 
/* Get CBPCY */

2246 
cbp = get_vlc2(&v>s.gb, v>cbpcy_vlc>table, VC1_CBPCY_P_VLC_BITS, 2);

2247 
for (i=0; i<4; i++) 
2248 
{ 
2249 
val = ((cbp >> (5  i)) & 1); 
2250 
blk_intra[i] = 0;

2251 
blk_coded[i] = val; 
2252 
if(val) {

2253 
GET_MVDATA(dmv_x, dmv_y); 
2254 
blk_intra[i] = s>mb_intra; 
2255 
} 
2256 
if (v>mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */) 
2257 
hybrid_pred = get_bits(gb, 1);

2258 
} 
2259 
if((blk_intra[0]  blk_intra[1]  blk_intra[2]  blk_intra[3])  
2260 
(blk_coded[0]  blk_coded[1]  blk_coded[2]  blk_coded[3])) { 
2261 
GET_MQUANT(); 
2262  
2263 
if (s>mb_intra /* One of the 4 blocks is intra */ 
2264 
/* nonzero pred for that block */)

2265 
s>ac_pred = get_bits(gb, 1);

2266 
if (!v>ttmbf)

2267 
ttmb = get_vlc2(gb, vc1_ttmb_vlc[v>tt_index].table, 
2268 
VC1_TTMB_VLC_BITS, 12);

2269 
for(i = 0; i < 6; i++) { 
2270 
val = ((cbp >> (5  i)) & 1); 
2271 
if(i & 4  blk_intra[i]  val) { 
2272 
if(i < 4 && blk_intra[i]) 
2273 
status = vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v>codingset2:v>codingset);

2274 
else

2275 
status = vc1_decode_p_block(v, block[i], i, mquant, ttmb, 0);

2276 
} 
2277 
} 
2278 
} 
2279 
return status;

2280 
} 
2281 
else //Skipped MB 
2282 
{ 
2283 
/* XXX: Skipped => cbp=0 and mquant doesn't matter ? */

2284 
for (i=0; i<4; i++) 
2285 
{ 
2286 
if (v>mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */) 
2287 
hybrid_pred = get_bits(gb, 1);

2288 
} 
2289 
/* TODO: blah */

2290 
return 0; 
2291 
} 
2292 
} 
2293  
2294 
/* Should never happen */

2295 
return 1; 
2296 
} 
2297  
2298 
/** Decode blocks of Iframe

2299 
*/

2300 
static void vc1_decode_i_blocks(VC1Context *v) 
2301 
{ 
2302 
int k;

2303 
MpegEncContext *s = &v>s; 
2304 
int cbp, val;

2305 
uint8_t *coded_val; 
2306 
int mb_pos;

2307  
2308 
/* select codingmode used for VLC tables selection */

2309 
switch(v>y_ac_table_index){

2310 
case 0: 
2311 
v>codingset = (v>pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;

2312 
break;

2313 
case 1: 
2314 
v>codingset = CS_HIGH_MOT_INTRA; 
2315 
break;

2316 
case 2: 
2317 
v>codingset = CS_MID_RATE_INTRA; 
2318 
break;

2319 
} 
2320  
2321 
switch(v>c_ac_table_index){

2322 
case 0: 
2323 
v>codingset2 = (v>pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;

2324 
break;

2325 
case 1: 
2326 
v>codingset2 = CS_HIGH_MOT_INTER; 
2327 
break;

2328 
case 2: 
2329 
v>codingset2 = CS_MID_RATE_INTER; 
2330 
break;

2331 
} 
2332  
2333 
/* Set DC scale  y and c use the same */

2334 
s>y_dc_scale = s>y_dc_scale_table[v>pq]; 
2335 
s>c_dc_scale = s>c_dc_scale_table[v>pq]; 
2336  
2337 
//do frame decode

2338 
s>mb_x = s>mb_y = 0;

2339 
s>mb_intra = 1;

2340 
ff_er_add_slice(s, 0, 0, s>mb_width  1, s>mb_height  1, (AC_ENDDC_ENDMV_END)); 
2341 
for(s>mb_y = 0; s>mb_y < s>mb_height; s>mb_y++) { 
2342 
for(s>mb_x = 0; s>mb_x < s>mb_width; s>mb_x++) { 
2343 
ff_init_block_index(s); 
2344 
ff_update_block_index(s); 
2345 
s>dsp.clear_blocks(s>block[0]);

2346 
mb_pos = s>mb_x + s>mb_y * s>mb_width; 
2347 
s>current_picture.mb_type[mb_pos] = MB_TYPE_INTRA; 
2348 
s>current_picture.qscale_table[mb_pos] = v>pq; 
2349  
2350 
// do actual MB decoding and displaying

2351 
cbp = get_vlc2(&v>s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);

2352 
v>s.ac_pred = get_bits(&v>s.gb, 1);

2353  
2354 
for(k = 0; k < 6; k++) { 
2355 
val = ((cbp >> (5  k)) & 1); 
2356  
2357 
if (k < 4) { 
2358 
int pred = vc1_coded_block_pred(&v>s, k, &coded_val);

2359 
val = val ^ pred; 
2360 
*coded_val = val; 
2361 
} 
2362 
cbp = val << (5  k);

2363  
2364 
vc1_decode_i_block(v, s>block[k], k, val, (k<4)? v>codingset : v>codingset2);

2365  
2366 
vc1_inv_trans(s>block[k], 8, 8); 
2367 
if(v>pq >= 9 && v>overlap) { 
2368 
vc1_overlap_block(s, s>block[k], k, (s>mb_y  k>1), (s>mb_x  (k != 0 && k != 2))); 
2369 
} 
2370 
} 
2371  
2372 
vc1_put_block(v, s>block); 
2373 
if(v>pq >= 9 && v>overlap) { /* XXX: do proper overlapping insted of loop filter */ 
2374 
if(s>mb_y) {

2375 
s>dsp.h263_v_loop_filter(s>dest[0], s>linesize, s>y_dc_scale);

2376 
s>dsp.h263_v_loop_filter(s>dest[0] + 8, s>linesize, s>y_dc_scale); 
2377 
s>dsp.h263_v_loop_filter(s>dest[1], s>uvlinesize, s>y_dc_scale);

2378 
s>dsp.h263_v_loop_filter(s>dest[2], s>uvlinesize, s>y_dc_scale);

2379 
} 
2380 
s>dsp.h263_v_loop_filter(s>dest[0] + 8 * s>linesize, s>linesize, s>y_dc_scale); 
2381 
s>dsp.h263_v_loop_filter(s>dest[0] + 8 * s>linesize + 8, s>linesize, s>y_dc_scale); 
2382 
if(s>mb_x) {

2383 
s>dsp.h263_h_loop_filter(s>dest[0], s>linesize, s>y_dc_scale);

2384 
s>dsp.h263_h_loop_filter(s>dest[0] + 8 * s>linesize, s>linesize, s>y_dc_scale); 
2385 
s>dsp.h263_h_loop_filter(s>dest[1], s>uvlinesize, s>y_dc_scale);

2386 
s>dsp.h263_h_loop_filter(s>dest[2], s>uvlinesize, s>y_dc_scale);

2387 
} 
2388 
s>dsp.h263_h_loop_filter(s>dest[0] + 8, s>linesize, s>y_dc_scale); 
2389 
s>dsp.h263_h_loop_filter(s>dest[0] + 8 * s>linesize + 8, s>linesize, s>y_dc_scale); 
2390 
} 
2391  
2392 
if(get_bits_count(&s>gb) > v>bits) {

2393 
av_log(s>avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s>gb), v>bits);

2394 
return;

2395 
} 
2396 
} 
2397 
ff_draw_horiz_band(s, s>mb_y * 16, 16); 
2398 
} 
2399 
} 
2400  
2401 
static void vc1_decode_p_blocks(VC1Context *v) 
2402 
{ 
2403 
MpegEncContext *s = &v>s; 
2404  
2405 
/* select codingmode used for VLC tables selection */

2406 
switch(v>c_ac_table_index){

2407 
case 0: 
2408 
v>codingset = (v>pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;

2409 
break;

2410 
case 1: 
2411 
v>codingset = CS_HIGH_MOT_INTRA; 
2412 
break;

2413 
case 2: 
2414 
v>codingset = CS_MID_RATE_INTRA; 
2415 
break;

2416 
} 
2417  
2418 
switch(v>c_ac_table_index){

2419 
case 0: 
2420 
v>codingset2 = (v>pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;

2421 
break;

2422 
case 1: 
2423 
v>codingset2 = CS_HIGH_MOT_INTER; 
2424 
break;

2425 
case 2: 
2426 
v>codingset2 = CS_MID_RATE_INTER; 
2427 
break;

2428 
} 
2429  
2430 
ff_er_add_slice(s, 0, 0, s>mb_width  1, s>mb_height  1, (AC_ENDDC_ENDMV_END)); 
2431 
s>first_slice_line = 1;

2432 
for(s>mb_y = 0; s>mb_y < s>mb_height; s>mb_y++) { 
2433 
for(s>mb_x = 0; s>mb_x < s>mb_width; s>mb_x++) { 
2434 
ff_init_block_index(s); 
2435 
ff_update_block_index(s); 
2436 
s>dsp.clear_blocks(s>block[0]);

2437  
2438 
vc1_decode_p_mb(v, s>block); 
2439 
if(get_bits_count(&s>gb) > v>bits  get_bits_count(&s>gb) < 0) { 
2440 
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);

2441 
return;

2442 
} 
2443 
} 
2444 
ff_draw_horiz_band(s, s>mb_y * 16, 16); 
2445 
s>first_slice_line = 0;

2446 
} 
2447 
} 
2448  
2449 
static void vc1_decode_blocks(VC1Context *v) 
2450 
{ 
2451  
2452 
v>s.esc3_level_length = 0;

2453  
2454 
switch(v>s.pict_type) {

2455 
case I_TYPE:

2456 
vc1_decode_i_blocks(v); 
2457 
break;

2458 
case P_TYPE:

2459 
vc1_decode_p_blocks(v); 
2460 
break;

2461 
} 
2462 
} 
2463  
2464  
2465 
/** Initialize a VC1/WMV3 decoder

2466 
* @todo TODO: Handle VC1 IDUs (Transport level?)

2467 
* @todo TODO: Decypher remaining bits in extra_data

2468 
*/

2469 
static int vc1_decode_init(AVCodecContext *avctx) 
2470 
{ 
2471 
VC1Context *v = avctx>priv_data; 
2472 
MpegEncContext *s = &v>s; 
2473 
GetBitContext gb; 
2474  
2475 
if (!avctx>extradata_size  !avctx>extradata) return 1; 
2476 
avctx>pix_fmt = PIX_FMT_YUV420P; 
2477 
v>s.avctx = avctx; 
2478 
avctx>flags = CODEC_FLAG_EMU_EDGE; 
2479 
v>s.flags = CODEC_FLAG_EMU_EDGE; 
2480  
2481 
if(ff_h263_decode_init(avctx) < 0) 
2482 
return 1; 
2483 
if (vc1_init_common(v) < 0) return 1; 
2484  
2485 
av_log(avctx, AV_LOG_INFO, "This decoder is not supposed to produce picture. Dont report this as a bug!\n");

2486 
av_log(avctx, AV_LOG_INFO, "If you see a picture, don't believe your eyes.\n");

2487  
2488 
avctx>coded_width = avctx>width; 
2489 
avctx>coded_height = avctx>height; 
2490 
if (avctx>codec_id == CODEC_ID_WMV3)

2491 
{ 
2492 
int count = 0; 
2493  
2494 
// looks like WMV3 has a sequence header stored in the extradata

2495 
// advanced sequence header may be before the first frame

2496 
// the last byte of the extradata is a version number, 1 for the

2497 
// samples we can decode

2498  
2499 
init_get_bits(&gb, avctx>extradata, avctx>extradata_size*8);

2500  
2501 
if (decode_sequence_header(avctx, &gb) < 0) 
2502 
return 1; 
2503  
2504 
count = avctx>extradata_size*8  get_bits_count(&gb);

2505 
if (count>0) 
2506 
{ 
2507 
av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",

2508 
count, get_bits(&gb, count)); 
2509 
} 
2510 
else if (count < 0) 
2511 
{ 
2512 
av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", count);

2513 
} 
2514 
} 
2515 
avctx>has_b_frames= !!(avctx>max_b_frames); 
2516  
2517 
s>mb_width = (avctx>coded_width+15)>>4; 
2518 
s>mb_height = (avctx>coded_height+15)>>4; 
2519  
2520 
/* Allocate mb bitplanes */

2521 
v>mv_type_mb_plane = av_malloc(s>mb_stride * s>mb_height); 
2522 
v>skip_mb_plane = av_malloc(s>mb_stride * s>mb_height); 
2523  
2524 
/* For predictors */

2525 
v>previous_line_cbpcy = (uint8_t *)av_malloc(s>mb_stride*4);

2526 
if (!v>previous_line_cbpcy) return 1; 
2527  
2528 
/* Init coded blocks info */

2529 
if (v>profile == PROFILE_ADVANCED)

2530 
{ 
2531 
// if (alloc_bitplane(&v>over_flags_plane, s>mb_width, s>mb_height) < 0)

2532 
// return 1;

2533 
// if (alloc_bitplane(&v>ac_pred_plane, s>mb_width, s>mb_height) < 0)

2534 
// return 1;

2535 
} 
2536  
2537 
return 0; 
2538 
} 
2539  
2540  
2541 
/** Decode a VC1/WMV3 frame

2542 
* @todo TODO: Handle VC1 IDUs (Transport level?)

2543 
* @warning Initial try at using MpegEncContext stuff

2544 
*/

2545 
static int vc1_decode_frame(AVCodecContext *avctx, 
2546 
void *data, int *data_size, 
2547 
uint8_t *buf, int buf_size)

2548 
{ 
2549 
VC1Context *v = avctx>priv_data; 
2550 
MpegEncContext *s = &v>s; 
2551 
AVFrame *pict = data; 
2552  
2553 
/* no supplementary picture */

2554 
if (buf_size == 0) { 
2555 
/* special case for last picture */

2556 
if (s>low_delay==0 && s>next_picture_ptr) { 
2557 
*pict= *(AVFrame*)s>next_picture_ptr; 
2558 
s>next_picture_ptr= NULL;

2559  
2560 
*data_size = sizeof(AVFrame);

2561 
} 
2562  
2563 
return 0; 
2564 
} 
2565  
2566 
//we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there

2567 
if(s>current_picture_ptr==NULL  s>current_picture_ptr>data[0]){ 
2568 
int i= ff_find_unused_picture(s, 0); 
2569 
s>current_picture_ptr= &s>picture[i]; 
2570 
} 
2571  
2572 
avctx>has_b_frames= !s>low_delay; 
2573  
2574 
init_get_bits(&s>gb, buf, buf_size*8);

2575 
// do parse frame header

2576 
if(vc1_parse_frame_header(v, &s>gb) == 1) 
2577 
return 1; 
2578  
2579 
if(s>pict_type != I_TYPE && s>pict_type != P_TYPE)return 1; 
2580  
2581 
// for hurry_up==5

2582 
s>current_picture.pict_type= s>pict_type; 
2583 
s>current_picture.key_frame= s>pict_type == I_TYPE; 
2584  
2585 
/* skip Bframes if we don't have reference frames */

2586 
if(s>last_picture_ptr==NULL && (s>pict_type==B_TYPE  s>dropable)) return 1;//buf_size; 
2587 
/* skip b frames if we are in a hurry */

2588 
if(avctx>hurry_up && s>pict_type==B_TYPE) return 1;//buf_size; 
2589 
if( (avctx>skip_frame >= AVDISCARD_NONREF && s>pict_type==B_TYPE)

2590 
 (avctx>skip_frame >= AVDISCARD_NONKEY && s>pict_type!=I_TYPE) 
2591 
 avctx>skip_frame >= AVDISCARD_ALL) 
2592 
return buf_size;

2593 
/* skip everything if we are in a hurry>=5 */

2594 
if(avctx>hurry_up>=5) return 1;//buf_size; 
2595  
2596 
if(s>next_p_frame_damaged){

2597 
if(s>pict_type==B_TYPE)

2598 
return buf_size;

2599 
else

2600 
s>next_p_frame_damaged=0;

2601 
} 
2602  
2603 
if(MPV_frame_start(s, avctx) < 0) 
2604 
return 1; 
2605  
2606 
ff_er_frame_start(s); 
2607  
2608 
v>bits = buf_size * 8;

2609 
vc1_decode_blocks(v); 
2610 
//av_log(s>avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s>gb), buf_size*8);

2611 
// if(get_bits_count(&s>gb) > buf_size * 8)

2612 
// return 1;

2613 
ff_er_frame_end(s); 
2614  
2615 
MPV_frame_end(s); 
2616  
2617 
assert(s>current_picture.pict_type == s>current_picture_ptr>pict_type); 
2618 
assert(s>current_picture.pict_type == s>pict_type); 
2619 
if (s>pict_type == B_TYPE  s>low_delay) {

2620 
*pict= *(AVFrame*)s>current_picture_ptr; 
2621 
} else if (s>last_picture_ptr != NULL) { 
2622 
*pict= *(AVFrame*)s>last_picture_ptr; 
2623 
} 
2624  
2625 
if(s>last_picture_ptr  s>low_delay){

2626 
*data_size = sizeof(AVFrame);

2627 
ff_print_debug_info(s, pict); 
2628 
} 
2629  
2630 
/* Return the Picture timestamp as the frame number */

2631 
/* we substract 1 because it is added on utils.c */

2632 
avctx>frame_number = s>picture_number  1;

2633  
2634 
return buf_size;

2635 
} 
2636  
2637  
2638 
/** Close a VC1/WMV3 decoder

2639 
* @warning Initial try at using MpegEncContext stuff

2640 
*/

2641 
static int vc1_decode_end(AVCodecContext *avctx) 
2642 
{ 
2643 
VC1Context *v = avctx>priv_data; 
2644  
2645 
av_freep(&v>hrd_rate); 
2646 
av_freep(&v>hrd_buffer); 
2647 
MPV_common_end(&v>s); 
2648 
av_freep(&v>mv_type_mb_plane); 
2649 
av_freep(&v>skip_mb_plane); 
2650 
return 0; 
2651 
} 
2652  
2653  
2654 
AVCodec vc1_decoder = { 
2655 
"vc1",

2656 
CODEC_TYPE_VIDEO, 
2657 
CODEC_ID_VC1, 
2658 
sizeof(VC1Context),

2659 
vc1_decode_init, 
2660 
NULL,

2661 
vc1_decode_end, 
2662 
vc1_decode_frame, 
2663 
CODEC_CAP_DELAY, 
2664 
NULL

2665 
}; 
2666  
2667 
AVCodec wmv3_decoder = { 
2668 
"wmv3",

2669 
CODEC_TYPE_VIDEO, 
2670 
CODEC_ID_WMV3, 
2671 
sizeof(VC1Context),

2672 
vc1_decode_init, 
2673 
NULL,

2674 
vc1_decode_end, 
2675 
vc1_decode_frame, 
2676 
CODEC_CAP_DELAY, 
2677 
NULL

2678 
}; 