Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vc1.c @ 8ea780d7

History | View | Annotate | Download (148 KB)

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 file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 *
22
 */
23

    
24
/**
25
 * @file vc1.c
26
 * VC-1 and WMV3 decoder
27
 *
28
 */
29
#include "common.h"
30
#include "dsputil.h"
31
#include "avcodec.h"
32
#include "mpegvideo.h"
33
#include "vc1data.h"
34
#include "vc1acdata.h"
35

    
36
#undef NDEBUG
37
#include <assert.h>
38

    
39
extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];
40
extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];
41
extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];
42
#define MB_INTRA_VLC_BITS 9
43
extern VLC ff_msmp4_mb_i_vlc;
44
extern const uint16_t ff_msmp4_mb_i_table[64][2];
45
#define DC_VLC_BITS 9
46
#define AC_VLC_BITS 9
47
static const uint16_t table_mb_intra[64][2];
48

    
49

    
50
/** Available Profiles */
51
//@{
52
enum Profile {
53
    PROFILE_SIMPLE,
54
    PROFILE_MAIN,
55
    PROFILE_COMPLEX, ///< TODO: WMV9 specific
56
    PROFILE_ADVANCED
57
};
58
//@}
59

    
60
/** Sequence quantizer mode */
61
//@{
62
enum QuantMode {
63
    QUANT_FRAME_IMPLICIT,    ///< Implicitly specified at frame level
64
    QUANT_FRAME_EXPLICIT,    ///< Explicitly specified at frame level
65
    QUANT_NON_UNIFORM,       ///< Non-uniform quant used for all frames
66
    QUANT_UNIFORM            ///< Uniform quant used for all frames
67
};
68
//@}
69

    
70
/** Where quant can be changed */
71
//@{
72
enum DQProfile {
73
    DQPROFILE_FOUR_EDGES,
74
    DQPROFILE_DOUBLE_EDGES,
75
    DQPROFILE_SINGLE_EDGE,
76
    DQPROFILE_ALL_MBS
77
};
78
//@}
79

    
80
/** @name Where quant can be changed
81
 */
82
//@{
83
enum DQSingleEdge {
84
    DQSINGLE_BEDGE_LEFT,
85
    DQSINGLE_BEDGE_TOP,
86
    DQSINGLE_BEDGE_RIGHT,
87
    DQSINGLE_BEDGE_BOTTOM
88
};
89
//@}
90

    
91
/** Which pair of edges is quantized with ALTPQUANT */
92
//@{
93
enum DQDoubleEdge {
94
    DQDOUBLE_BEDGE_TOPLEFT,
95
    DQDOUBLE_BEDGE_TOPRIGHT,
96
    DQDOUBLE_BEDGE_BOTTOMRIGHT,
97
    DQDOUBLE_BEDGE_BOTTOMLEFT
98
};
99
//@}
100

    
101
/** MV modes for P frames */
102
//@{
103
enum MVModes {
104
    MV_PMODE_1MV_HPEL_BILIN,
105
    MV_PMODE_1MV,
106
    MV_PMODE_1MV_HPEL,
107
    MV_PMODE_MIXED_MV,
108
    MV_PMODE_INTENSITY_COMP
109
};
110
//@}
111

    
112
/** @name MV types for B frames */
113
//@{
114
enum BMVTypes {
115
    BMV_TYPE_BACKWARD,
116
    BMV_TYPE_FORWARD,
117
    BMV_TYPE_INTERPOLATED
118
};
119
//@}
120

    
121
/** @name Block types for P/B frames */
122
//@{
123
enum TransformTypes {
124
    TT_8X8,
125
    TT_8X4_BOTTOM,
126
    TT_8X4_TOP,
127
    TT_8X4, //Both halves
128
    TT_4X8_RIGHT,
129
    TT_4X8_LEFT,
130
    TT_4X8, //Both halves
131
    TT_4X4
132
};
133
//@}
134

    
135
/** Table for conversion between TTBLK and TTMB */
136
static const int ttblk_to_tt[3][8] = {
137
  { TT_8X4, TT_4X8, TT_8X8, TT_4X4, TT_8X4_TOP, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT },
138
  { TT_8X8, TT_4X8_RIGHT, TT_4X8_LEFT, TT_4X4, TT_8X4, TT_4X8, TT_8X4_BOTTOM, TT_8X4_TOP },
139
  { TT_8X8, TT_4X8, TT_4X4, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT, TT_8X4, TT_8X4_TOP }
140
};
141

    
142
static const int ttfrm_to_tt[4] = { TT_8X8, TT_8X4, TT_4X8, TT_4X4 };
143

    
144
/** MV P mode - the 5th element is only used for mode 1 */
145
static const uint8_t mv_pmode_table[2][5] = {
146
  { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV },
147
  { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN }
148
};
149
static const uint8_t mv_pmode_table2[2][4] = {
150
  { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV },
151
  { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN }
152
};
153

    
154
/** One more frame type */
155
#define BI_TYPE 7
156

    
157
static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
158
  fps_dr[2] = { 1000, 1001 };
159
static const uint8_t pquant_table[3][32] = {
160
  {  /* Implicit quantizer */
161
     0,  1,  2,  3,  4,  5,  6,  7,  8,  6,  7,  8,  9, 10, 11, 12,
162
    13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
163
  },
164
  {  /* Explicit quantizer, pquantizer uniform */
165
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
166
    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
167
  },
168
  {  /* Explicit quantizer, pquantizer non-uniform */
169
     0,  1,  1,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,
170
    14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
171
  }
172
};
173

    
174
/** @name VC-1 VLC tables and defines
175
 *  @todo TODO move this into the context
176
 */
177
//@{
178
#define VC1_BFRACTION_VLC_BITS 7
179
static VLC vc1_bfraction_vlc;
180
#define VC1_IMODE_VLC_BITS 4
181
static VLC vc1_imode_vlc;
182
#define VC1_NORM2_VLC_BITS 3
183
static VLC vc1_norm2_vlc;
184
#define VC1_NORM6_VLC_BITS 9
185
static VLC vc1_norm6_vlc;
186
/* Could be optimized, one table only needs 8 bits */
187
#define VC1_TTMB_VLC_BITS 9 //12
188
static VLC vc1_ttmb_vlc[3];
189
#define VC1_MV_DIFF_VLC_BITS 9 //15
190
static VLC vc1_mv_diff_vlc[4];
191
#define VC1_CBPCY_P_VLC_BITS 9 //14
192
static VLC vc1_cbpcy_p_vlc[4];
193
#define VC1_4MV_BLOCK_PATTERN_VLC_BITS 6
194
static VLC vc1_4mv_block_pattern_vlc[4];
195
#define VC1_TTBLK_VLC_BITS 5
196
static VLC vc1_ttblk_vlc[3];
197
#define VC1_SUBBLKPAT_VLC_BITS 6
198
static VLC vc1_subblkpat_vlc[3];
199

    
200
static VLC vc1_ac_coeff_table[8];
201
//@}
202

    
203
enum CodingSet {
204
    CS_HIGH_MOT_INTRA = 0,
205
    CS_HIGH_MOT_INTER,
206
    CS_LOW_MOT_INTRA,
207
    CS_LOW_MOT_INTER,
208
    CS_MID_RATE_INTRA,
209
    CS_MID_RATE_INTER,
210
    CS_HIGH_RATE_INTRA,
211
    CS_HIGH_RATE_INTER
212
};
213

    
214
/** @name Overlap conditions for Advanced Profile */
215
//@{
216
enum COTypes {
217
    CONDOVER_NONE = 0,
218
    CONDOVER_ALL,
219
    CONDOVER_SELECT
220
};
221
//@}
222

    
223

    
224
/** The VC1 Context
225
 * @fixme Change size wherever another size is more efficient
226
 * Many members are only used for Advanced Profile
227
 */
228
typedef struct VC1Context{
229
    MpegEncContext s;
230

    
231
    int bits;
232

    
233
    /** Simple/Main Profile sequence header */
234
    //@{
235
    int res_sm;           ///< reserved, 2b
236
    int res_x8;           ///< reserved
237
    int multires;         ///< frame-level RESPIC syntax element present
238
    int res_fasttx;       ///< reserved, always 1
239
    int res_transtab;     ///< reserved, always 0
240
    int rangered;         ///< RANGEREDFRM (range reduction) syntax element present
241
                          ///< at frame level
242
    int res_rtm_flag;     ///< reserved, set to 1
243
    int reserved;         ///< reserved
244
    //@}
245

    
246
    /** Advanced Profile */
247
    //@{
248
    int level;            ///< 3bits, for Advanced/Simple Profile, provided by TS layer
249
    int chromaformat;     ///< 2bits, 2=4:2:0, only defined
250
    int postprocflag;     ///< Per-frame processing suggestion flag present
251
    int broadcast;        ///< TFF/RFF present
252
    int interlace;        ///< Progressive/interlaced (RPTFTM syntax element)
253
    int tfcntrflag;       ///< TFCNTR present
254
    int panscanflag;      ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
255
    int extended_dmv;     ///< Additional extended dmv range at P/B frame-level
256
    int color_prim;       ///< 8bits, chroma coordinates of the color primaries
257
    int transfer_char;    ///< 8bits, Opto-electronic transfer characteristics
258
    int matrix_coef;      ///< 8bits, Color primaries->YCbCr transform matrix
259
    int hrd_param_flag;   ///< Presence of Hypothetical Reference
260
                          ///< Decoder parameters
261
    int psf;              ///< Progressive Segmented Frame
262
    //@}
263

    
264
    /** Sequence header data for all Profiles
265
     * TODO: choose between ints, uint8_ts and monobit flags
266
     */
267
    //@{
268
    int profile;          ///< 2bits, Profile
269
    int frmrtq_postproc;  ///< 3bits,
270
    int bitrtq_postproc;  ///< 5bits, quantized framerate-based postprocessing strength
271
    int fastuvmc;         ///< Rounding of qpel vector to hpel ? (not in Simple)
272
    int extended_mv;      ///< Ext MV in P/B (not in Simple)
273
    int dquant;           ///< How qscale varies with MBs, 2bits (not in Simple)
274
    int vstransform;      ///< variable-size [48]x[48] transform type + info
275
    int overlap;          ///< overlapped transforms in use
276
    int quantizer_mode;   ///< 2bits, quantizer mode used for sequence, see QUANT_*
277
    int finterpflag;      ///< INTERPFRM present
278
    //@}
279

    
280
    /** Frame decoding info for all profiles */
281
    //@{
282
    uint8_t mv_mode;      ///< MV coding monde
283
    uint8_t mv_mode2;     ///< Secondary MV coding mode (B frames)
284
    int k_x;              ///< Number of bits for MVs (depends on MV range)
285
    int k_y;              ///< Number of bits for MVs (depends on MV range)
286
    int range_x, range_y; ///< MV range
287
    uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale
288
    /** pquant parameters */
289
    //@{
290
    uint8_t dquantfrm;
291
    uint8_t dqprofile;
292
    uint8_t dqsbedge;
293
    uint8_t dqbilevel;
294
    //@}
295
    /** AC coding set indexes
296
     * @see 8.1.1.10, p(1)10
297
     */
298
    //@{
299
    int c_ac_table_index; ///< Chroma index from ACFRM element
300
    int y_ac_table_index; ///< Luma index from AC2FRM element
301
    //@}
302
    int ttfrm;            ///< Transform type info present at frame level
303
    uint8_t ttmbf;        ///< Transform type flag
304
    uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
305
    int codingset;        ///< index of current table set from 11.8 to use for luma block decoding
306
    int codingset2;       ///< index of current table set from 11.8 to use for chroma block decoding
307
    int pqindex;          ///< raw pqindex used in coding set selection
308
    int a_avail, c_avail;
309
    uint8_t *mb_type_base, *mb_type[3];
310

    
311

    
312
    /** Luma compensation parameters */
313
    //@{
314
    uint8_t lumscale;
315
    uint8_t lumshift;
316
    //@}
317
    int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs
318
    uint8_t halfpq;       ///< Uniform quant over image and qp+.5
319
    uint8_t respic;       ///< Frame-level flag for resized images
320
    int buffer_fullness;  ///< HRD info
321
    /** Ranges:
322
     * -# 0 -> [-64n 63.f] x [-32, 31.f]
323
     * -# 1 -> [-128, 127.f] x [-64, 63.f]
324
     * -# 2 -> [-512, 511.f] x [-128, 127.f]
325
     * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
326
     */
327
    uint8_t mvrange;
328
    uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use
329
    VLC *cbpcy_vlc;               ///< CBPCY VLC table
330
    int tt_index;                 ///< Index for Transform Type tables
331
    uint8_t* mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)
332
    uint8_t* direct_mb_plane;     ///< bitplane for "direct" MBs
333
    int mv_type_is_raw;           ///< mv type mb plane is not coded
334
    int dmb_is_raw;               ///< direct mb plane is raw
335
    int skip_is_raw;              ///< skip mb plane is not coded
336
    uint8_t luty[256], lutuv[256]; // lookup tables used for intensity compensation
337
    int use_ic;                   ///< use intensity compensation in B-frames
338
    int rnd;                      ///< rounding control
339

    
340
    /** Frame decoding info for S/M profiles only */
341
    //@{
342
    uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
343
    uint8_t interpfrm;
344
    //@}
345

    
346
    /** Frame decoding info for Advanced profile */
347
    //@{
348
    uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
349
    uint8_t numpanscanwin;
350
    uint8_t tfcntr;
351
    uint8_t rptfrm, tff, rff;
352
    uint16_t topleftx;
353
    uint16_t toplefty;
354
    uint16_t bottomrightx;
355
    uint16_t bottomrighty;
356
    uint8_t uvsamp;
357
    uint8_t postproc;
358
    int hrd_num_leaky_buckets;
359
    uint8_t bit_rate_exponent;
360
    uint8_t buffer_size_exponent;
361
    uint8_t* acpred_plane;       ///< AC prediction flags bitplane
362
    int acpred_is_raw;
363
    uint8_t* over_flags_plane;   ///< Overflags bitplane
364
    int overflg_is_raw;
365
    uint8_t condover;
366
    uint16_t *hrd_rate, *hrd_buffer;
367
    uint8_t *hrd_fullness;
368
    uint8_t range_mapy_flag;
369
    uint8_t range_mapuv_flag;
370
    uint8_t range_mapy;
371
    uint8_t range_mapuv;
372
    //@}
373

    
374
    int p_frame_skipped;
375
    int bi_type;
376
} VC1Context;
377

    
378
/**
379
 * Get unary code of limited length
380
 * @fixme FIXME Slow and ugly
381
 * @param gb GetBitContext
382
 * @param[in] stop The bitstop value (unary code of 1's or 0's)
383
 * @param[in] len Maximum length
384
 * @return Unary length/index
385
 */
386
static int get_prefix(GetBitContext *gb, int stop, int len)
387
{
388
#if 1
389
    int i;
390

    
391
    for(i = 0; i < len && get_bits1(gb) != stop; i++);
392
    return i;
393
/*  int i = 0, tmp = !stop;
394

395
  while (i != len && tmp != stop)
396
  {
397
    tmp = get_bits(gb, 1);
398
    i++;
399
  }
400
  if (i == len && tmp != stop) return len+1;
401
  return i;*/
402
#else
403
  unsigned int buf;
404
  int log;
405

    
406
  OPEN_READER(re, gb);
407
  UPDATE_CACHE(re, gb);
408
  buf=GET_CACHE(re, gb); //Still not sure
409
  if (stop) buf = ~buf;
410

    
411
  log= av_log2(-buf); //FIXME: -?
412
  if (log < limit){
413
    LAST_SKIP_BITS(re, gb, log+1);
414
    CLOSE_READER(re, gb);
415
    return log;
416
  }
417

    
418
  LAST_SKIP_BITS(re, gb, limit);
419
  CLOSE_READER(re, gb);
420
  return limit;
421
#endif
422
}
423

    
424
static inline int decode210(GetBitContext *gb){
425
    int n;
426
    n = get_bits1(gb);
427
    if (n == 1)
428
        return 0;
429
    else
430
        return 2 - get_bits1(gb);
431
}
432

    
433
/**
434
 * Init VC-1 specific tables and VC1Context members
435
 * @param v The VC1Context to initialize
436
 * @return Status
437
 */
438
static int vc1_init_common(VC1Context *v)
439
{
440
    static int done = 0;
441
    int i = 0;
442

    
443
    v->hrd_rate = v->hrd_buffer = NULL;
444

    
445
    /* VLC tables */
446
    if(!done)
447
    {
448
        done = 1;
449
        init_vlc(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
450
                 vc1_bfraction_bits, 1, 1,
451
                 vc1_bfraction_codes, 1, 1, 1);
452
        init_vlc(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
453
                 vc1_norm2_bits, 1, 1,
454
                 vc1_norm2_codes, 1, 1, 1);
455
        init_vlc(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
456
                 vc1_norm6_bits, 1, 1,
457
                 vc1_norm6_codes, 2, 2, 1);
458
        init_vlc(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
459
                 vc1_imode_bits, 1, 1,
460
                 vc1_imode_codes, 1, 1, 1);
461
        for (i=0; i<3; i++)
462
        {
463
            init_vlc(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
464
                     vc1_ttmb_bits[i], 1, 1,
465
                     vc1_ttmb_codes[i], 2, 2, 1);
466
            init_vlc(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
467
                     vc1_ttblk_bits[i], 1, 1,
468
                     vc1_ttblk_codes[i], 1, 1, 1);
469
            init_vlc(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
470
                     vc1_subblkpat_bits[i], 1, 1,
471
                     vc1_subblkpat_codes[i], 1, 1, 1);
472
        }
473
        for(i=0; i<4; i++)
474
        {
475
            init_vlc(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
476
                     vc1_4mv_block_pattern_bits[i], 1, 1,
477
                     vc1_4mv_block_pattern_codes[i], 1, 1, 1);
478
            init_vlc(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
479
                     vc1_cbpcy_p_bits[i], 1, 1,
480
                     vc1_cbpcy_p_codes[i], 2, 2, 1);
481
            init_vlc(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
482
                     vc1_mv_diff_bits[i], 1, 1,
483
                     vc1_mv_diff_codes[i], 2, 2, 1);
484
        }
485
        for(i=0; i<8; i++)
486
            init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
487
                     &vc1_ac_tables[i][0][1], 8, 4,
488
                     &vc1_ac_tables[i][0][0], 8, 4, 1);
489
        init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
490
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
491
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
492
    }
493

    
494
    /* Other defaults */
495
    v->pq = -1;
496
    v->mvrange = 0; /* 7.1.1.18, p80 */
497

    
498
    return 0;
499
}
500

    
501
/***********************************************************************/
502
/**
503
 * @defgroup bitplane VC9 Bitplane decoding
504
 * @see 8.7, p56
505
 * @{
506
 */
507

    
508
/** @addtogroup bitplane
509
 * Imode types
510
 * @{
511
 */
512
enum Imode {
513
    IMODE_RAW,
514
    IMODE_NORM2,
515
    IMODE_DIFF2,
516
    IMODE_NORM6,
517
    IMODE_DIFF6,
518
    IMODE_ROWSKIP,
519
    IMODE_COLSKIP
520
};
521
/** @} */ //imode defines
522

    
523
/** Decode rows 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
 */
529
static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
530
    int x, y;
531

    
532
    for (y=0; y<height; y++){
533
        if (!get_bits(gb, 1)) //rowskip
534
            memset(plane, 0, width);
535
        else
536
            for (x=0; x<width; x++)
537
                plane[x] = get_bits(gb, 1);
538
        plane += stride;
539
    }
540
}
541

    
542
/** Decode columns by checking if they are skipped
543
 * @param plane Buffer to store decoded bits
544
 * @param[in] width Width of this buffer
545
 * @param[in] height Height of this buffer
546
 * @param[in] stride of this buffer
547
 * @fixme FIXME: Optimize
548
 */
549
static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
550
    int x, y;
551

    
552
    for (x=0; x<width; x++){
553
        if (!get_bits(gb, 1)) //colskip
554
            for (y=0; y<height; y++)
555
                plane[y*stride] = 0;
556
        else
557
            for (y=0; y<height; y++)
558
                plane[y*stride] = get_bits(gb, 1);
559
        plane ++;
560
    }
561
}
562

    
563
/** Decode a bitplane's bits
564
 * @param bp Bitplane where to store the decode bits
565
 * @param v VC-1 context for bit reading and logging
566
 * @return Status
567
 * @fixme FIXME: Optimize
568
 */
569
static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
570
{
571
    GetBitContext *gb = &v->s.gb;
572

    
573
    int imode, x, y, code, offset;
574
    uint8_t invert, *planep = data;
575
    int width, height, stride;
576

    
577
    width = v->s.mb_width;
578
    height = v->s.mb_height;
579
    stride = v->s.mb_stride;
580
    invert = get_bits(gb, 1);
581
    imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
582

    
583
    *raw_flag = 0;
584
    switch (imode)
585
    {
586
    case IMODE_RAW:
587
        //Data is actually read in the MB layer (same for all tests == "raw")
588
        *raw_flag = 1; //invert ignored
589
        return invert;
590
    case IMODE_DIFF2:
591
    case IMODE_NORM2:
592
        if ((height * width) & 1)
593
        {
594
            *planep++ = get_bits(gb, 1);
595
            offset = 1;
596
        }
597
        else offset = 0;
598
        // decode bitplane as one long line
599
        for (y = offset; y < height * width; y += 2) {
600
            code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
601
            *planep++ = code & 1;
602
            offset++;
603
            if(offset == width) {
604
                offset = 0;
605
                planep += stride - width;
606
            }
607
            *planep++ = code >> 1;
608
            offset++;
609
            if(offset == width) {
610
                offset = 0;
611
                planep += stride - width;
612
            }
613
        }
614
        break;
615
    case IMODE_DIFF6:
616
    case IMODE_NORM6:
617
        if(!(height % 3) && (width % 3)) { // use 2x3 decoding
618
            for(y = 0; y < height; y+= 3) {
619
                for(x = width & 1; x < width; x += 2) {
620
                    code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
621
                    if(code < 0){
622
                        av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
623
                        return -1;
624
                    }
625
                    planep[x + 0] = (code >> 0) & 1;
626
                    planep[x + 1] = (code >> 1) & 1;
627
                    planep[x + 0 + stride] = (code >> 2) & 1;
628
                    planep[x + 1 + stride] = (code >> 3) & 1;
629
                    planep[x + 0 + stride * 2] = (code >> 4) & 1;
630
                    planep[x + 1 + stride * 2] = (code >> 5) & 1;
631
                }
632
                planep += stride * 3;
633
            }
634
            if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
635
        } else { // 3x2
636
            planep += (height & 1) * stride;
637
            for(y = height & 1; y < height; y += 2) {
638
                for(x = width % 3; x < width; x += 3) {
639
                    code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
640
                    if(code < 0){
641
                        av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
642
                        return -1;
643
                    }
644
                    planep[x + 0] = (code >> 0) & 1;
645
                    planep[x + 1] = (code >> 1) & 1;
646
                    planep[x + 2] = (code >> 2) & 1;
647
                    planep[x + 0 + stride] = (code >> 3) & 1;
648
                    planep[x + 1 + stride] = (code >> 4) & 1;
649
                    planep[x + 2 + stride] = (code >> 5) & 1;
650
                }
651
                planep += stride * 2;
652
            }
653
            x = width % 3;
654
            if(x) decode_colskip(data  ,             x, height    , stride, &v->s.gb);
655
            if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
656
        }
657
        break;
658
    case IMODE_ROWSKIP:
659
        decode_rowskip(data, width, height, stride, &v->s.gb);
660
        break;
661
    case IMODE_COLSKIP:
662
        decode_colskip(data, width, height, stride, &v->s.gb);
663
        break;
664
    default: break;
665
    }
666

    
667
    /* Applying diff operator */
668
    if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
669
    {
670
        planep = data;
671
        planep[0] ^= invert;
672
        for (x=1; x<width; x++)
673
            planep[x] ^= planep[x-1];
674
        for (y=1; y<height; y++)
675
        {
676
            planep += stride;
677
            planep[0] ^= planep[-stride];
678
            for (x=1; x<width; x++)
679
            {
680
                if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
681
                else                                 planep[x] ^= planep[x-1];
682
            }
683
        }
684
    }
685
    else if (invert)
686
    {
687
        planep = data;
688
        for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
689
    }
690
    return (imode<<1) + invert;
691
}
692

    
693
/** @} */ //Bitplane group
694

    
695
/***********************************************************************/
696
/** VOP Dquant decoding
697
 * @param v VC-1 Context
698
 */
699
static int vop_dquant_decoding(VC1Context *v)
700
{
701
    GetBitContext *gb = &v->s.gb;
702
    int pqdiff;
703

    
704
    //variable size
705
    if (v->dquant == 2)
706
    {
707
        pqdiff = get_bits(gb, 3);
708
        if (pqdiff == 7) v->altpq = get_bits(gb, 5);
709
        else v->altpq = v->pq + pqdiff + 1;
710
    }
711
    else
712
    {
713
        v->dquantfrm = get_bits(gb, 1);
714
        if ( v->dquantfrm )
715
        {
716
            v->dqprofile = get_bits(gb, 2);
717
            switch (v->dqprofile)
718
            {
719
            case DQPROFILE_SINGLE_EDGE:
720
            case DQPROFILE_DOUBLE_EDGES:
721
                v->dqsbedge = get_bits(gb, 2);
722
                break;
723
            case DQPROFILE_ALL_MBS:
724
                v->dqbilevel = get_bits(gb, 1);
725
            default: break; //Forbidden ?
726
            }
727
            if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
728
            {
729
                pqdiff = get_bits(gb, 3);
730
                if (pqdiff == 7) v->altpq = get_bits(gb, 5);
731
                else v->altpq = v->pq + pqdiff + 1;
732
            }
733
        }
734
    }
735
    return 0;
736
}
737

    
738
/** Put block onto picture
739
 */
740
static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
741
{
742
    uint8_t *Y;
743
    int ys, us, vs;
744
    DSPContext *dsp = &v->s.dsp;
745

    
746
    if(v->rangeredfrm) {
747
        int i, j, k;
748
        for(k = 0; k < 6; k++)
749
            for(j = 0; j < 8; j++)
750
                for(i = 0; i < 8; i++)
751
                    block[k][i + j*8] = ((block[k][i + j*8] - 128) << 1) + 128;
752

    
753
    }
754
    ys = v->s.current_picture.linesize[0];
755
    us = v->s.current_picture.linesize[1];
756
    vs = v->s.current_picture.linesize[2];
757
    Y = v->s.dest[0];
758

    
759
    dsp->put_pixels_clamped(block[0], Y, ys);
760
    dsp->put_pixels_clamped(block[1], Y + 8, ys);
761
    Y += ys * 8;
762
    dsp->put_pixels_clamped(block[2], Y, ys);
763
    dsp->put_pixels_clamped(block[3], Y + 8, ys);
764

    
765
    if(!(v->s.flags & CODEC_FLAG_GRAY)) {
766
        dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
767
        dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
768
    }
769
}
770

    
771
/** Do motion compensation over 1 macroblock
772
 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
773
 */
774
static void vc1_mc_1mv(VC1Context *v, int dir)
775
{
776
    MpegEncContext *s = &v->s;
777
    DSPContext *dsp = &v->s.dsp;
778
    uint8_t *srcY, *srcU, *srcV;
779
    int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
780

    
781
    if(!v->s.last_picture.data[0])return;
782

    
783
    mx = s->mv[dir][0][0];
784
    my = s->mv[dir][0][1];
785

    
786
    // store motion vectors for further use in B frames
787
    if(s->pict_type == P_TYPE) {
788
        s->current_picture.motion_val[1][s->block_index[0]][0] = mx;
789
        s->current_picture.motion_val[1][s->block_index[0]][1] = my;
790
    }
791
    uvmx = (mx + ((mx & 3) == 3)) >> 1;
792
    uvmy = (my + ((my & 3) == 3)) >> 1;
793
    if(v->fastuvmc) {
794
        uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
795
        uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
796
    }
797
    if(!dir) {
798
        srcY = s->last_picture.data[0];
799
        srcU = s->last_picture.data[1];
800
        srcV = s->last_picture.data[2];
801
    } else {
802
        srcY = s->next_picture.data[0];
803
        srcU = s->next_picture.data[1];
804
        srcV = s->next_picture.data[2];
805
    }
806

    
807
    src_x = s->mb_x * 16 + (mx >> 2);
808
    src_y = s->mb_y * 16 + (my >> 2);
809
    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
810
    uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
811

    
812
    src_x   = clip(  src_x, -16, s->mb_width  * 16);
813
    src_y   = clip(  src_y, -16, s->mb_height * 16);
814
    uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
815
    uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
816

    
817
    srcY += src_y * s->linesize + src_x;
818
    srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
819
    srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
820

    
821
    /* for grayscale we should not try to read from unknown area */
822
    if(s->flags & CODEC_FLAG_GRAY) {
823
        srcU = s->edge_emu_buffer + 18 * s->linesize;
824
        srcV = s->edge_emu_buffer + 18 * s->linesize;
825
    }
826

    
827
    if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
828
       || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
829
       || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
830
        uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
831

    
832
        srcY -= s->mspel * (1 + s->linesize);
833
        ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
834
                            src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
835
        srcY = s->edge_emu_buffer;
836
        ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
837
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
838
        ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
839
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
840
        srcU = uvbuf;
841
        srcV = uvbuf + 16;
842
        /* if we deal with range reduction we need to scale source blocks */
843
        if(v->rangeredfrm) {
844
            int i, j;
845
            uint8_t *src, *src2;
846

    
847
            src = srcY;
848
            for(j = 0; j < 17 + s->mspel*2; j++) {
849
                for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
850
                src += s->linesize;
851
            }
852
            src = srcU; src2 = srcV;
853
            for(j = 0; j < 9; j++) {
854
                for(i = 0; i < 9; i++) {
855
                    src[i] = ((src[i] - 128) >> 1) + 128;
856
                    src2[i] = ((src2[i] - 128) >> 1) + 128;
857
                }
858
                src += s->uvlinesize;
859
                src2 += s->uvlinesize;
860
            }
861
        }
862
        /* if we deal with intensity compensation we need to scale source blocks */
863
        if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
864
            int i, j;
865
            uint8_t *src, *src2;
866

    
867
            src = srcY;
868
            for(j = 0; j < 17 + s->mspel*2; j++) {
869
                for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
870
                src += s->linesize;
871
            }
872
            src = srcU; src2 = srcV;
873
            for(j = 0; j < 9; j++) {
874
                for(i = 0; i < 9; i++) {
875
                    src[i] = v->lutuv[src[i]];
876
                    src2[i] = v->lutuv[src2[i]];
877
                }
878
                src += s->uvlinesize;
879
                src2 += s->uvlinesize;
880
            }
881
        }
882
        srcY += s->mspel * (1 + s->linesize);
883
    }
884

    
885
    if(s->mspel) {
886
        dxy = ((my & 3) << 2) | (mx & 3);
887
        dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0]    , srcY    , s->linesize, v->rnd);
888
        dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
889
        srcY += s->linesize * 8;
890
        dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
891
        dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
892
    } else { // hpel mc - always used for luma
893
        dxy = (my & 2) | ((mx & 2) >> 1);
894

    
895
        if(!v->rnd)
896
            dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
897
        else
898
            dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
899
    }
900

    
901
    if(s->flags & CODEC_FLAG_GRAY) return;
902
    /* Chroma MC always uses qpel bilinear */
903
    uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
904
    uvmx = (uvmx&3)<<1;
905
    uvmy = (uvmy&3)<<1;
906
    if(!v->rnd){
907
        dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
908
        dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
909
    }else{
910
        dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
911
        dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
912
    }
913
}
914

    
915
/** Do motion compensation for 4-MV macroblock - luminance block
916
 */
917
static void vc1_mc_4mv_luma(VC1Context *v, int n)
918
{
919
    MpegEncContext *s = &v->s;
920
    DSPContext *dsp = &v->s.dsp;
921
    uint8_t *srcY;
922
    int dxy, mx, my, src_x, src_y;
923
    int off;
924

    
925
    if(!v->s.last_picture.data[0])return;
926
    mx = s->mv[0][n][0];
927
    my = s->mv[0][n][1];
928
    srcY = s->last_picture.data[0];
929

    
930
    off = s->linesize * 4 * (n&2) + (n&1) * 8;
931

    
932
    src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
933
    src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
934

    
935
    src_x   = clip(  src_x, -16, s->mb_width  * 16);
936
    src_y   = clip(  src_y, -16, s->mb_height * 16);
937

    
938
    srcY += src_y * s->linesize + src_x;
939

    
940
    if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
941
       || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
942
       || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
943
        srcY -= s->mspel * (1 + s->linesize);
944
        ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
945
                            src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
946
        srcY = s->edge_emu_buffer;
947
        /* if we deal with range reduction we need to scale source blocks */
948
        if(v->rangeredfrm) {
949
            int i, j;
950
            uint8_t *src;
951

    
952
            src = srcY;
953
            for(j = 0; j < 9 + s->mspel*2; j++) {
954
                for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
955
                src += s->linesize;
956
            }
957
        }
958
        /* if we deal with intensity compensation we need to scale source blocks */
959
        if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
960
            int i, j;
961
            uint8_t *src;
962

    
963
            src = srcY;
964
            for(j = 0; j < 9 + s->mspel*2; j++) {
965
                for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
966
                src += s->linesize;
967
            }
968
        }
969
        srcY += s->mspel * (1 + s->linesize);
970
    }
971

    
972
    if(s->mspel) {
973
        dxy = ((my & 3) << 2) | (mx & 3);
974
        dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
975
    } else { // hpel mc - always used for luma
976
        dxy = (my & 2) | ((mx & 2) >> 1);
977
        if(!v->rnd)
978
            dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
979
        else
980
            dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
981
    }
982
}
983

    
984
static inline int median4(int a, int b, int c, int d)
985
{
986
    if(a < b) {
987
        if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
988
        else      return (FFMIN(b, c) + FFMAX(a, d)) / 2;
989
    } else {
990
        if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
991
        else      return (FFMIN(a, c) + FFMAX(b, d)) / 2;
992
    }
993
}
994

    
995

    
996
/** Do motion compensation for 4-MV macroblock - both chroma blocks
997
 */
998
static void vc1_mc_4mv_chroma(VC1Context *v)
999
{
1000
    MpegEncContext *s = &v->s;
1001
    DSPContext *dsp = &v->s.dsp;
1002
    uint8_t *srcU, *srcV;
1003
    int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1004
    int i, idx, tx = 0, ty = 0;
1005
    int mvx[4], mvy[4], intra[4];
1006
    static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1007

    
1008
    if(!v->s.last_picture.data[0])return;
1009
    if(s->flags & CODEC_FLAG_GRAY) return;
1010

    
1011
    for(i = 0; i < 4; i++) {
1012
        mvx[i] = s->mv[0][i][0];
1013
        mvy[i] = s->mv[0][i][1];
1014
        intra[i] = v->mb_type[0][s->block_index[i]];
1015
    }
1016

    
1017
    /* calculate chroma MV vector from four luma MVs */
1018
    idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1019
    if(!idx) { // all blocks are inter
1020
        tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1021
        ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1022
    } else if(count[idx] == 1) { // 3 inter blocks
1023
        switch(idx) {
1024
        case 0x1:
1025
            tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1026
            ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1027
            break;
1028
        case 0x2:
1029
            tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1030
            ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1031
            break;
1032
        case 0x4:
1033
            tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1034
            ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1035
            break;
1036
        case 0x8:
1037
            tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1038
            ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1039
            break;
1040
        }
1041
    } else if(count[idx] == 2) {
1042
        int t1 = 0, t2 = 0;
1043
        for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1044
        for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1045
        tx = (mvx[t1] + mvx[t2]) / 2;
1046
        ty = (mvy[t1] + mvy[t2]) / 2;
1047
    } else
1048
        return; //no need to do MC for inter blocks
1049

    
1050
    s->current_picture.motion_val[1][s->block_index[0]][0] = tx;
1051
    s->current_picture.motion_val[1][s->block_index[0]][1] = ty;
1052
    uvmx = (tx + ((tx&3) == 3)) >> 1;
1053
    uvmy = (ty + ((ty&3) == 3)) >> 1;
1054
    if(v->fastuvmc) {
1055
        uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1056
        uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1057
    }
1058

    
1059
    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1060
    uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1061

    
1062
    uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
1063
    uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
1064
    srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1065
    srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1066
    if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1067
       || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
1068
       || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
1069
        ff_emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize, 8+1, 8+1,
1070
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1071
        ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1072
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1073
        srcU = s->edge_emu_buffer;
1074
        srcV = s->edge_emu_buffer + 16;
1075

    
1076
        /* if we deal with range reduction we need to scale source blocks */
1077
        if(v->rangeredfrm) {
1078
            int i, j;
1079
            uint8_t *src, *src2;
1080

    
1081
            src = srcU; src2 = srcV;
1082
            for(j = 0; j < 9; j++) {
1083
                for(i = 0; i < 9; i++) {
1084
                    src[i] = ((src[i] - 128) >> 1) + 128;
1085
                    src2[i] = ((src2[i] - 128) >> 1) + 128;
1086
                }
1087
                src += s->uvlinesize;
1088
                src2 += s->uvlinesize;
1089
            }
1090
        }
1091
        /* if we deal with intensity compensation we need to scale source blocks */
1092
        if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1093
            int i, j;
1094
            uint8_t *src, *src2;
1095

    
1096
            src = srcU; src2 = srcV;
1097
            for(j = 0; j < 9; j++) {
1098
                for(i = 0; i < 9; i++) {
1099
                    src[i] = v->lutuv[src[i]];
1100
                    src2[i] = v->lutuv[src2[i]];
1101
                }
1102
                src += s->uvlinesize;
1103
                src2 += s->uvlinesize;
1104
            }
1105
        }
1106
    }
1107

    
1108
    /* Chroma MC always uses qpel bilinear */
1109
    uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
1110
    uvmx = (uvmx&3)<<1;
1111
    uvmy = (uvmy&3)<<1;
1112
    if(!v->rnd){
1113
        dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1114
        dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1115
    }else{
1116
        dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1117
        dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1118
    }
1119
}
1120

    
1121
static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
1122

    
1123
/**
1124
 * Decode Simple/Main Profiles sequence header
1125
 * @see Figure 7-8, p16-17
1126
 * @param avctx Codec context
1127
 * @param gb GetBit context initialized from Codec context extra_data
1128
 * @return Status
1129
 */
1130
static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1131
{
1132
    VC1Context *v = avctx->priv_data;
1133

    
1134
    av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
1135
    v->profile = get_bits(gb, 2);
1136
    if (v->profile == 2)
1137
    {
1138
        av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1139
        return -1;
1140
    }
1141

    
1142
    if (v->profile == PROFILE_ADVANCED)
1143
    {
1144
        return decode_sequence_header_adv(v, gb);
1145
    }
1146
    else
1147
    {
1148
        v->res_sm = get_bits(gb, 2); //reserved
1149
        if (v->res_sm)
1150
        {
1151
            av_log(avctx, AV_LOG_ERROR,
1152
                   "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1153
            return -1;
1154
        }
1155
    }
1156

    
1157
    // (fps-2)/4 (->30)
1158
    v->frmrtq_postproc = get_bits(gb, 3); //common
1159
    // (bitrate-32kbps)/64kbps
1160
    v->bitrtq_postproc = get_bits(gb, 5); //common
1161
    v->s.loop_filter = get_bits(gb, 1); //common
1162
    if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1163
    {
1164
        av_log(avctx, AV_LOG_ERROR,
1165
               "LOOPFILTER shell not be enabled in simple profile\n");
1166
    }
1167

    
1168
    v->res_x8 = get_bits(gb, 1); //reserved
1169
    if (v->res_x8)
1170
    {
1171
        av_log(avctx, AV_LOG_ERROR,
1172
               "1 for reserved RES_X8 is forbidden\n");
1173
        //return -1;
1174
    }
1175
    v->multires = get_bits(gb, 1);
1176
    v->res_fasttx = get_bits(gb, 1);
1177
    if (!v->res_fasttx)
1178
    {
1179
        av_log(avctx, AV_LOG_ERROR,
1180
               "0 for reserved RES_FASTTX is forbidden\n");
1181
        //return -1;
1182
    }
1183

    
1184
    v->fastuvmc =  get_bits(gb, 1); //common
1185
    if (!v->profile && !v->fastuvmc)
1186
    {
1187
        av_log(avctx, AV_LOG_ERROR,
1188
               "FASTUVMC unavailable in Simple Profile\n");
1189
        return -1;
1190
    }
1191
    v->extended_mv =  get_bits(gb, 1); //common
1192
    if (!v->profile && v->extended_mv)
1193
    {
1194
        av_log(avctx, AV_LOG_ERROR,
1195
               "Extended MVs unavailable in Simple Profile\n");
1196
        return -1;
1197
    }
1198
    v->dquant =  get_bits(gb, 2); //common
1199
    v->vstransform =  get_bits(gb, 1); //common
1200

    
1201
    v->res_transtab = get_bits(gb, 1);
1202
    if (v->res_transtab)
1203
    {
1204
        av_log(avctx, AV_LOG_ERROR,
1205
               "1 for reserved RES_TRANSTAB is forbidden\n");
1206
        return -1;
1207
    }
1208

    
1209
    v->overlap = get_bits(gb, 1); //common
1210

    
1211
    v->s.resync_marker = get_bits(gb, 1);
1212
    v->rangered = get_bits(gb, 1);
1213
    if (v->rangered && v->profile == PROFILE_SIMPLE)
1214
    {
1215
        av_log(avctx, AV_LOG_INFO,
1216
               "RANGERED should be set to 0 in simple profile\n");
1217
    }
1218

    
1219
    v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1220
    v->quantizer_mode = get_bits(gb, 2); //common
1221

    
1222
    v->finterpflag = get_bits(gb, 1); //common
1223
    v->res_rtm_flag = get_bits(gb, 1); //reserved
1224
    if (!v->res_rtm_flag)
1225
    {
1226
//            av_log(avctx, AV_LOG_ERROR,
1227
//                   "0 for reserved RES_RTM_FLAG is forbidden\n");
1228
        av_log(avctx, AV_LOG_ERROR,
1229
               "Old WMV3 version detected, only I-frames will be decoded\n");
1230
        //return -1;
1231
    }
1232
    av_log(avctx, AV_LOG_DEBUG,
1233
               "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1234
               "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1235
               "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1236
               "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1237
               v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1238
               v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1239
               v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1240
               v->dquant, v->quantizer_mode, avctx->max_b_frames
1241
               );
1242
    return 0;
1243
}
1244

    
1245
static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
1246
{
1247
    v->res_rtm_flag = 1;
1248
    v->level = get_bits(gb, 3);
1249
    if(v->level >= 5)
1250
    {
1251
        av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1252
    }
1253
    v->chromaformat = get_bits(gb, 2);
1254
    if (v->chromaformat != 1)
1255
    {
1256
        av_log(v->s.avctx, AV_LOG_ERROR,
1257
               "Only 4:2:0 chroma format supported\n");
1258
        return -1;
1259
    }
1260

    
1261
    // (fps-2)/4 (->30)
1262
    v->frmrtq_postproc = get_bits(gb, 3); //common
1263
    // (bitrate-32kbps)/64kbps
1264
    v->bitrtq_postproc = get_bits(gb, 5); //common
1265
    v->postprocflag = get_bits(gb, 1); //common
1266

    
1267
    v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
1268
    v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
1269
    v->broadcast = get_bits1(gb);
1270
    v->interlace = get_bits1(gb);
1271
    if(v->interlace){
1272
        av_log(v->s.avctx, AV_LOG_ERROR, "Interlaced mode not supported (yet)\n");
1273
        return -1;
1274
    }
1275
    v->tfcntrflag = get_bits1(gb);
1276
    v->finterpflag = get_bits1(gb);
1277
    get_bits1(gb); // reserved
1278

    
1279
    av_log(v->s.avctx, AV_LOG_DEBUG,
1280
               "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1281
               "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
1282
               "TFCTRflag=%i, FINTERPflag=%i\n",
1283
               v->level, v->frmrtq_postproc, v->bitrtq_postproc,
1284
               v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
1285
               v->tfcntrflag, v->finterpflag
1286
               );
1287

    
1288
    v->psf = get_bits1(gb);
1289
    if(v->psf) { //PsF, 6.1.13
1290
        av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
1291
        return -1;
1292
    }
1293
    if(get_bits1(gb)) { //Display Info - decoding is not affected by it
1294
        int w, h, ar = 0;
1295
        av_log(v->s.avctx, AV_LOG_INFO, "Display extended info:\n");
1296
        w = get_bits(gb, 14) + 1;
1297
        h = get_bits(gb, 14) + 1;
1298
        av_log(v->s.avctx, AV_LOG_INFO, "Display dimensions: %ix%i\n", w, h);
1299
        //TODO: store aspect ratio in AVCodecContext
1300
        if(get_bits1(gb))
1301
            ar = get_bits(gb, 4);
1302
        if(ar == 15) {
1303
            w = get_bits(gb, 8);
1304
            h = get_bits(gb, 8);
1305
        }
1306

    
1307
        if(get_bits1(gb)){ //framerate stuff
1308
            if(get_bits1(gb)) {
1309
                get_bits(gb, 16);
1310
            } else {
1311
                get_bits(gb, 8);
1312
                get_bits(gb, 4);
1313
            }
1314
        }
1315

    
1316
        if(get_bits1(gb)){
1317
            v->color_prim = get_bits(gb, 8);
1318
            v->transfer_char = get_bits(gb, 8);
1319
            v->matrix_coef = get_bits(gb, 8);
1320
        }
1321
    }
1322

    
1323
    v->hrd_param_flag = get_bits1(gb);
1324
    if(v->hrd_param_flag) {
1325
        int i;
1326
        v->hrd_num_leaky_buckets = get_bits(gb, 5);
1327
        get_bits(gb, 4); //bitrate exponent
1328
        get_bits(gb, 4); //buffer size exponent
1329
        for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1330
            get_bits(gb, 16); //hrd_rate[n]
1331
            get_bits(gb, 16); //hrd_buffer[n]
1332
        }
1333
    }
1334
    return 0;
1335
}
1336

    
1337
static int decode_entry_point(AVCodecContext *avctx, GetBitContext *gb)
1338
{
1339
    VC1Context *v = avctx->priv_data;
1340
    int i, blink, refdist;
1341

    
1342
    av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
1343
    blink = get_bits1(gb); // broken link
1344
    avctx->max_b_frames = 1 - get_bits1(gb); // 'closed entry' also signalize possible B-frames
1345
    v->panscanflag = get_bits1(gb);
1346
    refdist = get_bits1(gb); // refdist flag
1347
    v->s.loop_filter = get_bits1(gb);
1348
    v->fastuvmc = get_bits1(gb);
1349
    v->extended_mv = get_bits1(gb);
1350
    v->dquant = get_bits(gb, 2);
1351
    v->vstransform = get_bits1(gb);
1352
    v->overlap = get_bits1(gb);
1353
    v->quantizer_mode = get_bits(gb, 2);
1354

    
1355
    if(v->hrd_param_flag){
1356
        for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1357
            get_bits(gb, 8); //hrd_full[n]
1358
        }
1359
    }
1360

    
1361
    if(get_bits1(gb)){
1362
        avctx->coded_width = (get_bits(gb, 12)+1)<<1;
1363
        avctx->coded_height = (get_bits(gb, 12)+1)<<1;
1364
    }
1365
    if(v->extended_mv)
1366
        v->extended_dmv = get_bits1(gb);
1367
    if(get_bits1(gb)) {
1368
        av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
1369
        skip_bits(gb, 3); // Y range, ignored for now
1370
    }
1371
    if(get_bits1(gb)) {
1372
        av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
1373
        skip_bits(gb, 3); // UV range, ignored for now
1374
    }
1375

    
1376
    av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
1377
        "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1378
        "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1379
        "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1380
        blink, 1 - avctx->max_b_frames, v->panscanflag, refdist, v->s.loop_filter,
1381
        v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
1382

    
1383
    return 0;
1384
}
1385

    
1386
static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1387
{
1388
    int pqindex, lowquant, status;
1389

    
1390
    if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1391
    skip_bits(gb, 2); //framecnt unused
1392
    v->rangeredfrm = 0;
1393
    if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1394
    v->s.pict_type = get_bits(gb, 1);
1395
    if (v->s.avctx->max_b_frames) {
1396
        if (!v->s.pict_type) {
1397
            if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1398
            else v->s.pict_type = B_TYPE;
1399
        } else v->s.pict_type = P_TYPE;
1400
    } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1401

    
1402
    v->bi_type = 0;
1403
    if(v->s.pict_type == B_TYPE) {
1404
        v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1405
        v->bfraction = vc1_bfraction_lut[v->bfraction];
1406
        if(v->bfraction == 0) {
1407
            v->s.pict_type = BI_TYPE;
1408
        }
1409
    }
1410
    if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1411
        get_bits(gb, 7); // skip buffer fullness
1412

    
1413
    /* calculate RND */
1414
    if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1415
        v->rnd = 1;
1416
    if(v->s.pict_type == P_TYPE)
1417
        v->rnd ^= 1;
1418

    
1419
    /* Quantizer stuff */
1420
    pqindex = get_bits(gb, 5);
1421
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1422
        v->pq = pquant_table[0][pqindex];
1423
    else
1424
        v->pq = pquant_table[1][pqindex];
1425

    
1426
    v->pquantizer = 1;
1427
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1428
        v->pquantizer = pqindex < 9;
1429
    if (v->quantizer_mode == QUANT_NON_UNIFORM)
1430
        v->pquantizer = 0;
1431
    v->pqindex = pqindex;
1432
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1433
    else v->halfpq = 0;
1434
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1435
        v->pquantizer = get_bits(gb, 1);
1436
    v->dquantfrm = 0;
1437
    if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1438
    v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1439
    v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1440
    v->range_x = 1 << (v->k_x - 1);
1441
    v->range_y = 1 << (v->k_y - 1);
1442
    if (v->profile == PROFILE_ADVANCED)
1443
    {
1444
        if (v->postprocflag) v->postproc = get_bits(gb, 1);
1445
    }
1446
    else
1447
        if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1448

    
1449
//av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1450
//        (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1451

    
1452
    if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
1453

    
1454
    switch(v->s.pict_type) {
1455
    case P_TYPE:
1456
        if (v->pq < 5) v->tt_index = 0;
1457
        else if(v->pq < 13) v->tt_index = 1;
1458
        else v->tt_index = 2;
1459

    
1460
        lowquant = (v->pq > 12) ? 0 : 1;
1461
        v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1462
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1463
        {
1464
            int scale, shift, i;
1465
            v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1466
            v->lumscale = get_bits(gb, 6);
1467
            v->lumshift = get_bits(gb, 6);
1468
            v->use_ic = 1;
1469
            /* fill lookup tables for intensity compensation */
1470
            if(!v->lumscale) {
1471
                scale = -64;
1472
                shift = (255 - v->lumshift * 2) << 6;
1473
                if(v->lumshift > 31)
1474
                    shift += 128 << 6;
1475
            } else {
1476
                scale = v->lumscale + 32;
1477
                if(v->lumshift > 31)
1478
                    shift = (v->lumshift - 64) << 6;
1479
                else
1480
                    shift = v->lumshift << 6;
1481
            }
1482
            for(i = 0; i < 256; i++) {
1483
                v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1484
                v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1485
            }
1486
        }
1487
        if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1488
            v->s.quarter_sample = 0;
1489
        else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1490
            if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1491
                v->s.quarter_sample = 0;
1492
            else
1493
                v->s.quarter_sample = 1;
1494
        } else
1495
            v->s.quarter_sample = 1;
1496
        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));
1497

    
1498
        if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1499
                 v->mv_mode2 == MV_PMODE_MIXED_MV)
1500
                || v->mv_mode == MV_PMODE_MIXED_MV)
1501
        {
1502
            status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1503
            if (status < 0) return -1;
1504
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1505
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1506
        } else {
1507
            v->mv_type_is_raw = 0;
1508
            memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1509
        }
1510
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1511
        if (status < 0) return -1;
1512
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1513
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1514

    
1515
        /* Hopefully this is correct for P frames */
1516
        v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1517
        v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1518

    
1519
        if (v->dquant)
1520
        {
1521
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1522
            vop_dquant_decoding(v);
1523
        }
1524

    
1525
        v->ttfrm = 0; //FIXME Is that so ?
1526
        if (v->vstransform)
1527
        {
1528
            v->ttmbf = get_bits(gb, 1);
1529
            if (v->ttmbf)
1530
            {
1531
                v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1532
            }
1533
        } else {
1534
            v->ttmbf = 1;
1535
            v->ttfrm = TT_8X8;
1536
        }
1537
        break;
1538
    case B_TYPE:
1539
        if (v->pq < 5) v->tt_index = 0;
1540
        else if(v->pq < 13) v->tt_index = 1;
1541
        else v->tt_index = 2;
1542

    
1543
        lowquant = (v->pq > 12) ? 0 : 1;
1544
        v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1545
        v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1546
        v->s.mspel = v->s.quarter_sample;
1547

    
1548
        status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1549
        if (status < 0) return -1;
1550
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1551
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1552
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1553
        if (status < 0) return -1;
1554
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1555
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1556

    
1557
        v->s.mv_table_index = get_bits(gb, 2);
1558
        v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1559

    
1560
        if (v->dquant)
1561
        {
1562
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1563
            vop_dquant_decoding(v);
1564
        }
1565

    
1566
        v->ttfrm = 0;
1567
        if (v->vstransform)
1568
        {
1569
            v->ttmbf = get_bits(gb, 1);
1570
            if (v->ttmbf)
1571
            {
1572
                v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1573
            }
1574
        } else {
1575
            v->ttmbf = 1;
1576
            v->ttfrm = TT_8X8;
1577
        }
1578
        break;
1579
    }
1580

    
1581
    /* AC Syntax */
1582
    v->c_ac_table_index = decode012(gb);
1583
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1584
    {
1585
        v->y_ac_table_index = decode012(gb);
1586
    }
1587
    /* DC Syntax */
1588
    v->s.dc_table_index = get_bits(gb, 1);
1589

    
1590
    if(v->s.pict_type == BI_TYPE) {
1591
        v->s.pict_type = B_TYPE;
1592
        v->bi_type = 1;
1593
    }
1594
    return 0;
1595
}
1596

    
1597
static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
1598
{
1599
    int fcm;
1600
    int pqindex, lowquant;
1601
    int status;
1602

    
1603
    v->p_frame_skipped = 0;
1604

    
1605
    if(v->interlace)
1606
        fcm = decode012(gb);
1607
    switch(get_prefix(gb, 0, 4)) {
1608
    case 0:
1609
        v->s.pict_type = P_TYPE;
1610
        break;
1611
    case 1:
1612
        v->s.pict_type = B_TYPE;
1613
        break;
1614
    case 2:
1615
        v->s.pict_type = I_TYPE;
1616
        break;
1617
    case 3:
1618
        v->s.pict_type = BI_TYPE;
1619
        break;
1620
    case 4:
1621
        v->s.pict_type = P_TYPE; // skipped pic
1622
        v->p_frame_skipped = 1;
1623
        return 0;
1624
    }
1625
    if(v->tfcntrflag)
1626
        get_bits(gb, 8);
1627
    if(v->broadcast) {
1628
        if(!v->interlace || v->panscanflag) {
1629
            get_bits(gb, 2);
1630
        } else {
1631
            get_bits1(gb);
1632
            get_bits1(gb);
1633
        }
1634
    }
1635
    if(v->panscanflag) {
1636
        //...
1637
    }
1638
    v->rnd = get_bits1(gb);
1639
    if(v->interlace)
1640
        v->uvsamp = get_bits1(gb);
1641
    if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1642
    if(v->s.pict_type == B_TYPE) {
1643
        v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1644
        v->bfraction = vc1_bfraction_lut[v->bfraction];
1645
        if(v->bfraction == 0) {
1646
            v->s.pict_type = BI_TYPE; /* XXX: should not happen here */
1647
        }
1648
    }
1649
    pqindex = get_bits(gb, 5);
1650
    v->pqindex = pqindex;
1651
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1652
        v->pq = pquant_table[0][pqindex];
1653
    else
1654
        v->pq = pquant_table[1][pqindex];
1655

    
1656
    v->pquantizer = 1;
1657
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1658
        v->pquantizer = pqindex < 9;
1659
    if (v->quantizer_mode == QUANT_NON_UNIFORM)
1660
        v->pquantizer = 0;
1661
    v->pqindex = pqindex;
1662
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1663
    else v->halfpq = 0;
1664
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1665
        v->pquantizer = get_bits(gb, 1);
1666

    
1667
    switch(v->s.pict_type) {
1668
    case I_TYPE:
1669
    case BI_TYPE:
1670
        status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1671
        if (status < 0) return -1;
1672
        av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1673
                "Imode: %i, Invert: %i\n", status>>1, status&1);
1674
        v->condover = CONDOVER_NONE;
1675
        if(v->overlap && v->pq <= 8) {
1676
            v->condover = decode012(gb);
1677
            if(v->condover == CONDOVER_SELECT) {
1678
                status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1679
                if (status < 0) return -1;
1680
                av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1681
                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1682
            }
1683
        }
1684
        break;
1685
    case P_TYPE:
1686
        if(v->postprocflag)
1687
            v->postproc = get_bits1(gb);
1688
        if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1689
        else v->mvrange = 0;
1690
        v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1691
        v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1692
        v->range_x = 1 << (v->k_x - 1);
1693
        v->range_y = 1 << (v->k_y - 1);
1694

    
1695
        if (v->pq < 5) v->tt_index = 0;
1696
        else if(v->pq < 13) v->tt_index = 1;
1697
        else v->tt_index = 2;
1698

    
1699
        lowquant = (v->pq > 12) ? 0 : 1;
1700
        v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1701
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1702
        {
1703
            int scale, shift, i;
1704
            v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1705
            v->lumscale = get_bits(gb, 6);
1706
            v->lumshift = get_bits(gb, 6);
1707
            /* fill lookup tables for intensity compensation */
1708
            if(!v->lumscale) {
1709
                scale = -64;
1710
                shift = (255 - v->lumshift * 2) << 6;
1711
                if(v->lumshift > 31)
1712
                    shift += 128 << 6;
1713
            } else {
1714
                scale = v->lumscale + 32;
1715
                if(v->lumshift > 31)
1716
                    shift = (v->lumshift - 64) << 6;
1717
                else
1718
                    shift = v->lumshift << 6;
1719
            }
1720
            for(i = 0; i < 256; i++) {
1721
                v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1722
                v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1723
            }
1724
        }
1725
        if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1726
            v->s.quarter_sample = 0;
1727
        else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1728
            if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1729
                v->s.quarter_sample = 0;
1730
            else
1731
                v->s.quarter_sample = 1;
1732
        } else
1733
            v->s.quarter_sample = 1;
1734
        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));
1735

    
1736
        if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1737
                 v->mv_mode2 == MV_PMODE_MIXED_MV)
1738
                || v->mv_mode == MV_PMODE_MIXED_MV)
1739
        {
1740
            status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1741
            if (status < 0) return -1;
1742
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1743
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1744
        } else {
1745
            v->mv_type_is_raw = 0;
1746
            memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1747
        }
1748
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1749
        if (status < 0) return -1;
1750
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1751
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1752

    
1753
        /* Hopefully this is correct for P frames */
1754
        v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1755
        v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1756
        if (v->dquant)
1757
        {
1758
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1759
            vop_dquant_decoding(v);
1760
        }
1761

    
1762
        v->ttfrm = 0; //FIXME Is that so ?
1763
        if (v->vstransform)
1764
        {
1765
            v->ttmbf = get_bits(gb, 1);
1766
            if (v->ttmbf)
1767
            {
1768
                v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1769
            }
1770
        } else {
1771
            v->ttmbf = 1;
1772
            v->ttfrm = TT_8X8;
1773
        }
1774
        break;
1775
    case B_TYPE:
1776
        if(v->postprocflag)
1777
            v->postproc = get_bits1(gb);
1778
        if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1779
        else v->mvrange = 0;
1780
        v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1781
        v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1782
        v->range_x = 1 << (v->k_x - 1);
1783
        v->range_y = 1 << (v->k_y - 1);
1784

    
1785
        if (v->pq < 5) v->tt_index = 0;
1786
        else if(v->pq < 13) v->tt_index = 1;
1787
        else v->tt_index = 2;
1788

    
1789
        lowquant = (v->pq > 12) ? 0 : 1;
1790
        v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1791
        v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1792
        v->s.mspel = v->s.quarter_sample;
1793

    
1794
        status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1795
        if (status < 0) return -1;
1796
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1797
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1798
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1799
        if (status < 0) return -1;
1800
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1801
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1802

    
1803
        v->s.mv_table_index = get_bits(gb, 2);
1804
        v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1805

    
1806
        if (v->dquant)
1807
        {
1808
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1809
            vop_dquant_decoding(v);
1810
        }
1811

    
1812
        v->ttfrm = 0;
1813
        if (v->vstransform)
1814
        {
1815
            v->ttmbf = get_bits(gb, 1);
1816
            if (v->ttmbf)
1817
            {
1818
                v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1819
            }
1820
        } else {
1821
            v->ttmbf = 1;
1822
            v->ttfrm = TT_8X8;
1823
        }
1824
        break;
1825
    }
1826

    
1827
    /* AC Syntax */
1828
    v->c_ac_table_index = decode012(gb);
1829
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1830
    {
1831
        v->y_ac_table_index = decode012(gb);
1832
    }
1833
    /* DC Syntax */
1834
    v->s.dc_table_index = get_bits(gb, 1);
1835
    if (v->s.pict_type == I_TYPE && v->dquant) {
1836
        av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1837
        vop_dquant_decoding(v);
1838
    }
1839

    
1840
    v->bi_type = 0;
1841
    if(v->s.pict_type == BI_TYPE) {
1842
        v->s.pict_type = B_TYPE;
1843
        v->bi_type = 1;
1844
    }
1845
    return 0;
1846
}
1847

    
1848
/***********************************************************************/
1849
/**
1850
 * @defgroup block VC-1 Block-level functions
1851
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1852
 * @{
1853
 */
1854

    
1855
/**
1856
 * @def GET_MQUANT
1857
 * @brief Get macroblock-level quantizer scale
1858
 */
1859
#define GET_MQUANT()                                           \
1860
  if (v->dquantfrm)                                            \
1861
  {                                                            \
1862
    int edges = 0;                                             \
1863
    if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1864
    {                                                          \
1865
      if (v->dqbilevel)                                        \
1866
      {                                                        \
1867
        mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
1868
      }                                                        \
1869
      else                                                     \
1870
      {                                                        \
1871
        mqdiff = get_bits(gb, 3);                              \
1872
        if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1873
        else mquant = get_bits(gb, 5);                         \
1874
      }                                                        \
1875
    }                                                          \
1876
    if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
1877
        edges = 1 << v->dqsbedge;                              \
1878
    else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1879
        edges = (3 << v->dqsbedge) % 15;                       \
1880
    else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1881
        edges = 15;                                            \
1882
    if((edges&1) && !s->mb_x)                                  \
1883
        mquant = v->altpq;                                     \
1884
    if((edges&2) && s->first_slice_line)                       \
1885
        mquant = v->altpq;                                     \
1886
    if((edges&4) && s->mb_x == (s->mb_width - 1))              \
1887
        mquant = v->altpq;                                     \
1888
    if((edges&8) && s->mb_y == (s->mb_height - 1))             \
1889
        mquant = v->altpq;                                     \
1890
  }
1891

    
1892
/**
1893
 * @def GET_MVDATA(_dmv_x, _dmv_y)
1894
 * @brief Get MV differentials
1895
 * @see MVDATA decoding from 8.3.5.2, p(1)20
1896
 * @param _dmv_x Horizontal differential for decoded MV
1897
 * @param _dmv_y Vertical differential for decoded MV
1898
 */
1899
#define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1900
  index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1901
                       VC1_MV_DIFF_VLC_BITS, 2);                    \
1902
  if (index > 36)                                                   \
1903
  {                                                                 \
1904
    mb_has_coeffs = 1;                                              \
1905
    index -= 37;                                                    \
1906
  }                                                                 \
1907
  else mb_has_coeffs = 0;                                           \
1908
  s->mb_intra = 0;                                                  \
1909
  if (!index) { _dmv_x = _dmv_y = 0; }                              \
1910
  else if (index == 35)                                             \
1911
  {                                                                 \
1912
    _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1913
    _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1914
  }                                                                 \
1915
  else if (index == 36)                                             \
1916
  {                                                                 \
1917
    _dmv_x = 0;                                                     \
1918
    _dmv_y = 0;                                                     \
1919
    s->mb_intra = 1;                                                \
1920
  }                                                                 \
1921
  else                                                              \
1922
  {                                                                 \
1923
    index1 = index%6;                                               \
1924
    if (!s->quarter_sample && index1 == 5) val = 1;                 \
1925
    else                                   val = 0;                 \
1926
    if(size_table[index1] - val > 0)                                \
1927
        val = get_bits(gb, size_table[index1] - val);               \
1928
    else                                   val = 0;                 \
1929
    sign = 0 - (val&1);                                             \
1930
    _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1931
                                                                    \
1932
    index1 = index/6;                                               \
1933
    if (!s->quarter_sample && index1 == 5) val = 1;                 \
1934
    else                                   val = 0;                 \
1935
    if(size_table[index1] - val > 0)                                \
1936
        val = get_bits(gb, size_table[index1] - val);               \
1937
    else                                   val = 0;                 \
1938
    sign = 0 - (val&1);                                             \
1939
    _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1940
  }
1941

    
1942
/** Predict and set motion vector
1943
 */
1944
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)
1945
{
1946
    int xy, wrap, off = 0;
1947
    int16_t *A, *B, *C;
1948
    int px, py;
1949
    int sum;
1950

    
1951
    /* scale MV difference to be quad-pel */
1952
    dmv_x <<= 1 - s->quarter_sample;
1953
    dmv_y <<= 1 - s->quarter_sample;
1954

    
1955
    wrap = s->b8_stride;
1956
    xy = s->block_index[n];
1957

    
1958
    if(s->mb_intra){
1959
        s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1960
        s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1961
        if(mv1) { /* duplicate motion data for 1-MV block */
1962
            s->current_picture.motion_val[0][xy + 1][0] = 0;
1963
            s->current_picture.motion_val[0][xy + 1][1] = 0;
1964
            s->current_picture.motion_val[0][xy + wrap][0] = 0;
1965
            s->current_picture.motion_val[0][xy + wrap][1] = 0;
1966
            s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1967
            s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1968
        }
1969
        return;
1970
    }
1971

    
1972
    C = s->current_picture.motion_val[0][xy - 1];
1973
    A = s->current_picture.motion_val[0][xy - wrap];
1974
    if(mv1)
1975
        off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1976
    else {
1977
        //in 4-MV mode different blocks have different B predictor position
1978
        switch(n){
1979
        case 0:
1980
            off = (s->mb_x > 0) ? -1 : 1;
1981
            break;
1982
        case 1:
1983
            off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1984
            break;
1985
        case 2:
1986
            off = 1;
1987
            break;
1988
        case 3:
1989
            off = -1;
1990
        }
1991
    }
1992
    B = s->current_picture.motion_val[0][xy - wrap + off];
1993

    
1994
    if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
1995
        if(s->mb_width == 1) {
1996
            px = A[0];
1997
            py = A[1];
1998
        } else {
1999
            px = mid_pred(A[0], B[0], C[0]);
2000
            py = mid_pred(A[1], B[1], C[1]);
2001
        }
2002
    } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
2003
        px = C[0];
2004
        py = C[1];
2005
    } else {
2006
        px = py = 0;
2007
    }
2008
    /* Pullback MV as specified in 8.3.5.3.4 */
2009
    {
2010
        int qx, qy, X, Y;
2011
        qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
2012
        qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
2013
        X = (s->mb_width << 6) - 4;
2014
        Y = (s->mb_height << 6) - 4;
2015
        if(mv1) {
2016
            if(qx + px < -60) px = -60 - qx;
2017
            if(qy + py < -60) py = -60 - qy;
2018
        } else {
2019
            if(qx + px < -28) px = -28 - qx;
2020
            if(qy + py < -28) py = -28 - qy;
2021
        }
2022
        if(qx + px > X) px = X - qx;
2023
        if(qy + py > Y) py = Y - qy;
2024
    }
2025
    /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2026
    if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
2027
        if(is_intra[xy - wrap])
2028
            sum = FFABS(px) + FFABS(py);
2029
        else
2030
            sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2031
        if(sum > 32) {
2032
            if(get_bits1(&s->gb)) {
2033
                px = A[0];
2034
                py = A[1];
2035
            } else {
2036
                px = C[0];
2037
                py = C[1];
2038
            }
2039
        } else {
2040
            if(is_intra[xy - 1])
2041
                sum = FFABS(px) + FFABS(py);
2042
            else
2043
                sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2044
            if(sum > 32) {
2045
                if(get_bits1(&s->gb)) {
2046
                    px = A[0];
2047
                    py = A[1];
2048
                } else {
2049
                    px = C[0];
2050
                    py = C[1];
2051
                }
2052
            }
2053
        }
2054
    }
2055
    /* store MV using signed modulus of MV range defined in 4.11 */
2056
    s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
2057
    s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
2058
    if(mv1) { /* duplicate motion data for 1-MV block */
2059
        s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
2060
        s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
2061
        s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
2062
        s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
2063
        s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
2064
        s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
2065
    }
2066
}
2067

    
2068
/** Motion compensation for direct or interpolated blocks in B-frames
2069
 */
2070
static void vc1_interp_mc(VC1Context *v)
2071
{
2072
    MpegEncContext *s = &v->s;
2073
    DSPContext *dsp = &v->s.dsp;
2074
    uint8_t *srcY, *srcU, *srcV;
2075
    int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
2076

    
2077
    if(!v->s.next_picture.data[0])return;
2078

    
2079
    mx = s->mv[1][0][0];
2080
    my = s->mv[1][0][1];
2081
    uvmx = (mx + ((mx & 3) == 3)) >> 1;
2082
    uvmy = (my + ((my & 3) == 3)) >> 1;
2083
    if(v->fastuvmc) {
2084
        uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
2085
        uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
2086
    }
2087
    srcY = s->next_picture.data[0];
2088
    srcU = s->next_picture.data[1];
2089
    srcV = s->next_picture.data[2];
2090

    
2091
    src_x = s->mb_x * 16 + (mx >> 2);
2092
    src_y = s->mb_y * 16 + (my >> 2);
2093
    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
2094
    uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
2095

    
2096
    src_x   = clip(  src_x, -16, s->mb_width  * 16);
2097
    src_y   = clip(  src_y, -16, s->mb_height * 16);
2098
    uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
2099
    uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
2100

    
2101
    srcY += src_y * s->linesize + src_x;
2102
    srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
2103
    srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
2104

    
2105
    /* for grayscale we should not try to read from unknown area */
2106
    if(s->flags & CODEC_FLAG_GRAY) {
2107
        srcU = s->edge_emu_buffer + 18 * s->linesize;
2108
        srcV = s->edge_emu_buffer + 18 * s->linesize;
2109
    }
2110

    
2111
    if(v->rangeredfrm
2112
       || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
2113
       || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
2114
        uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
2115

    
2116
        srcY -= s->mspel * (1 + s->linesize);
2117
        ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
2118
                            src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
2119
        srcY = s->edge_emu_buffer;
2120
        ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
2121
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2122
        ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
2123
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2124
        srcU = uvbuf;
2125
        srcV = uvbuf + 16;
2126
        /* if we deal with range reduction we need to scale source blocks */
2127
        if(v->rangeredfrm) {
2128
            int i, j;
2129
            uint8_t *src, *src2;
2130

    
2131
            src = srcY;
2132
            for(j = 0; j < 17 + s->mspel*2; j++) {
2133
                for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
2134
                src += s->linesize;
2135
            }
2136
            src = srcU; src2 = srcV;
2137
            for(j = 0; j < 9; j++) {
2138
                for(i = 0; i < 9; i++) {
2139
                    src[i] = ((src[i] - 128) >> 1) + 128;
2140
                    src2[i] = ((src2[i] - 128) >> 1) + 128;
2141
                }
2142
                src += s->uvlinesize;
2143
                src2 += s->uvlinesize;
2144
            }
2145
        }
2146
        srcY += s->mspel * (1 + s->linesize);
2147
    }
2148

    
2149
    mx >>= 1;
2150
    my >>= 1;
2151
    dxy = ((my & 1) << 1) | (mx & 1);
2152

    
2153
    dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
2154

    
2155
    if(s->flags & CODEC_FLAG_GRAY) return;
2156
    /* Chroma MC always uses qpel blilinear */
2157
    uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
2158
    uvmx = (uvmx&3)<<1;
2159
    uvmy = (uvmy&3)<<1;
2160
    dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
2161
    dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
2162
}
2163

    
2164
static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2165
{
2166
    int n = bfrac;
2167

    
2168
#if B_FRACTION_DEN==256
2169
    if(inv)
2170
        n -= 256;
2171
    if(!qs)
2172
        return 2 * ((value * n + 255) >> 9);
2173
    return (value * n + 128) >> 8;
2174
#else
2175
    if(inv)
2176
        n -= B_FRACTION_DEN;
2177
    if(!qs)
2178
        return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2179
    return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2180
#endif
2181
}
2182

    
2183
/** Reconstruct motion vector for B-frame and do motion compensation
2184
 */
2185
static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
2186
{
2187
    if(v->use_ic) {
2188
        v->mv_mode2 = v->mv_mode;
2189
        v->mv_mode = MV_PMODE_INTENSITY_COMP;
2190
    }
2191
    if(direct) {
2192
        vc1_mc_1mv(v, 0);
2193
        vc1_interp_mc(v);
2194
        if(v->use_ic) v->mv_mode = v->mv_mode2;
2195
        return;
2196
    }
2197
    if(mode == BMV_TYPE_INTERPOLATED) {
2198
        vc1_mc_1mv(v, 0);
2199
        vc1_interp_mc(v);
2200
        if(v->use_ic) v->mv_mode = v->mv_mode2;
2201
        return;
2202
    }
2203

    
2204
    if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
2205
    vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2206
    if(v->use_ic) v->mv_mode = v->mv_mode2;
2207
}
2208

    
2209
static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
2210
{
2211
    MpegEncContext *s = &v->s;
2212
    int xy, wrap, off = 0;
2213
    int16_t *A, *B, *C;
2214
    int px, py;
2215
    int sum;
2216
    int r_x, r_y;
2217
    const uint8_t *is_intra = v->mb_type[0];
2218

    
2219
    r_x = v->range_x;
2220
    r_y = v->range_y;
2221
    /* scale MV difference to be quad-pel */
2222
    dmv_x[0] <<= 1 - s->quarter_sample;
2223
    dmv_y[0] <<= 1 - s->quarter_sample;
2224
    dmv_x[1] <<= 1 - s->quarter_sample;
2225
    dmv_y[1] <<= 1 - s->quarter_sample;
2226

    
2227
    wrap = s->b8_stride;
2228
    xy = s->block_index[0];
2229

    
2230
    if(s->mb_intra) {
2231
        s->current_picture.motion_val[0][xy][0] =
2232
        s->current_picture.motion_val[0][xy][1] =
2233
        s->current_picture.motion_val[1][xy][0] =
2234
        s->current_picture.motion_val[1][xy][1] = 0;
2235
        return;
2236
    }
2237
    s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2238
    s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2239
    s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2240
    s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2241
    if(direct) {
2242
        s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2243
        s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2244
        s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2245
        s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2246
        return;
2247
    }
2248

    
2249
    if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2250
        C = s->current_picture.motion_val[0][xy - 2];
2251
        A = s->current_picture.motion_val[0][xy - wrap*2];
2252
        off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2253
        B = s->current_picture.motion_val[0][xy - wrap*2 + off];
2254

    
2255
        if(!s->first_slice_line) { // predictor A is not out of bounds
2256
            if(s->mb_width == 1) {
2257
                px = A[0];
2258
                py = A[1];
2259
            } else {
2260
                px = mid_pred(A[0], B[0], C[0]);
2261
                py = mid_pred(A[1], B[1], C[1]);
2262
            }
2263
        } else if(s->mb_x) { // predictor C is not out of bounds
2264
            px = C[0];
2265
            py = C[1];
2266
        } else {
2267
            px = py = 0;
2268
        }
2269
        /* Pullback MV as specified in 8.3.5.3.4 */
2270
        {
2271
            int qx, qy, X, Y;
2272
            if(v->profile < PROFILE_ADVANCED) {
2273
                qx = (s->mb_x << 5);
2274
                qy = (s->mb_y << 5);
2275
                X = (s->mb_width << 5) - 4;
2276
                Y = (s->mb_height << 5) - 4;
2277
                if(qx + px < -28) px = -28 - qx;
2278
                if(qy + py < -28) py = -28 - qy;
2279
                if(qx + px > X) px = X - qx;
2280
                if(qy + py > Y) py = Y - qy;
2281
            } else {
2282
                qx = (s->mb_x << 6);
2283
                qy = (s->mb_y << 6);
2284
                X = (s->mb_width << 6) - 4;
2285
                Y = (s->mb_height << 6) - 4;
2286
                if(qx + px < -60) px = -60 - qx;
2287
                if(qy + py < -60) py = -60 - qy;
2288
                if(qx + px > X) px = X - qx;
2289
                if(qy + py > Y) py = Y - qy;
2290
            }
2291
        }
2292
        /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2293
        if(0 && !s->first_slice_line && s->mb_x) {
2294
            if(is_intra[xy - wrap])
2295
                sum = FFABS(px) + FFABS(py);
2296
            else
2297
                sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2298
            if(sum > 32) {
2299
                if(get_bits1(&s->gb)) {
2300
                    px = A[0];
2301
                    py = A[1];
2302
                } else {
2303
                    px = C[0];
2304
                    py = C[1];
2305
                }
2306
            } else {
2307
                if(is_intra[xy - 2])
2308
                    sum = FFABS(px) + FFABS(py);
2309
                else
2310
                    sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2311
                if(sum > 32) {
2312
                    if(get_bits1(&s->gb)) {
2313
                        px = A[0];
2314
                        py = A[1];
2315
                    } else {
2316
                        px = C[0];
2317
                        py = C[1];
2318
                    }
2319
                }
2320
            }
2321
        }
2322
        /* store MV using signed modulus of MV range defined in 4.11 */
2323
        s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2324
        s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2325
    }
2326
    if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2327
        C = s->current_picture.motion_val[1][xy - 2];
2328
        A = s->current_picture.motion_val[1][xy - wrap*2];
2329
        off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2330
        B = s->current_picture.motion_val[1][xy - wrap*2 + off];
2331

    
2332
        if(!s->first_slice_line) { // predictor A is not out of bounds
2333
            if(s->mb_width == 1) {
2334
                px = A[0];
2335
                py = A[1];
2336
            } else {
2337
                px = mid_pred(A[0], B[0], C[0]);
2338
                py = mid_pred(A[1], B[1], C[1]);
2339
            }
2340
        } else if(s->mb_x) { // predictor C is not out of bounds
2341
            px = C[0];
2342
            py = C[1];
2343
        } else {
2344
            px = py = 0;
2345
        }
2346
        /* Pullback MV as specified in 8.3.5.3.4 */
2347
        {
2348
            int qx, qy, X, Y;
2349
            if(v->profile < PROFILE_ADVANCED) {
2350
                qx = (s->mb_x << 5);
2351
                qy = (s->mb_y << 5);
2352
                X = (s->mb_width << 5) - 4;
2353
                Y = (s->mb_height << 5) - 4;
2354
                if(qx + px < -28) px = -28 - qx;
2355
                if(qy + py < -28) py = -28 - qy;
2356
                if(qx + px > X) px = X - qx;
2357
                if(qy + py > Y) py = Y - qy;
2358
            } else {
2359
                qx = (s->mb_x << 6);
2360
                qy = (s->mb_y << 6);
2361
                X = (s->mb_width << 6) - 4;
2362
                Y = (s->mb_height << 6) - 4;
2363
                if(qx + px < -60) px = -60 - qx;
2364
                if(qy + py < -60) py = -60 - qy;
2365
                if(qx + px > X) px = X - qx;
2366
                if(qy + py > Y) py = Y - qy;
2367
            }
2368
        }
2369
        /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2370
        if(0 && !s->first_slice_line && s->mb_x) {
2371
            if(is_intra[xy - wrap])
2372
                sum = FFABS(px) + FFABS(py);
2373
            else
2374
                sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2375
            if(sum > 32) {
2376
                if(get_bits1(&s->gb)) {
2377
                    px = A[0];
2378
                    py = A[1];
2379
                } else {
2380
                    px = C[0];
2381
                    py = C[1];
2382
                }
2383
            } else {
2384
                if(is_intra[xy - 2])
2385
                    sum = FFABS(px) + FFABS(py);
2386
                else
2387
                    sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2388
                if(sum > 32) {
2389
                    if(get_bits1(&s->gb)) {
2390
                        px = A[0];
2391
                        py = A[1];
2392
                    } else {
2393
                        px = C[0];
2394
                        py = C[1];
2395
                    }
2396
                }
2397
            }
2398
        }
2399
        /* store MV using signed modulus of MV range defined in 4.11 */
2400

    
2401
        s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2402
        s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2403
    }
2404
    s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2405
    s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2406
    s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2407
    s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2408
}
2409

    
2410
/** Get predicted DC value for I-frames only
2411
 * prediction dir: left=0, top=1
2412
 * @param s MpegEncContext
2413
 * @param[in] n block index in the current MB
2414
 * @param dc_val_ptr Pointer to DC predictor
2415
 * @param dir_ptr Prediction direction for use in AC prediction
2416
 */
2417
static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2418
                              int16_t **dc_val_ptr, int *dir_ptr)
2419
{
2420
    int a, b, c, wrap, pred, scale;
2421
    int16_t *dc_val;
2422
    static const uint16_t dcpred[32] = {
2423
    -1, 1024,  512,  341,  256,  205,  171,  146,  128,
2424
         114,  102,   93,   85,   79,   73,   68,   64,
2425
          60,   57,   54,   51,   49,   47,   45,   43,
2426
          41,   39,   38,   37,   35,   34,   33
2427
    };
2428

    
2429
    /* find prediction - wmv3_dc_scale always used here in fact */
2430
    if (n < 4)     scale = s->y_dc_scale;
2431
    else           scale = s->c_dc_scale;
2432

    
2433
    wrap = s->block_wrap[n];
2434
    dc_val= s->dc_val[0] + s->block_index[n];
2435

    
2436
    /* B A
2437
     * C X
2438
     */
2439
    c = dc_val[ - 1];
2440
    b = dc_val[ - 1 - wrap];
2441
    a = dc_val[ - wrap];
2442

    
2443
    if (pq < 9 || !overlap)
2444
    {
2445
        /* Set outer values */
2446
        if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
2447
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
2448
    }
2449
    else
2450
    {
2451
        /* Set outer values */
2452
        if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
2453
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
2454
    }
2455

    
2456
    if (abs(a - b) <= abs(b - c)) {
2457
        pred = c;
2458
        *dir_ptr = 1;//left
2459
    } else {
2460
        pred = a;
2461
        *dir_ptr = 0;//top
2462
    }
2463

    
2464
    /* update predictor */
2465
    *dc_val_ptr = &dc_val[0];
2466
    return pred;
2467
}
2468

    
2469

    
2470
/** Get predicted DC value
2471
 * prediction dir: left=0, top=1
2472
 * @param s MpegEncContext
2473
 * @param[in] n block index in the current MB
2474
 * @param dc_val_ptr Pointer to DC predictor
2475
 * @param dir_ptr Prediction direction for use in AC prediction
2476
 */
2477
static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2478
                              int a_avail, int c_avail,
2479
                              int16_t **dc_val_ptr, int *dir_ptr)
2480
{
2481
    int a, b, c, wrap, pred, scale;
2482
    int16_t *dc_val;
2483
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2484
    int q1, q2 = 0;
2485

    
2486
    /* find prediction - wmv3_dc_scale always used here in fact */
2487
    if (n < 4)     scale = s->y_dc_scale;
2488
    else           scale = s->c_dc_scale;
2489

    
2490
    wrap = s->block_wrap[n];
2491
    dc_val= s->dc_val[0] + s->block_index[n];
2492

    
2493
    /* B A
2494
     * C X
2495
     */
2496
    c = dc_val[ - 1];
2497
    b = dc_val[ - 1 - wrap];
2498
    a = dc_val[ - wrap];
2499
    /* scale predictors if needed */
2500
    q1 = s->current_picture.qscale_table[mb_pos];
2501
    if(c_avail && (n!= 1 && n!=3)) {
2502
        q2 = s->current_picture.qscale_table[mb_pos - 1];
2503
        if(q2 && q2 != q1)
2504
            c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2505
    }
2506
    if(a_avail && (n!= 2 && n!=3)) {
2507
        q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2508
        if(q2 && q2 != q1)
2509
            a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2510
    }
2511
    if(a_avail && c_avail && (n!=3)) {
2512
        int off = mb_pos;
2513
        if(n != 1) off--;
2514
        if(n != 2) off -= s->mb_stride;
2515
        q2 = s->current_picture.qscale_table[off];
2516
        if(q2 && q2 != q1)
2517
            b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2518
    }
2519

    
2520
    if(a_avail && c_avail) {
2521
        if(abs(a - b) <= abs(b - c)) {
2522
            pred = c;
2523
            *dir_ptr = 1;//left
2524
        } else {
2525
            pred = a;
2526
            *dir_ptr = 0;//top
2527
        }
2528
    } else if(a_avail) {
2529
        pred = a;
2530
        *dir_ptr = 0;//top
2531
    } else if(c_avail) {
2532
        pred = c;
2533
        *dir_ptr = 1;//left
2534
    } else {
2535
        pred = 0;
2536
        *dir_ptr = 1;//left
2537
    }
2538

    
2539
    /* update predictor */
2540
    *dc_val_ptr = &dc_val[0];
2541
    return pred;
2542
}
2543

    
2544

    
2545
/**
2546
 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2547
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2548
 * @{
2549
 */
2550

    
2551
static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
2552
{
2553
    int xy, wrap, pred, a, b, c;
2554

    
2555
    xy = s->block_index[n];
2556
    wrap = s->b8_stride;
2557

    
2558
    /* B C
2559
     * A X
2560
     */
2561
    a = s->coded_block[xy - 1       ];
2562
    b = s->coded_block[xy - 1 - wrap];
2563
    c = s->coded_block[xy     - wrap];
2564

    
2565
    if (b == c) {
2566
        pred = a;
2567
    } else {
2568
        pred = c;
2569
    }
2570

    
2571
    /* store value */
2572
    *coded_block_ptr = &s->coded_block[xy];
2573

    
2574
    return pred;
2575
}
2576

    
2577
/**
2578
 * Decode one AC coefficient
2579
 * @param v The VC1 context
2580
 * @param last Last coefficient
2581
 * @param skip How much zero coefficients to skip
2582
 * @param value Decoded AC coefficient value
2583
 * @see 8.1.3.4
2584
 */
2585
static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
2586
{
2587
    GetBitContext *gb = &v->s.gb;
2588
    int index, escape, run = 0, level = 0, lst = 0;
2589

    
2590
    index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2591
    if (index != vc1_ac_sizes[codingset] - 1) {
2592
        run = vc1_index_decode_table[codingset][index][0];
2593
        level = vc1_index_decode_table[codingset][index][1];
2594
        lst = index >= vc1_last_decode_table[codingset];
2595
        if(get_bits(gb, 1))
2596
            level = -level;
2597
    } else {
2598
        escape = decode210(gb);
2599
        if (escape != 2) {
2600
            index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2601
            run = vc1_index_decode_table[codingset][index][0];
2602
            level = vc1_index_decode_table[codingset][index][1];
2603
            lst = index >= vc1_last_decode_table[codingset];
2604
            if(escape == 0) {
2605
                if(lst)
2606
                    level += vc1_last_delta_level_table[codingset][run];
2607
                else
2608
                    level += vc1_delta_level_table[codingset][run];
2609
            } else {
2610
                if(lst)
2611
                    run += vc1_last_delta_run_table[codingset][level] + 1;
2612
                else
2613
                    run += vc1_delta_run_table[codingset][level] + 1;
2614
            }
2615
            if(get_bits(gb, 1))
2616
                level = -level;
2617
        } else {
2618
            int sign;
2619
            lst = get_bits(gb, 1);
2620
            if(v->s.esc3_level_length == 0) {
2621
                if(v->pq < 8 || v->dquantfrm) { // table 59
2622
                    v->s.esc3_level_length = get_bits(gb, 3);
2623
                    if(!v->s.esc3_level_length)
2624
                        v->s.esc3_level_length = get_bits(gb, 2) + 8;
2625
                } else { //table 60
2626
                    v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
2627
                }
2628
                v->s.esc3_run_length = 3 + get_bits(gb, 2);
2629
            }
2630
            run = get_bits(gb, v->s.esc3_run_length);
2631
            sign = get_bits(gb, 1);
2632
            level = get_bits(gb, v->s.esc3_level_length);
2633
            if(sign)
2634
                level = -level;
2635
        }
2636
    }
2637

    
2638
    *last = lst;
2639
    *skip = run;
2640
    *value = level;
2641
}
2642

    
2643
/** Decode intra block in intra frames - should be faster than decode_intra_block
2644
 * @param v VC1Context
2645
 * @param block block to decode
2646
 * @param coded are AC coeffs present or not
2647
 * @param codingset set of VLC to decode data
2648
 */
2649
static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
2650
{
2651
    GetBitContext *gb = &v->s.gb;
2652
    MpegEncContext *s = &v->s;
2653
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
2654
    int run_diff, i;
2655
    int16_t *dc_val;
2656
    int16_t *ac_val, *ac_val2;
2657
    int dcdiff;
2658

    
2659
    /* Get DC differential */
2660
    if (n < 4) {
2661
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2662
    } else {
2663
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2664
    }
2665
    if (dcdiff < 0){
2666
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2667
        return -1;
2668
    }
2669
    if (dcdiff)
2670
    {
2671
        if (dcdiff == 119 /* ESC index value */)
2672
        {
2673
            /* TODO: Optimize */
2674
            if (v->pq == 1) dcdiff = get_bits(gb, 10);
2675
            else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2676
            else dcdiff = get_bits(gb, 8);
2677
        }
2678
        else
2679
        {
2680
            if (v->pq == 1)
2681
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2682
            else if (v->pq == 2)
2683
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2684
        }
2685
        if (get_bits(gb, 1))
2686
            dcdiff = -dcdiff;
2687
    }
2688

    
2689
    /* Prediction */
2690
    dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2691
    *dc_val = dcdiff;
2692

    
2693
    /* Store the quantized DC coeff, used for prediction */
2694
    if (n < 4) {
2695
        block[0] = dcdiff * s->y_dc_scale;
2696
    } else {
2697
        block[0] = dcdiff * s->c_dc_scale;
2698
    }
2699
    /* Skip ? */
2700
    run_diff = 0;
2701
    i = 0;
2702
    if (!coded) {
2703
        goto not_coded;
2704
    }
2705

    
2706
    //AC Decoding
2707
    i = 1;
2708

    
2709
    {
2710
        int last = 0, skip, value;
2711
        const int8_t *zz_table;
2712
        int scale;
2713
        int k;
2714

    
2715
        scale = v->pq * 2 + v->halfpq;
2716

    
2717
        if(v->s.ac_pred) {
2718
            if(!dc_pred_dir)
2719
                zz_table = vc1_horizontal_zz;
2720
            else
2721
                zz_table = vc1_vertical_zz;
2722
        } else
2723
            zz_table = vc1_normal_zz;
2724

    
2725
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2726
        ac_val2 = ac_val;
2727
        if(dc_pred_dir) //left
2728
            ac_val -= 16;
2729
        else //top
2730
            ac_val -= 16 * s->block_wrap[n];
2731

    
2732
        while (!last) {
2733
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2734
            i += skip;
2735
            if(i > 63)
2736
                break;
2737
            block[zz_table[i++]] = value;
2738
        }
2739

    
2740
        /* apply AC prediction if needed */
2741
        if(s->ac_pred) {
2742
            if(dc_pred_dir) { //left
2743
                for(k = 1; k < 8; k++)
2744
                    block[k << 3] += ac_val[k];
2745
            } else { //top
2746
                for(k = 1; k < 8; k++)
2747
                    block[k] += ac_val[k + 8];
2748
            }
2749
        }
2750
        /* save AC coeffs for further prediction */
2751
        for(k = 1; k < 8; k++) {
2752
            ac_val2[k] = block[k << 3];
2753
            ac_val2[k + 8] = block[k];
2754
        }
2755

    
2756
        /* scale AC coeffs */
2757
        for(k = 1; k < 64; k++)
2758
            if(block[k]) {
2759
                block[k] *= scale;
2760
                if(!v->pquantizer)
2761
                    block[k] += (block[k] < 0) ? -v->pq : v->pq;
2762
            }
2763

    
2764
        if(s->ac_pred) i = 63;
2765
    }
2766

    
2767
not_coded:
2768
    if(!coded) {
2769
        int k, scale;
2770
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2771
        ac_val2 = ac_val;
2772

    
2773
        scale = v->pq * 2 + v->halfpq;
2774
        memset(ac_val2, 0, 16 * 2);
2775
        if(dc_pred_dir) {//left
2776
            ac_val -= 16;
2777
            if(s->ac_pred)
2778
                memcpy(ac_val2, ac_val, 8 * 2);
2779
        } else {//top
2780
            ac_val -= 16 * s->block_wrap[n];
2781
            if(s->ac_pred)
2782
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2783
        }
2784

    
2785
        /* apply AC prediction if needed */
2786
        if(s->ac_pred) {
2787
            if(dc_pred_dir) { //left
2788
                for(k = 1; k < 8; k++) {
2789
                    block[k << 3] = ac_val[k] * scale;
2790
                    if(!v->pquantizer && block[k << 3])
2791
                        block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2792
                }
2793
            } else { //top
2794
                for(k = 1; k < 8; k++) {
2795
                    block[k] = ac_val[k + 8] * scale;
2796
                    if(!v->pquantizer && block[k])
2797
                        block[k] += (block[k] < 0) ? -v->pq : v->pq;
2798
                }
2799
            }
2800
            i = 63;
2801
        }
2802
    }
2803
    s->block_last_index[n] = i;
2804

    
2805
    return 0;
2806
}
2807

    
2808
/** Decode intra block in intra frames - should be faster than decode_intra_block
2809
 * @param v VC1Context
2810
 * @param block block to decode
2811
 * @param coded are AC coeffs present or not
2812
 * @param codingset set of VLC to decode data
2813
 */
2814
static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
2815
{
2816
    GetBitContext *gb = &v->s.gb;
2817
    MpegEncContext *s = &v->s;
2818
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
2819
    int run_diff, i;
2820
    int16_t *dc_val;
2821
    int16_t *ac_val, *ac_val2;
2822
    int dcdiff;
2823
    int a_avail = v->a_avail, c_avail = v->c_avail;
2824
    int use_pred = s->ac_pred;
2825
    int scale;
2826
    int q1, q2 = 0;
2827
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2828

    
2829
    /* Get DC differential */
2830
    if (n < 4) {
2831
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2832
    } else {
2833
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2834
    }
2835
    if (dcdiff < 0){
2836
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2837
        return -1;
2838
    }
2839
    if (dcdiff)
2840
    {
2841
        if (dcdiff == 119 /* ESC index value */)
2842
        {
2843
            /* TODO: Optimize */
2844
            if (mquant == 1) dcdiff = get_bits(gb, 10);
2845
            else if (mquant == 2) dcdiff = get_bits(gb, 9);
2846
            else dcdiff = get_bits(gb, 8);
2847
        }
2848
        else
2849
        {
2850
            if (mquant == 1)
2851
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2852
            else if (mquant == 2)
2853
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2854
        }
2855
        if (get_bits(gb, 1))
2856
            dcdiff = -dcdiff;
2857
    }
2858

    
2859
    /* Prediction */
2860
    dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2861
    *dc_val = dcdiff;
2862

    
2863
    /* Store the quantized DC coeff, used for prediction */
2864
    if (n < 4) {
2865
        block[0] = dcdiff * s->y_dc_scale;
2866
    } else {
2867
        block[0] = dcdiff * s->c_dc_scale;
2868
    }
2869
    /* Skip ? */
2870
    run_diff = 0;
2871
    i = 0;
2872

    
2873
    //AC Decoding
2874
    i = 1;
2875

    
2876
    /* check if AC is needed at all and adjust direction if needed */
2877
    if(!a_avail) dc_pred_dir = 1;
2878
    if(!c_avail) dc_pred_dir = 0;
2879
    if(!a_avail && !c_avail) use_pred = 0;
2880
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2881
    ac_val2 = ac_val;
2882

    
2883
    scale = mquant * 2 + v->halfpq;
2884

    
2885
    if(dc_pred_dir) //left
2886
        ac_val -= 16;
2887
    else //top
2888
        ac_val -= 16 * s->block_wrap[n];
2889

    
2890
    q1 = s->current_picture.qscale_table[mb_pos];
2891
    if(dc_pred_dir && c_avail) q2 = s->current_picture.qscale_table[mb_pos - 1];
2892
    if(!dc_pred_dir && a_avail) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2893
    if(n && n<4) q2 = q1;
2894

    
2895
    if(coded) {
2896
        int last = 0, skip, value;
2897
        const int8_t *zz_table;
2898
        int k;
2899

    
2900
        if(v->s.ac_pred) {
2901
            if(!dc_pred_dir)
2902
                zz_table = vc1_horizontal_zz;
2903
            else
2904
                zz_table = vc1_vertical_zz;
2905
        } else
2906
            zz_table = vc1_normal_zz;
2907

    
2908
        while (!last) {
2909
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2910
            i += skip;
2911
            if(i > 63)
2912
                break;
2913
            block[zz_table[i++]] = value;
2914
        }
2915

    
2916
        /* apply AC prediction if needed */
2917
        if(use_pred) {
2918
            /* scale predictors if needed*/
2919
            if(q2 && q1!=q2) {
2920
                q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2921
                q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2922

    
2923
                if(dc_pred_dir) { //left
2924
                    for(k = 1; k < 8; k++)
2925
                        block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2926
                } else { //top
2927
                    for(k = 1; k < 8; k++)
2928
                        block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2929
                }
2930
            } else {
2931
                if(dc_pred_dir) { //left
2932
                    for(k = 1; k < 8; k++)
2933
                        block[k << 3] += ac_val[k];
2934
                } else { //top
2935
                    for(k = 1; k < 8; k++)
2936
                        block[k] += ac_val[k + 8];
2937
                }
2938
            }
2939
        }
2940
        /* save AC coeffs for further prediction */
2941
        for(k = 1; k < 8; k++) {
2942
            ac_val2[k] = block[k << 3];
2943
            ac_val2[k + 8] = block[k];
2944
        }
2945

    
2946
        /* scale AC coeffs */
2947
        for(k = 1; k < 64; k++)
2948
            if(block[k]) {
2949
                block[k] *= scale;
2950
                if(!v->pquantizer)
2951
                    block[k] += (block[k] < 0) ? -mquant : mquant;
2952
            }
2953

    
2954
        if(use_pred) i = 63;
2955
    } else { // no AC coeffs
2956
        int k;
2957

    
2958
        memset(ac_val2, 0, 16 * 2);
2959
        if(dc_pred_dir) {//left
2960
            if(use_pred) {
2961
                memcpy(ac_val2, ac_val, 8 * 2);
2962
                if(q2 && q1!=q2) {
2963
                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2964
                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2965
                    for(k = 1; k < 8; k++)
2966
                        ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2967
                }
2968
            }
2969
        } else {//top
2970
            if(use_pred) {
2971
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2972
                if(q2 && q1!=q2) {
2973
                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2974
                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2975
                    for(k = 1; k < 8; k++)
2976
                        ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2977
                }
2978
            }
2979
        }
2980

    
2981
        /* apply AC prediction if needed */
2982
        if(use_pred) {
2983
            if(dc_pred_dir) { //left
2984
                for(k = 1; k < 8; k++) {
2985
                    block[k << 3] = ac_val2[k] * scale;
2986
                    if(!v->pquantizer && block[k << 3])
2987
                        block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2988
                }
2989
            } else { //top
2990
                for(k = 1; k < 8; k++) {
2991
                    block[k] = ac_val2[k + 8] * scale;
2992
                    if(!v->pquantizer && block[k])
2993
                        block[k] += (block[k] < 0) ? -mquant : mquant;
2994
                }
2995
            }
2996
            i = 63;
2997
        }
2998
    }
2999
    s->block_last_index[n] = i;
3000

    
3001
    return 0;
3002
}
3003

    
3004
/** Decode intra block in inter frames - more generic version than vc1_decode_i_block
3005
 * @param v VC1Context
3006
 * @param block block to decode
3007
 * @param coded are AC coeffs present or not
3008
 * @param mquant block quantizer
3009
 * @param codingset set of VLC to decode data
3010
 */
3011
static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
3012
{
3013
    GetBitContext *gb = &v->s.gb;
3014
    MpegEncContext *s = &v->s;
3015
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
3016
    int run_diff, i;
3017
    int16_t *dc_val;
3018
    int16_t *ac_val, *ac_val2;
3019
    int dcdiff;
3020
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3021
    int a_avail = v->a_avail, c_avail = v->c_avail;
3022
    int use_pred = s->ac_pred;
3023
    int scale;
3024
    int q1, q2 = 0;
3025

    
3026
    /* XXX: Guard against dumb values of mquant */
3027
    mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
3028

    
3029
    /* Set DC scale - y and c use the same */
3030
    s->y_dc_scale = s->y_dc_scale_table[mquant];
3031
    s->c_dc_scale = s->c_dc_scale_table[mquant];
3032

    
3033
    /* Get DC differential */
3034
    if (n < 4) {
3035
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3036
    } else {
3037
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3038
    }
3039
    if (dcdiff < 0){
3040
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3041
        return -1;
3042
    }
3043
    if (dcdiff)
3044
    {
3045
        if (dcdiff == 119 /* ESC index value */)
3046
        {
3047
            /* TODO: Optimize */
3048
            if (mquant == 1) dcdiff = get_bits(gb, 10);
3049
            else if (mquant == 2) dcdiff = get_bits(gb, 9);
3050
            else dcdiff = get_bits(gb, 8);
3051
        }
3052
        else
3053
        {
3054
            if (mquant == 1)
3055
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
3056
            else if (mquant == 2)
3057
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
3058
        }
3059
        if (get_bits(gb, 1))
3060
            dcdiff = -dcdiff;
3061
    }
3062

    
3063
    /* Prediction */
3064
    dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3065
    *dc_val = dcdiff;
3066

    
3067
    /* Store the quantized DC coeff, used for prediction */
3068

    
3069
    if (n < 4) {
3070
        block[0] = dcdiff * s->y_dc_scale;
3071
    } else {
3072
        block[0] = dcdiff * s->c_dc_scale;
3073
    }
3074
    /* Skip ? */
3075
    run_diff = 0;
3076
    i = 0;
3077

    
3078
    //AC Decoding
3079
    i = 1;
3080

    
3081
    /* check if AC is needed at all and adjust direction if needed */
3082
    if(!a_avail) dc_pred_dir = 1;
3083
    if(!c_avail) dc_pred_dir = 0;
3084
    if(!a_avail && !c_avail) use_pred = 0;
3085
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3086
    ac_val2 = ac_val;
3087

    
3088
    scale = mquant * 2 + v->halfpq;
3089

    
3090
    if(dc_pred_dir) //left
3091
        ac_val -= 16;
3092
    else //top
3093
        ac_val -= 16 * s->block_wrap[n];
3094

    
3095
    q1 = s->current_picture.qscale_table[mb_pos];
3096
    if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
3097
    if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3098
    if(n && n<4) q2 = q1;
3099

    
3100
    if(coded) {
3101
        int last = 0, skip, value;
3102
        const int8_t *zz_table;
3103
        int k;
3104

    
3105
        zz_table = vc1_simple_progressive_8x8_zz;
3106

    
3107
        while (!last) {
3108
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3109
            i += skip;
3110
            if(i > 63)
3111
                break;
3112
            block[zz_table[i++]] = value;
3113
        }
3114

    
3115
        /* apply AC prediction if needed */
3116
        if(use_pred) {
3117
            /* scale predictors if needed*/
3118
            if(q2 && q1!=q2) {
3119
                q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3120
                q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3121

    
3122
                if(dc_pred_dir) { //left
3123
                    for(k = 1; k < 8; k++)
3124
                        block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3125
                } else { //top
3126
                    for(k = 1; k < 8; k++)
3127
                        block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3128
                }
3129
            } else {
3130
                if(dc_pred_dir) { //left
3131
                    for(k = 1; k < 8; k++)
3132
                        block[k << 3] += ac_val[k];
3133
                } else { //top
3134
                    for(k = 1; k < 8; k++)
3135
                        block[k] += ac_val[k + 8];
3136
                }
3137
            }
3138
        }
3139
        /* save AC coeffs for further prediction */
3140
        for(k = 1; k < 8; k++) {
3141
            ac_val2[k] = block[k << 3];
3142
            ac_val2[k + 8] = block[k];
3143
        }
3144

    
3145
        /* scale AC coeffs */
3146
        for(k = 1; k < 64; k++)
3147
            if(block[k]) {
3148
                block[k] *= scale;
3149
                if(!v->pquantizer)
3150
                    block[k] += (block[k] < 0) ? -mquant : mquant;
3151
            }
3152

    
3153
        if(use_pred) i = 63;
3154
    } else { // no AC coeffs
3155
        int k;
3156

    
3157
        memset(ac_val2, 0, 16 * 2);
3158
        if(dc_pred_dir) {//left
3159
            if(use_pred) {
3160
                memcpy(ac_val2, ac_val, 8 * 2);
3161
                if(q2 && q1!=q2) {
3162
                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3163
                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3164
                    for(k = 1; k < 8; k++)
3165
                        ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3166
                }
3167
            }
3168
        } else {//top
3169
            if(use_pred) {
3170
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3171
                if(q2 && q1!=q2) {
3172
                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3173
                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3174
                    for(k = 1; k < 8; k++)
3175
                        ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3176
                }
3177
            }
3178
        }
3179

    
3180
        /* apply AC prediction if needed */
3181
        if(use_pred) {
3182
            if(dc_pred_dir) { //left
3183
                for(k = 1; k < 8; k++) {
3184
                    block[k << 3] = ac_val2[k] * scale;
3185
                    if(!v->pquantizer && block[k << 3])
3186
                        block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3187
                }
3188
            } else { //top
3189
                for(k = 1; k < 8; k++) {
3190
                    block[k] = ac_val2[k + 8] * scale;
3191
                    if(!v->pquantizer && block[k])
3192
                        block[k] += (block[k] < 0) ? -mquant : mquant;
3193
                }
3194
            }
3195
            i = 63;
3196
        }
3197
    }
3198
    s->block_last_index[n] = i;
3199

    
3200
    return 0;
3201
}
3202

    
3203
/** Decode P block
3204
 */
3205
static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
3206
{
3207
    MpegEncContext *s = &v->s;
3208
    GetBitContext *gb = &s->gb;
3209
    int i, j;
3210
    int subblkpat = 0;
3211
    int scale, off, idx, last, skip, value;
3212
    int ttblk = ttmb & 7;
3213

    
3214
    if(ttmb == -1) {
3215
        ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
3216
    }
3217
    if(ttblk == TT_4X4) {
3218
        subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3219
    }
3220
    if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
3221
        subblkpat = decode012(gb);
3222
        if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
3223
        if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
3224
        if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
3225
    }
3226
    scale = 2 * mquant + v->halfpq;
3227

    
3228
    // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3229
    if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3230
        subblkpat = 2 - (ttblk == TT_8X4_TOP);
3231
        ttblk = TT_8X4;
3232
    }
3233
    if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3234
        subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3235
        ttblk = TT_4X8;
3236
    }
3237
    switch(ttblk) {
3238
    case TT_8X8:
3239
        i = 0;
3240
        last = 0;
3241
        while (!last) {
3242
            vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3243
            i += skip;
3244
            if(i > 63)
3245
                break;
3246
            idx = vc1_simple_progressive_8x8_zz[i++];
3247
            block[idx] = value * scale;
3248
            if(!v->pquantizer)
3249
                block[idx] += (block[idx] < 0) ? -mquant : mquant;
3250
        }
3251
        s->dsp.vc1_inv_trans_8x8(block);
3252
        break;
3253
    case TT_4X4:
3254
        for(j = 0; j < 4; j++) {
3255
            last = subblkpat & (1 << (3 - j));
3256
            i = 0;
3257
            off = (j & 1) * 4 + (j & 2) * 16;
3258
            while (!last) {
3259
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3260
                i += skip;
3261
                if(i > 15)
3262
                    break;
3263
                idx = vc1_simple_progressive_4x4_zz[i++];
3264
                block[idx + off] = value * scale;
3265
                if(!v->pquantizer)
3266
                    block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3267
            }
3268
            if(!(subblkpat & (1 << (3 - j))))
3269
                s->dsp.vc1_inv_trans_4x4(block, j);
3270
        }
3271
        break;
3272
    case TT_8X4:
3273
        for(j = 0; j < 2; j++) {
3274
            last = subblkpat & (1 << (1 - j));
3275
            i = 0;
3276
            off = j * 32;
3277
            while (!last) {
3278
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3279
                i += skip;
3280
                if(i > 31)
3281
                    break;
3282
                if(v->profile < PROFILE_ADVANCED)
3283
                    idx = vc1_simple_progressive_8x4_zz[i++];
3284
                else
3285
                    idx = vc1_adv_progressive_8x4_zz[i++];
3286
                block[idx + off] = value * scale;
3287
                if(!v->pquantizer)
3288
                    block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3289
            }
3290
            if(!(subblkpat & (1 << (1 - j))))
3291
                s->dsp.vc1_inv_trans_8x4(block, j);
3292
        }
3293
        break;
3294
    case TT_4X8:
3295
        for(j = 0; j < 2; j++) {
3296
            last = subblkpat & (1 << (1 - j));
3297
            i = 0;
3298
            off = j * 4;
3299
            while (!last) {
3300
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3301
                i += skip;
3302
                if(i > 31)
3303
                    break;
3304
                if(v->profile < PROFILE_ADVANCED)
3305
                    idx = vc1_simple_progressive_4x8_zz[i++];
3306
                else
3307
                    idx = vc1_adv_progressive_4x8_zz[i++];
3308
                block[idx + off] = value * scale;
3309
                if(!v->pquantizer)
3310
                    block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3311
            }
3312
            if(!(subblkpat & (1 << (1 - j))))
3313
                s->dsp.vc1_inv_trans_4x8(block, j);
3314
        }
3315
        break;
3316
    }
3317
    return 0;
3318
}
3319

    
3320

    
3321
/** Decode one P-frame MB (in Simple/Main profile)
3322
 */
3323
static int vc1_decode_p_mb(VC1Context *v)
3324
{
3325
    MpegEncContext *s = &v->s;
3326
    GetBitContext *gb = &s->gb;
3327
    int i, j;
3328
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3329
    int cbp; /* cbp decoding stuff */
3330
    int mqdiff, mquant; /* MB quantization */
3331
    int ttmb = v->ttfrm; /* MB Transform type */
3332
    int status;
3333

    
3334
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3335
      offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3336
    int mb_has_coeffs = 1; /* last_flag */
3337
    int dmv_x, dmv_y; /* Differential MV components */
3338
    int index, index1; /* LUT indices */
3339
    int val, sign; /* temp values */
3340
    int first_block = 1;
3341
    int dst_idx, off;
3342
    int skipped, fourmv;
3343

    
3344
    mquant = v->pq; /* Loosy initialization */
3345

    
3346
    if (v->mv_type_is_raw)
3347
        fourmv = get_bits1(gb);
3348
    else
3349
        fourmv = v->mv_type_mb_plane[mb_pos];
3350
    if (v->skip_is_raw)
3351
        skipped = get_bits1(gb);
3352
    else
3353
        skipped = v->s.mbskip_table[mb_pos];
3354

    
3355
    s->dsp.clear_blocks(s->block[0]);
3356

    
3357
    if (!fourmv) /* 1MV mode */
3358
    {
3359
        if (!skipped)
3360
        {
3361
            GET_MVDATA(dmv_x, dmv_y);
3362

    
3363
            if (s->mb_intra) {
3364
                s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3365
                s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3366
            }
3367
            s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3368
            vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3369

    
3370
            /* FIXME Set DC val for inter block ? */
3371
            if (s->mb_intra && !mb_has_coeffs)
3372
            {
3373
                GET_MQUANT();
3374
                s->ac_pred = get_bits(gb, 1);
3375
                cbp = 0;
3376
            }
3377
            else if (mb_has_coeffs)
3378
            {
3379
                if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
3380
                cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3381
                GET_MQUANT();
3382
            }
3383
            else
3384
            {
3385
                mquant = v->pq;
3386
                cbp = 0;
3387
            }
3388
            s->current_picture.qscale_table[mb_pos] = mquant;
3389

    
3390
            if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3391
                ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
3392
                                VC1_TTMB_VLC_BITS, 2);
3393
            if(!s->mb_intra) vc1_mc_1mv(v, 0);
3394
            dst_idx = 0;
3395
            for (i=0; i<6; i++)
3396
            {
3397
                s->dc_val[0][s->block_index[i]] = 0;
3398
                dst_idx += i >> 2;
3399
                val = ((cbp >> (5 - i)) & 1);
3400
                off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3401
                v->mb_type[0][s->block_index[i]] = s->mb_intra;
3402
                if(s->mb_intra) {
3403
                    /* check if prediction blocks A and C are available */
3404
                    v->a_avail = v->c_avail = 0;
3405
                    if(i == 2 || i == 3 || !s->first_slice_line)
3406
                        v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3407
                    if(i == 1 || i == 3 || s->mb_x)
3408
                        v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3409

    
3410
                    vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3411
                    if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3412
                    s->dsp.vc1_inv_trans_8x8(s->block[i]);
3413
                    if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3414
                    for(j = 0; j < 64; j++) s->block[i][j] += 128;
3415
                    s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3416
                    if(v->pq >= 9 && v->overlap) {
3417
                        if(v->c_avail)
3418
                            s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3419
                        if(v->a_avail)
3420
                            s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3421
                    }
3422
                } else if(val) {
3423
                    vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3424
                    if(!v->ttmbf && ttmb < 8) ttmb = -1;
3425
                    first_block = 0;
3426
                    if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3427
                        s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3428
                }
3429
            }
3430
        }
3431
        else //Skipped
3432
        {
3433
            s->mb_intra = 0;
3434
            for(i = 0; i < 6; i++) {
3435
                v->mb_type[0][s->block_index[i]] = 0;
3436
                s->dc_val[0][s->block_index[i]] = 0;
3437
            }
3438
            s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3439
            s->current_picture.qscale_table[mb_pos] = 0;
3440
            vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3441
            vc1_mc_1mv(v, 0);
3442
            return 0;
3443
        }
3444
    } //1MV mode
3445
    else //4MV mode
3446
    {
3447
        if (!skipped /* unskipped MB */)
3448
        {
3449
            int intra_count = 0, coded_inter = 0;
3450
            int is_intra[6], is_coded[6];
3451
            /* Get CBPCY */
3452
            cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3453
            for (i=0; i<6; i++)
3454
            {
3455
                val = ((cbp >> (5 - i)) & 1);
3456
                s->dc_val[0][s->block_index[i]] = 0;
3457
                s->mb_intra = 0;
3458
                if(i < 4) {
3459
                    dmv_x = dmv_y = 0;
3460
                    s->mb_intra = 0;
3461
                    mb_has_coeffs = 0;
3462
                    if(val) {
3463
                        GET_MVDATA(dmv_x, dmv_y);
3464
                    }
3465
                    vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3466
                    if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
3467
                    intra_count += s->mb_intra;
3468
                    is_intra[i] = s->mb_intra;
3469
                    is_coded[i] = mb_has_coeffs;
3470
                }
3471
                if(i&4){
3472
                    is_intra[i] = (intra_count >= 3);
3473
                    is_coded[i] = val;
3474
                }
3475
                if(i == 4) vc1_mc_4mv_chroma(v);
3476
                v->mb_type[0][s->block_index[i]] = is_intra[i];
3477
                if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
3478
            }
3479
            // if there are no coded blocks then don't do anything more
3480
            if(!intra_count && !coded_inter) return 0;
3481
            dst_idx = 0;
3482
            GET_MQUANT();
3483
            s->current_picture.qscale_table[mb_pos] = mquant;
3484
            /* test if block is intra and has pred */
3485
            {
3486
                int intrapred = 0;
3487
                for(i=0; i<6; i++)
3488
                    if(is_intra[i]) {
3489
                        if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3490
                            || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
3491
                            intrapred = 1;
3492
                            break;
3493
                        }
3494
                    }
3495
                if(intrapred)s->ac_pred = get_bits(gb, 1);
3496
                else s->ac_pred = 0;
3497
            }
3498
            if (!v->ttmbf && coded_inter)
3499
                ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3500
            for (i=0; i<6; i++)
3501
            {
3502
                dst_idx += i >> 2;
3503
                off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3504
                s->mb_intra = is_intra[i];
3505
                if (is_intra[i]) {
3506
                    /* check if prediction blocks A and C are available */
3507
                    v->a_avail = v->c_avail = 0;
3508
                    if(i == 2 || i == 3 || !s->first_slice_line)
3509
                        v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3510
                    if(i == 1 || i == 3 || s->mb_x)
3511
                        v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3512

    
3513
                    vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
3514
                    if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3515
                    s->dsp.vc1_inv_trans_8x8(s->block[i]);
3516
                    if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3517
                    for(j = 0; j < 64; j++) s->block[i][j] += 128;
3518
                    s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3519
                    if(v->pq >= 9 && v->overlap) {
3520
                        if(v->c_avail)
3521
                            s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3522
                        if(v->a_avail)
3523
                            s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3524
                    }
3525
                } else if(is_coded[i]) {
3526
                    status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3527
                    if(!v->ttmbf && ttmb < 8) ttmb = -1;
3528
                    first_block = 0;
3529
                    if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3530
                        s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3531
                }
3532
            }
3533
            return status;
3534
        }
3535
        else //Skipped MB
3536
        {
3537
            s->mb_intra = 0;
3538
            s->current_picture.qscale_table[mb_pos] = 0;
3539
            for (i=0; i<6; i++) {
3540
                v->mb_type[0][s->block_index[i]] = 0;
3541
                s->dc_val[0][s->block_index[i]] = 0;
3542
            }
3543
            for (i=0; i<4; i++)
3544
            {
3545
                vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
3546
                vc1_mc_4mv_luma(v, i);
3547
            }
3548
            vc1_mc_4mv_chroma(v);
3549
            s->current_picture.qscale_table[mb_pos] = 0;
3550
            return 0;
3551
        }
3552
    }
3553

    
3554
    /* Should never happen */
3555
    return -1;
3556
}
3557

    
3558
/** Decode one B-frame MB (in Main profile)
3559
 */
3560
static void vc1_decode_b_mb(VC1Context *v)
3561
{
3562
    MpegEncContext *s = &v->s;
3563
    GetBitContext *gb = &s->gb;
3564
    int i, j;
3565
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3566
    int cbp = 0; /* cbp decoding stuff */
3567
    int mqdiff, mquant; /* MB quantization */
3568
    int ttmb = v->ttfrm; /* MB Transform type */
3569

    
3570
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3571
      offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3572
    int mb_has_coeffs = 0; /* last_flag */
3573
    int index, index1; /* LUT indices */
3574
    int val, sign; /* temp values */
3575
    int first_block = 1;
3576
    int dst_idx, off;
3577
    int skipped, direct;
3578
    int dmv_x[2], dmv_y[2];
3579
    int bmvtype = BMV_TYPE_BACKWARD;
3580

    
3581
    mquant = v->pq; /* Loosy initialization */
3582
    s->mb_intra = 0;
3583

    
3584
    if (v->dmb_is_raw)
3585
        direct = get_bits1(gb);
3586
    else
3587
        direct = v->direct_mb_plane[mb_pos];
3588
    if (v->skip_is_raw)
3589
        skipped = get_bits1(gb);
3590
    else
3591
        skipped = v->s.mbskip_table[mb_pos];
3592

    
3593
    s->dsp.clear_blocks(s->block[0]);
3594
    dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
3595
    for(i = 0; i < 6; i++) {
3596
        v->mb_type[0][s->block_index[i]] = 0;
3597
        s->dc_val[0][s->block_index[i]] = 0;
3598
    }
3599
    s->current_picture.qscale_table[mb_pos] = 0;
3600

    
3601
    if (!direct) {
3602
        if (!skipped) {
3603
            GET_MVDATA(dmv_x[0], dmv_y[0]);
3604
            dmv_x[1] = dmv_x[0];
3605
            dmv_y[1] = dmv_y[0];
3606
        }
3607
        if(skipped || !s->mb_intra) {
3608
            bmvtype = decode012(gb);
3609
            switch(bmvtype) {
3610
            case 0:
3611
                bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
3612
                break;
3613
            case 1:
3614
                bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
3615
                break;
3616
            case 2:
3617
                bmvtype = BMV_TYPE_INTERPOLATED;
3618
                dmv_x[0] = dmv_y[0] = 0;
3619
            }
3620
        }
3621
    }
3622
    for(i = 0; i < 6; i++)
3623
        v->mb_type[0][s->block_index[i]] = s->mb_intra;
3624

    
3625
    if (skipped) {
3626
        if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
3627
        vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3628
        vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3629
        return;
3630
    }
3631
    if (direct) {
3632
        cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3633
        GET_MQUANT();
3634
        s->mb_intra = 0;
3635
        mb_has_coeffs = 0;
3636
        s->current_picture.qscale_table[mb_pos] = mquant;
3637
        if(!v->ttmbf)
3638
            ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3639
        dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
3640
        vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3641
        vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3642
    } else {
3643
        if(!mb_has_coeffs && !s->mb_intra) {
3644
            /* no coded blocks - effectively skipped */
3645
            vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3646
            vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3647
            return;
3648
        }
3649
        if(s->mb_intra && !mb_has_coeffs) {
3650
            GET_MQUANT();
3651
            s->current_picture.qscale_table[mb_pos] = mquant;
3652
            s->ac_pred = get_bits1(gb);
3653
            cbp = 0;
3654
            vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3655
        } else {
3656
            if(bmvtype == BMV_TYPE_INTERPOLATED) {
3657
                GET_MVDATA(dmv_x[0], dmv_y[0]);
3658
                if(!mb_has_coeffs) {
3659
                    /* interpolated skipped block */
3660
                    vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3661
                    vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3662
                    return;
3663
                }
3664
            }
3665
            vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3666
            if(!s->mb_intra) {
3667
                vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3668
            }
3669
            if(s->mb_intra)
3670
                s->ac_pred = get_bits1(gb);
3671
            cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3672
            GET_MQUANT();
3673
            s->current_picture.qscale_table[mb_pos] = mquant;
3674
            if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3675
                ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3676
        }
3677
    }
3678
    dst_idx = 0;
3679
    for (i=0; i<6; i++)
3680
    {
3681
        s->dc_val[0][s->block_index[i]] = 0;
3682
        dst_idx += i >> 2;
3683
        val = ((cbp >> (5 - i)) & 1);
3684
        off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3685
        v->mb_type[0][s->block_index[i]] = s->mb_intra;
3686
        if(s->mb_intra) {
3687
            /* check if prediction blocks A and C are available */
3688
            v->a_avail = v->c_avail = 0;
3689
            if(i == 2 || i == 3 || !s->first_slice_line)
3690
                v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3691
            if(i == 1 || i == 3 || s->mb_x)
3692
                v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3693

    
3694
            vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3695
            if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3696
            s->dsp.vc1_inv_trans_8x8(s->block[i]);
3697
            if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3698
            for(j = 0; j < 64; j++) s->block[i][j] += 128;
3699
            s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3700
        } else if(val) {
3701
            vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3702
            if(!v->ttmbf && ttmb < 8) ttmb = -1;
3703
            first_block = 0;
3704
            if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3705
                s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3706
        }
3707
    }
3708
}
3709

    
3710
/** Decode blocks of I-frame
3711
 */
3712
static void vc1_decode_i_blocks(VC1Context *v)
3713
{
3714
    int k, j;
3715
    MpegEncContext *s = &v->s;
3716
    int cbp, val;
3717
    uint8_t *coded_val;
3718
    int mb_pos;
3719

    
3720
    /* select codingmode used for VLC tables selection */
3721
    switch(v->y_ac_table_index){
3722
    case 0:
3723
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3724
        break;
3725
    case 1:
3726
        v->codingset = CS_HIGH_MOT_INTRA;
3727
        break;
3728
    case 2:
3729
        v->codingset = CS_MID_RATE_INTRA;
3730
        break;
3731
    }
3732

    
3733
    switch(v->c_ac_table_index){
3734
    case 0:
3735
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3736
        break;
3737
    case 1:
3738
        v->codingset2 = CS_HIGH_MOT_INTER;
3739
        break;
3740
    case 2:
3741
        v->codingset2 = CS_MID_RATE_INTER;
3742
        break;
3743
    }
3744

    
3745
    /* Set DC scale - y and c use the same */
3746
    s->y_dc_scale = s->y_dc_scale_table[v->pq];
3747
    s->c_dc_scale = s->c_dc_scale_table[v->pq];
3748

    
3749
    //do frame decode
3750
    s->mb_x = s->mb_y = 0;
3751
    s->mb_intra = 1;
3752
    s->first_slice_line = 1;
3753
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3754
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3755
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3756
            ff_init_block_index(s);
3757
            ff_update_block_index(s);
3758
            s->dsp.clear_blocks(s->block[0]);
3759
            mb_pos = s->mb_x + s->mb_y * s->mb_width;
3760
            s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3761
            s->current_picture.qscale_table[mb_pos] = v->pq;
3762
            s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3763
            s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3764

    
3765
            // do actual MB decoding and displaying
3766
            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3767
            v->s.ac_pred = get_bits(&v->s.gb, 1);
3768

    
3769
            for(k = 0; k < 6; k++) {
3770
                val = ((cbp >> (5 - k)) & 1);
3771

    
3772
                if (k < 4) {
3773
                    int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3774
                    val = val ^ pred;
3775
                    *coded_val = val;
3776
                }
3777
                cbp |= val << (5 - k);
3778

    
3779
                vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
3780

    
3781
                s->dsp.vc1_inv_trans_8x8(s->block[k]);
3782
                if(v->pq >= 9 && v->overlap) {
3783
                    for(j = 0; j < 64; j++) s->block[k][j] += 128;
3784
                }
3785
            }
3786

    
3787
            vc1_put_block(v, s->block);
3788
            if(v->pq >= 9 && v->overlap) {
3789
                if(s->mb_x) {
3790
                    s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3791
                    s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3792
                    if(!(s->flags & CODEC_FLAG_GRAY)) {
3793
                        s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3794
                        s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3795
                    }
3796
                }
3797
                s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3798
                s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3799
                if(!s->first_slice_line) {
3800
                    s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3801
                    s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3802
                    if(!(s->flags & CODEC_FLAG_GRAY)) {
3803
                        s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3804
                        s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3805
                    }
3806
                }
3807
                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3808
                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3809
            }
3810

    
3811
            if(get_bits_count(&s->gb) > v->bits) {
3812
                av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3813
                return;
3814
            }
3815
        }
3816
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
3817
        s->first_slice_line = 0;
3818
    }
3819
}
3820

    
3821
/** Decode blocks of I-frame for advanced profile
3822
 */
3823
static void vc1_decode_i_blocks_adv(VC1Context *v)
3824
{
3825
    int k, j;
3826
    MpegEncContext *s = &v->s;
3827
    int cbp, val;
3828
    uint8_t *coded_val;
3829
    int mb_pos;
3830
    int mquant = v->pq;
3831
    int mqdiff;
3832
    int overlap;
3833
    GetBitContext *gb = &s->gb;
3834

    
3835
    /* select codingmode used for VLC tables selection */
3836
    switch(v->y_ac_table_index){
3837
    case 0:
3838
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3839
        break;
3840
    case 1:
3841
        v->codingset = CS_HIGH_MOT_INTRA;
3842
        break;
3843
    case 2:
3844
        v->codingset = CS_MID_RATE_INTRA;
3845
        break;
3846
    }
3847

    
3848
    switch(v->c_ac_table_index){
3849
    case 0:
3850
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3851
        break;
3852
    case 1:
3853
        v->codingset2 = CS_HIGH_MOT_INTER;
3854
        break;
3855
    case 2:
3856
        v->codingset2 = CS_MID_RATE_INTER;
3857
        break;
3858
    }
3859

    
3860
    //do frame decode
3861
    s->mb_x = s->mb_y = 0;
3862
    s->mb_intra = 1;
3863
    s->first_slice_line = 1;
3864
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3865
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3866
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3867
            ff_init_block_index(s);
3868
            ff_update_block_index(s);
3869
            s->dsp.clear_blocks(s->block[0]);
3870
            mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3871
            s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3872
            s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3873
            s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3874

    
3875
            // do actual MB decoding and displaying
3876
            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3877
            if(v->acpred_is_raw)
3878
                v->s.ac_pred = get_bits(&v->s.gb, 1);
3879
            else
3880
                v->s.ac_pred = v->acpred_plane[mb_pos];
3881

    
3882
            if(v->condover == CONDOVER_SELECT) {
3883
                if(v->overflg_is_raw)
3884
                    overlap = get_bits(&v->s.gb, 1);
3885
                else
3886
                    overlap = v->over_flags_plane[mb_pos];
3887
            } else
3888
                overlap = (v->condover == CONDOVER_ALL);
3889

    
3890
            GET_MQUANT();
3891

    
3892
            s->current_picture.qscale_table[mb_pos] = mquant;
3893
            /* Set DC scale - y and c use the same */
3894
            s->y_dc_scale = s->y_dc_scale_table[mquant];
3895
            s->c_dc_scale = s->c_dc_scale_table[mquant];
3896

    
3897
            for(k = 0; k < 6; k++) {
3898
                val = ((cbp >> (5 - k)) & 1);
3899

    
3900
                if (k < 4) {
3901
                    int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3902
                    val = val ^ pred;
3903
                    *coded_val = val;
3904
                }
3905
                cbp |= val << (5 - k);
3906

    
3907
                v->a_avail = !s->first_slice_line || (k==2 || k==3);
3908
                v->c_avail = !!s->mb_x || (k==1 || k==3);
3909

    
3910
                vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
3911

    
3912
                s->dsp.vc1_inv_trans_8x8(s->block[k]);
3913
                for(j = 0; j < 64; j++) s->block[k][j] += 128;
3914
            }
3915

    
3916
            vc1_put_block(v, s->block);
3917
            if(overlap) {
3918
                if(s->mb_x) {
3919
                    s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3920
                    s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3921
                    if(!(s->flags & CODEC_FLAG_GRAY)) {
3922
                        s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3923
                        s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3924
                    }
3925
                }
3926
                s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3927
                s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3928
                if(!s->first_slice_line) {
3929
                    s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3930
                    s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3931
                    if(!(s->flags & CODEC_FLAG_GRAY)) {
3932
                        s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3933
                        s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3934
                    }
3935
                }
3936
                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3937
                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3938
            }
3939

    
3940
            if(get_bits_count(&s->gb) > v->bits) {
3941
                av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3942
                return;
3943
            }
3944
        }
3945
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
3946
        s->first_slice_line = 0;
3947
    }
3948
}
3949

    
3950
static void vc1_decode_p_blocks(VC1Context *v)
3951
{
3952
    MpegEncContext *s = &v->s;
3953

    
3954
    /* select codingmode used for VLC tables selection */
3955
    switch(v->c_ac_table_index){
3956
    case 0:
3957
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3958
        break;
3959
    case 1:
3960
        v->codingset = CS_HIGH_MOT_INTRA;
3961
        break;
3962
    case 2:
3963
        v->codingset = CS_MID_RATE_INTRA;
3964
        break;
3965
    }
3966

    
3967
    switch(v->c_ac_table_index){
3968
    case 0:
3969
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3970
        break;
3971
    case 1:
3972
        v->codingset2 = CS_HIGH_MOT_INTER;
3973
        break;
3974
    case 2:
3975
        v->codingset2 = CS_MID_RATE_INTER;
3976
        break;
3977
    }
3978

    
3979
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3980
    s->first_slice_line = 1;
3981
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3982
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3983
            ff_init_block_index(s);
3984
            ff_update_block_index(s);
3985
            s->dsp.clear_blocks(s->block[0]);
3986

    
3987
            vc1_decode_p_mb(v);
3988
            if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
3989
                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);
3990
                return;
3991
            }
3992
        }
3993
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
3994
        s->first_slice_line = 0;
3995
    }
3996
}
3997

    
3998
static void vc1_decode_b_blocks(VC1Context *v)
3999
{
4000
    MpegEncContext *s = &v->s;
4001

    
4002
    /* select codingmode used for VLC tables selection */
4003
    switch(v->c_ac_table_index){
4004
    case 0:
4005
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4006
        break;
4007
    case 1:
4008
        v->codingset = CS_HIGH_MOT_INTRA;
4009
        break;
4010
    case 2:
4011
        v->codingset = CS_MID_RATE_INTRA;
4012
        break;
4013
    }
4014

    
4015
    switch(v->c_ac_table_index){
4016
    case 0:
4017
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4018
        break;
4019
    case 1:
4020
        v->codingset2 = CS_HIGH_MOT_INTER;
4021
        break;
4022
    case 2:
4023
        v->codingset2 = CS_MID_RATE_INTER;
4024
        break;
4025
    }
4026

    
4027
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4028
    s->first_slice_line = 1;
4029
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4030
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
4031
            ff_init_block_index(s);
4032
            ff_update_block_index(s);
4033
            s->dsp.clear_blocks(s->block[0]);
4034

    
4035
            vc1_decode_b_mb(v);
4036
            if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4037
                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);
4038
                return;
4039
            }
4040
        }
4041
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
4042
        s->first_slice_line = 0;
4043
    }
4044
}
4045

    
4046
static void vc1_decode_skip_blocks(VC1Context *v)
4047
{
4048
    MpegEncContext *s = &v->s;
4049

    
4050
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4051
    s->first_slice_line = 1;
4052
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4053
        s->mb_x = 0;
4054
        ff_init_block_index(s);
4055
        ff_update_block_index(s);
4056
        memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4057
        memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4058
        memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4059
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
4060
        s->first_slice_line = 0;
4061
    }
4062
    s->pict_type = P_TYPE;
4063
}
4064

    
4065
static void vc1_decode_blocks(VC1Context *v)
4066
{
4067

    
4068
    v->s.esc3_level_length = 0;
4069

    
4070
    switch(v->s.pict_type) {
4071
    case I_TYPE:
4072
        if(v->profile == PROFILE_ADVANCED)
4073
            vc1_decode_i_blocks_adv(v);
4074
        else
4075
            vc1_decode_i_blocks(v);
4076
        break;
4077
    case P_TYPE:
4078
        if(v->p_frame_skipped)
4079
            vc1_decode_skip_blocks(v);
4080
        else
4081
            vc1_decode_p_blocks(v);
4082
        break;
4083
    case B_TYPE:
4084
        if(v->bi_type)
4085
            vc1_decode_i_blocks(v);
4086
        else
4087
            vc1_decode_b_blocks(v);
4088
        break;
4089
    }
4090
}
4091

    
4092

    
4093
/** Initialize a VC1/WMV3 decoder
4094
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4095
 * @todo TODO: Decypher remaining bits in extra_data
4096
 */
4097
static int vc1_decode_init(AVCodecContext *avctx)
4098
{
4099
    VC1Context *v = avctx->priv_data;
4100
    MpegEncContext *s = &v->s;
4101
    GetBitContext gb;
4102

    
4103
    if (!avctx->extradata_size || !avctx->extradata) return -1;
4104
    if (!(avctx->flags & CODEC_FLAG_GRAY))
4105
        avctx->pix_fmt = PIX_FMT_YUV420P;
4106
    else
4107
        avctx->pix_fmt = PIX_FMT_GRAY8;
4108
    v->s.avctx = avctx;
4109
    avctx->flags |= CODEC_FLAG_EMU_EDGE;
4110
    v->s.flags |= CODEC_FLAG_EMU_EDGE;
4111

    
4112
    if(ff_h263_decode_init(avctx) < 0)
4113
        return -1;
4114
    if (vc1_init_common(v) < 0) return -1;
4115

    
4116
    avctx->coded_width = avctx->width;
4117
    avctx->coded_height = avctx->height;
4118
    if (avctx->codec_id == CODEC_ID_WMV3)
4119
    {
4120
        int count = 0;
4121

    
4122
        // looks like WMV3 has a sequence header stored in the extradata
4123
        // advanced sequence header may be before the first frame
4124
        // the last byte of the extradata is a version number, 1 for the
4125
        // samples we can decode
4126

    
4127
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
4128

    
4129
        if (decode_sequence_header(avctx, &gb) < 0)
4130
          return -1;
4131

    
4132
        count = avctx->extradata_size*8 - get_bits_count(&gb);
4133
        if (count>0)
4134
        {
4135
            av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
4136
                   count, get_bits(&gb, count));
4137
        }
4138
        else if (count < 0)
4139
        {
4140
            av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
4141
        }
4142
    } else { // VC1/WVC1
4143
        int edata_size = avctx->extradata_size;
4144
        uint8_t *edata = avctx->extradata;
4145

    
4146
        if(avctx->extradata_size < 16) {
4147
            av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", edata_size);
4148
            return -1;
4149
        }
4150
        while(edata_size > 8) {
4151
            // test if we've found header
4152
            if(AV_RB32(edata) == 0x0000010F) {
4153
                edata += 4;
4154
                edata_size -= 4;
4155
                break;
4156
            }
4157
            edata_size--;
4158
            edata++;
4159
        }
4160

    
4161
        init_get_bits(&gb, edata, edata_size*8);
4162

    
4163
        if (decode_sequence_header(avctx, &gb) < 0)
4164
          return -1;
4165

    
4166
        while(edata_size > 8) {
4167
            // test if we've found entry point
4168
            if(AV_RB32(edata) == 0x0000010E) {
4169
                edata += 4;
4170
                edata_size -= 4;
4171
                break;
4172
            }
4173
            edata_size--;
4174
            edata++;
4175
        }
4176

    
4177
        init_get_bits(&gb, edata, edata_size*8);
4178

    
4179
        if (decode_entry_point(avctx, &gb) < 0)
4180
          return -1;
4181
    }
4182
    avctx->has_b_frames= !!(avctx->max_b_frames);
4183
    s->low_delay = !avctx->has_b_frames;
4184

    
4185
    s->mb_width = (avctx->coded_width+15)>>4;
4186
    s->mb_height = (avctx->coded_height+15)>>4;
4187

    
4188
    /* Allocate mb bitplanes */
4189
    v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
4190
    v->direct_mb_plane = av_malloc(s->mb_stride * s->mb_height);
4191
    v->acpred_plane = av_malloc(s->mb_stride * s->mb_height);
4192
    v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height);
4193

    
4194
    /* allocate block type info in that way so it could be used with s->block_index[] */
4195
    v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
4196
    v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
4197
    v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
4198
    v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
4199

    
4200
    /* Init coded blocks info */
4201
    if (v->profile == PROFILE_ADVANCED)
4202
    {
4203
//        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
4204
//            return -1;
4205
//        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
4206
//            return -1;
4207
    }
4208

    
4209
    return 0;
4210
}
4211

    
4212

    
4213
/** Decode a VC1/WMV3 frame
4214
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4215
 */
4216
static int vc1_decode_frame(AVCodecContext *avctx,
4217
                            void *data, int *data_size,
4218
                            uint8_t *buf, int buf_size)
4219
{
4220
    VC1Context *v = avctx->priv_data;
4221
    MpegEncContext *s = &v->s;
4222
    AVFrame *pict = data;
4223
    uint8_t *buf2 = NULL;
4224

    
4225
    /* no supplementary picture */
4226
    if (buf_size == 0) {
4227
        /* special case for last picture */
4228
        if (s->low_delay==0 && s->next_picture_ptr) {
4229
            *pict= *(AVFrame*)s->next_picture_ptr;
4230
            s->next_picture_ptr= NULL;
4231

    
4232
            *data_size = sizeof(AVFrame);
4233
        }
4234

    
4235
        return 0;
4236
    }
4237

    
4238
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
4239
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
4240
        int i= ff_find_unused_picture(s, 0);
4241
        s->current_picture_ptr= &s->picture[i];
4242
    }
4243

    
4244
    //for advanced profile we need to unescape buffer
4245
    if (avctx->codec_id == CODEC_ID_VC1) {
4246
        int i, buf_size2;
4247
        buf2 = av_malloc(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
4248
        buf_size2 = 0;
4249
        for(i = 0; i < buf_size; i++) {
4250
            if(buf[i] == 3 && i >= 2 && !buf[i-1] && !buf[i-2] && i < buf_size-1 && buf[i+1] < 4) {
4251
                buf2[buf_size2++] = buf[i+1];
4252
                i++;
4253
            } else
4254
                buf2[buf_size2++] = buf[i];
4255
        }
4256
        init_get_bits(&s->gb, buf2, buf_size2*8);
4257
    } else
4258
        init_get_bits(&s->gb, buf, buf_size*8);
4259
    // do parse frame header
4260
    if(v->profile < PROFILE_ADVANCED) {
4261
        if(vc1_parse_frame_header(v, &s->gb) == -1) {
4262
            av_free(buf2);
4263
            return -1;
4264
        }
4265
    } else {
4266
        if(vc1_parse_frame_header_adv(v, &s->gb) == -1) {
4267
            av_free(buf2);
4268
            return -1;
4269
        }
4270
    }
4271

    
4272
    if(s->pict_type != I_TYPE && !v->res_rtm_flag){
4273
        av_free(buf2);
4274
        return -1;
4275
    }
4276

    
4277
    // for hurry_up==5
4278
    s->current_picture.pict_type= s->pict_type;
4279
    s->current_picture.key_frame= s->pict_type == I_TYPE;
4280

    
4281
    /* skip B-frames if we don't have reference frames */
4282
    if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)){
4283
        av_free(buf2);
4284
        return -1;//buf_size;
4285
    }
4286
    /* skip b frames if we are in a hurry */
4287
    if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
4288
    if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
4289
       || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
4290
       ||  avctx->skip_frame >= AVDISCARD_ALL) {
4291
        av_free(buf2);
4292
        return buf_size;
4293
    }
4294
    /* skip everything if we are in a hurry>=5 */
4295
    if(avctx->hurry_up>=5) {
4296
        av_free(buf2);
4297
        return -1;//buf_size;
4298
    }
4299

    
4300
    if(s->next_p_frame_damaged){
4301
        if(s->pict_type==B_TYPE)
4302
            return buf_size;
4303
        else
4304
            s->next_p_frame_damaged=0;
4305
    }
4306

    
4307
    if(MPV_frame_start(s, avctx) < 0) {
4308
        av_free(buf2);
4309
        return -1;
4310
    }
4311

    
4312
    ff_er_frame_start(s);
4313

    
4314
    v->bits = buf_size * 8;
4315
    vc1_decode_blocks(v);
4316
//av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
4317
//  if(get_bits_count(&s->gb) > buf_size * 8)
4318
//      return -1;
4319
    ff_er_frame_end(s);
4320

    
4321
    MPV_frame_end(s);
4322

    
4323
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
4324
assert(s->current_picture.pict_type == s->pict_type);
4325
    if (s->pict_type == B_TYPE || s->low_delay) {
4326
        *pict= *(AVFrame*)s->current_picture_ptr;
4327
    } else if (s->last_picture_ptr != NULL) {
4328
        *pict= *(AVFrame*)s->last_picture_ptr;
4329
    }
4330

    
4331
    if(s->last_picture_ptr || s->low_delay){
4332
        *data_size = sizeof(AVFrame);
4333
        ff_print_debug_info(s, pict);
4334
    }
4335

    
4336
    /* Return the Picture timestamp as the frame number */
4337
    /* we substract 1 because it is added on utils.c    */
4338
    avctx->frame_number = s->picture_number - 1;
4339

    
4340
    av_free(buf2);
4341
    return buf_size;
4342
}
4343

    
4344

    
4345
/** Close a VC1/WMV3 decoder
4346
 * @warning Initial try at using MpegEncContext stuff
4347
 */
4348
static int vc1_decode_end(AVCodecContext *avctx)
4349
{
4350
    VC1Context *v = avctx->priv_data;
4351

    
4352
    av_freep(&v->hrd_rate);
4353
    av_freep(&v->hrd_buffer);
4354
    MPV_common_end(&v->s);
4355
    av_freep(&v->mv_type_mb_plane);
4356
    av_freep(&v->direct_mb_plane);
4357
    av_freep(&v->acpred_plane);
4358
    av_freep(&v->over_flags_plane);
4359
    av_freep(&v->mb_type_base);
4360
    return 0;
4361
}
4362

    
4363

    
4364
AVCodec vc1_decoder = {
4365
    "vc1",
4366
    CODEC_TYPE_VIDEO,
4367
    CODEC_ID_VC1,
4368
    sizeof(VC1Context),
4369
    vc1_decode_init,
4370
    NULL,
4371
    vc1_decode_end,
4372
    vc1_decode_frame,
4373
    CODEC_CAP_DELAY,
4374
    NULL
4375
};
4376

    
4377
AVCodec wmv3_decoder = {
4378
    "wmv3",
4379
    CODEC_TYPE_VIDEO,
4380
    CODEC_ID_WMV3,
4381
    sizeof(VC1Context),
4382
    vc1_decode_init,
4383
    NULL,
4384
    vc1_decode_end,
4385
    vc1_decode_frame,
4386
    CODEC_CAP_DELAY,
4387
    NULL
4388
};