Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vc1.c @ 5cca6bc3

History | View | Annotate | Download (147 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
    v->psf = get_bits1(gb);
1279
    if(v->psf) { //PsF, 6.1.13
1280
        av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
1281
        return -1;
1282
    }
1283
    if(get_bits1(gb)) { //Display Info - decoding is not affected by it
1284
        int w, h, ar = 0;
1285
        av_log(v->s.avctx, AV_LOG_INFO, "Display extended info:\n");
1286
        w = get_bits(gb, 14);
1287
        h = get_bits(gb, 14);
1288
        av_log(v->s.avctx, AV_LOG_INFO, "Display dimensions: %ix%i\n", w, h);
1289
        //TODO: store aspect ratio in AVCodecContext
1290
        if(get_bits1(gb))
1291
            ar = get_bits(gb, 4);
1292
        if(ar == 15) {
1293
            w = get_bits(gb, 8);
1294
            h = get_bits(gb, 8);
1295
        }
1296

    
1297
        if(get_bits1(gb)){ //framerate stuff
1298
            if(get_bits1(gb)) {
1299
                get_bits(gb, 16);
1300
            } else {
1301
                get_bits(gb, 8);
1302
                get_bits(gb, 4);
1303
            }
1304
        }
1305

    
1306
        if(get_bits1(gb)){
1307
            v->color_prim = get_bits(gb, 8);
1308
            v->transfer_char = get_bits(gb, 8);
1309
            v->matrix_coef = get_bits(gb, 8);
1310
        }
1311
    }
1312

    
1313
    v->hrd_param_flag = get_bits1(gb);
1314
    if(v->hrd_param_flag) {
1315
        int i;
1316
        v->hrd_num_leaky_buckets = get_bits(gb, 5);
1317
        get_bits(gb, 4); //bitrate exponent
1318
        get_bits(gb, 4); //buffer size exponent
1319
        for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1320
            get_bits(gb, 16); //hrd_rate[n]
1321
            get_bits(gb, 16); //hrd_buffer[n]
1322
        }
1323
    }
1324
    return 0;
1325
}
1326

    
1327
static int decode_entry_point(AVCodecContext *avctx, GetBitContext *gb)
1328
{
1329
    VC1Context *v = avctx->priv_data;
1330
    int i;
1331

    
1332
    av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
1333
    get_bits1(gb); // broken link
1334
    avctx->max_b_frames = 1 - get_bits1(gb); // 'closed entry' also signalize possible B-frames
1335
    v->panscanflag = get_bits1(gb);
1336
    get_bits1(gb); // refdist flag
1337
    v->s.loop_filter = get_bits1(gb);
1338
    v->fastuvmc = get_bits1(gb);
1339
    v->extended_mv = get_bits1(gb);
1340
    v->dquant = get_bits(gb, 2);
1341
    v->vstransform = get_bits1(gb);
1342
    v->overlap = get_bits1(gb);
1343
    v->quantizer_mode = get_bits(gb, 2);
1344

    
1345
    if(v->hrd_param_flag){
1346
        for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1347
            get_bits(gb, 8); //hrd_full[n]
1348
        }
1349
    }
1350

    
1351
    if(get_bits1(gb)){
1352
        avctx->coded_width = (get_bits(gb, 12)+1)<<1;
1353
        avctx->coded_height = (get_bits(gb, 12)+1)<<1;
1354
    }
1355
    if(v->extended_mv)
1356
        v->extended_dmv = get_bits1(gb);
1357
    if(get_bits1(gb)) {
1358
        av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
1359
        skip_bits(gb, 3); // Y range, ignored for now
1360
    }
1361
    if(get_bits1(gb)) {
1362
        av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
1363
        skip_bits(gb, 3); // UV range, ignored for now
1364
    }
1365

    
1366
    return 0;
1367
}
1368

    
1369
static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1370
{
1371
    int pqindex, lowquant, status;
1372

    
1373
    if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1374
    skip_bits(gb, 2); //framecnt unused
1375
    v->rangeredfrm = 0;
1376
    if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1377
    v->s.pict_type = get_bits(gb, 1);
1378
    if (v->s.avctx->max_b_frames) {
1379
        if (!v->s.pict_type) {
1380
            if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1381
            else v->s.pict_type = B_TYPE;
1382
        } else v->s.pict_type = P_TYPE;
1383
    } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1384

    
1385
    v->bi_type = 0;
1386
    if(v->s.pict_type == B_TYPE) {
1387
        v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1388
        v->bfraction = vc1_bfraction_lut[v->bfraction];
1389
        if(v->bfraction == 0) {
1390
            v->s.pict_type = BI_TYPE;
1391
        }
1392
    }
1393
    if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1394
        get_bits(gb, 7); // skip buffer fullness
1395

    
1396
    /* calculate RND */
1397
    if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1398
        v->rnd = 1;
1399
    if(v->s.pict_type == P_TYPE)
1400
        v->rnd ^= 1;
1401

    
1402
    /* Quantizer stuff */
1403
    pqindex = get_bits(gb, 5);
1404
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1405
        v->pq = pquant_table[0][pqindex];
1406
    else
1407
        v->pq = pquant_table[1][pqindex];
1408

    
1409
    v->pquantizer = 1;
1410
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1411
        v->pquantizer = pqindex < 9;
1412
    if (v->quantizer_mode == QUANT_NON_UNIFORM)
1413
        v->pquantizer = 0;
1414
    v->pqindex = pqindex;
1415
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1416
    else v->halfpq = 0;
1417
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1418
        v->pquantizer = get_bits(gb, 1);
1419
    v->dquantfrm = 0;
1420
    if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1421
    v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1422
    v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1423
    v->range_x = 1 << (v->k_x - 1);
1424
    v->range_y = 1 << (v->k_y - 1);
1425
    if (v->profile == PROFILE_ADVANCED)
1426
    {
1427
        if (v->postprocflag) v->postproc = get_bits(gb, 1);
1428
    }
1429
    else
1430
        if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1431

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

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

    
1437
    switch(v->s.pict_type) {
1438
    case P_TYPE:
1439
        if (v->pq < 5) v->tt_index = 0;
1440
        else if(v->pq < 13) v->tt_index = 1;
1441
        else v->tt_index = 2;
1442

    
1443
        lowquant = (v->pq > 12) ? 0 : 1;
1444
        v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1445
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1446
        {
1447
            int scale, shift, i;
1448
            v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1449
            v->lumscale = get_bits(gb, 6);
1450
            v->lumshift = get_bits(gb, 6);
1451
            v->use_ic = 1;
1452
            /* fill lookup tables for intensity compensation */
1453
            if(!v->lumscale) {
1454
                scale = -64;
1455
                shift = (255 - v->lumshift * 2) << 6;
1456
                if(v->lumshift > 31)
1457
                    shift += 128 << 6;
1458
            } else {
1459
                scale = v->lumscale + 32;
1460
                if(v->lumshift > 31)
1461
                    shift = (v->lumshift - 64) << 6;
1462
                else
1463
                    shift = v->lumshift << 6;
1464
            }
1465
            for(i = 0; i < 256; i++) {
1466
                v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1467
                v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1468
            }
1469
        }
1470
        if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1471
            v->s.quarter_sample = 0;
1472
        else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1473
            if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1474
                v->s.quarter_sample = 0;
1475
            else
1476
                v->s.quarter_sample = 1;
1477
        } else
1478
            v->s.quarter_sample = 1;
1479
        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));
1480

    
1481
        if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1482
                 v->mv_mode2 == MV_PMODE_MIXED_MV)
1483
                || v->mv_mode == MV_PMODE_MIXED_MV)
1484
        {
1485
            status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1486
            if (status < 0) return -1;
1487
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1488
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1489
        } else {
1490
            v->mv_type_is_raw = 0;
1491
            memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1492
        }
1493
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1494
        if (status < 0) return -1;
1495
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1496
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1497

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

    
1502
        if (v->dquant)
1503
        {
1504
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1505
            vop_dquant_decoding(v);
1506
        }
1507

    
1508
        v->ttfrm = 0; //FIXME Is that so ?
1509
        if (v->vstransform)
1510
        {
1511
            v->ttmbf = get_bits(gb, 1);
1512
            if (v->ttmbf)
1513
            {
1514
                v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1515
            }
1516
        } else {
1517
            v->ttmbf = 1;
1518
            v->ttfrm = TT_8X8;
1519
        }
1520
        break;
1521
    case B_TYPE:
1522
        if (v->pq < 5) v->tt_index = 0;
1523
        else if(v->pq < 13) v->tt_index = 1;
1524
        else v->tt_index = 2;
1525

    
1526
        lowquant = (v->pq > 12) ? 0 : 1;
1527
        v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1528
        v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1529
        v->s.mspel = v->s.quarter_sample;
1530

    
1531
        status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1532
        if (status < 0) return -1;
1533
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1534
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1535
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1536
        if (status < 0) return -1;
1537
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1538
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1539

    
1540
        v->s.mv_table_index = get_bits(gb, 2);
1541
        v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1542

    
1543
        if (v->dquant)
1544
        {
1545
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1546
            vop_dquant_decoding(v);
1547
        }
1548

    
1549
        v->ttfrm = 0;
1550
        if (v->vstransform)
1551
        {
1552
            v->ttmbf = get_bits(gb, 1);
1553
            if (v->ttmbf)
1554
            {
1555
                v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1556
            }
1557
        } else {
1558
            v->ttmbf = 1;
1559
            v->ttfrm = TT_8X8;
1560
        }
1561
        break;
1562
    }
1563

    
1564
    /* AC Syntax */
1565
    v->c_ac_table_index = decode012(gb);
1566
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1567
    {
1568
        v->y_ac_table_index = decode012(gb);
1569
    }
1570
    /* DC Syntax */
1571
    v->s.dc_table_index = get_bits(gb, 1);
1572

    
1573
    if(v->s.pict_type == BI_TYPE) {
1574
        v->s.pict_type = B_TYPE;
1575
        v->bi_type = 1;
1576
    }
1577
    return 0;
1578
}
1579

    
1580
static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
1581
{
1582
    int fcm;
1583
    int pqindex, lowquant;
1584
    int status;
1585

    
1586
    v->p_frame_skipped = 0;
1587

    
1588
    if(v->interlace)
1589
        fcm = decode012(gb);
1590
    switch(get_prefix(gb, 0, 4)) {
1591
    case 0:
1592
        v->s.pict_type = P_TYPE;
1593
        break;
1594
    case 1:
1595
        v->s.pict_type = B_TYPE;
1596
        break;
1597
    case 2:
1598
        v->s.pict_type = I_TYPE;
1599
        break;
1600
    case 3:
1601
        v->s.pict_type = BI_TYPE;
1602
        break;
1603
    case 4:
1604
        v->s.pict_type = P_TYPE; // skipped pic
1605
        v->p_frame_skipped = 1;
1606
        return 0;
1607
    }
1608
    if(v->tfcntrflag)
1609
        get_bits(gb, 8);
1610
    if(v->broadcast) {
1611
        if(!v->interlace || v->panscanflag) {
1612
            get_bits(gb, 2);
1613
        } else {
1614
            get_bits1(gb);
1615
            get_bits1(gb);
1616
        }
1617
    }
1618
    if(v->panscanflag) {
1619
        //...
1620
    }
1621
    v->rnd = get_bits1(gb);
1622
    if(v->interlace)
1623
        v->uvsamp = get_bits1(gb);
1624
    if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1625
    if(v->s.pict_type == B_TYPE) {
1626
        v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1627
        v->bfraction = vc1_bfraction_lut[v->bfraction];
1628
        if(v->bfraction == 0) {
1629
            v->s.pict_type = BI_TYPE; /* XXX: should not happen here */
1630
        }
1631
    }
1632
    pqindex = get_bits(gb, 5);
1633
    v->pqindex = pqindex;
1634
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1635
        v->pq = pquant_table[0][pqindex];
1636
    else
1637
        v->pq = pquant_table[1][pqindex];
1638

    
1639
    v->pquantizer = 1;
1640
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1641
        v->pquantizer = pqindex < 9;
1642
    if (v->quantizer_mode == QUANT_NON_UNIFORM)
1643
        v->pquantizer = 0;
1644
    v->pqindex = pqindex;
1645
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1646
    else v->halfpq = 0;
1647
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1648
        v->pquantizer = get_bits(gb, 1);
1649

    
1650
    switch(v->s.pict_type) {
1651
    case I_TYPE:
1652
    case BI_TYPE:
1653
        status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1654
        if (status < 0) return -1;
1655
        av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1656
                "Imode: %i, Invert: %i\n", status>>1, status&1);
1657
        v->condover = CONDOVER_NONE;
1658
        if(v->overlap && v->pq <= 8) {
1659
            v->condover = decode012(gb);
1660
            if(v->condover == CONDOVER_SELECT) {
1661
                status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1662
                if (status < 0) return -1;
1663
                av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1664
                        "Imode: %i, Invert: %i\n", status>>1, status&1);
1665
            }
1666
        }
1667
        break;
1668
    case P_TYPE:
1669
        if(v->postprocflag)
1670
            v->postproc = get_bits1(gb);
1671
        if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1672
        else v->mvrange = 0;
1673
        v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1674
        v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1675
        v->range_x = 1 << (v->k_x - 1);
1676
        v->range_y = 1 << (v->k_y - 1);
1677

    
1678
        if (v->pq < 5) v->tt_index = 0;
1679
        else if(v->pq < 13) v->tt_index = 1;
1680
        else v->tt_index = 2;
1681

    
1682
        lowquant = (v->pq > 12) ? 0 : 1;
1683
        v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1684
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1685
        {
1686
            int scale, shift, i;
1687
            v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1688
            v->lumscale = get_bits(gb, 6);
1689
            v->lumshift = get_bits(gb, 6);
1690
            /* fill lookup tables for intensity compensation */
1691
            if(!v->lumscale) {
1692
                scale = -64;
1693
                shift = (255 - v->lumshift * 2) << 6;
1694
                if(v->lumshift > 31)
1695
                    shift += 128 << 6;
1696
            } else {
1697
                scale = v->lumscale + 32;
1698
                if(v->lumshift > 31)
1699
                    shift = (v->lumshift - 64) << 6;
1700
                else
1701
                    shift = v->lumshift << 6;
1702
            }
1703
            for(i = 0; i < 256; i++) {
1704
                v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1705
                v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1706
            }
1707
        }
1708
        if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1709
            v->s.quarter_sample = 0;
1710
        else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1711
            if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1712
                v->s.quarter_sample = 0;
1713
            else
1714
                v->s.quarter_sample = 1;
1715
        } else
1716
            v->s.quarter_sample = 1;
1717
        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));
1718

    
1719
        if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1720
                 v->mv_mode2 == MV_PMODE_MIXED_MV)
1721
                || v->mv_mode == MV_PMODE_MIXED_MV)
1722
        {
1723
            status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1724
            if (status < 0) return -1;
1725
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1726
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1727
        } else {
1728
            v->mv_type_is_raw = 0;
1729
            memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1730
        }
1731
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1732
        if (status < 0) return -1;
1733
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1734
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1735

    
1736
        /* Hopefully this is correct for P frames */
1737
        v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1738
        v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1739
        if (v->dquant)
1740
        {
1741
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1742
            vop_dquant_decoding(v);
1743
        }
1744

    
1745
        v->ttfrm = 0; //FIXME Is that so ?
1746
        if (v->vstransform)
1747
        {
1748
            v->ttmbf = get_bits(gb, 1);
1749
            if (v->ttmbf)
1750
            {
1751
                v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1752
            }
1753
        } else {
1754
            v->ttmbf = 1;
1755
            v->ttfrm = TT_8X8;
1756
        }
1757
        break;
1758
    case B_TYPE:
1759
        if(v->postprocflag)
1760
            v->postproc = get_bits1(gb);
1761
        if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1762
        else v->mvrange = 0;
1763
        v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1764
        v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1765
        v->range_x = 1 << (v->k_x - 1);
1766
        v->range_y = 1 << (v->k_y - 1);
1767

    
1768
        if (v->pq < 5) v->tt_index = 0;
1769
        else if(v->pq < 13) v->tt_index = 1;
1770
        else v->tt_index = 2;
1771

    
1772
        lowquant = (v->pq > 12) ? 0 : 1;
1773
        v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1774
        v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1775
        v->s.mspel = v->s.quarter_sample;
1776

    
1777
        status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1778
        if (status < 0) return -1;
1779
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1780
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1781
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1782
        if (status < 0) return -1;
1783
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1784
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1785

    
1786
        v->s.mv_table_index = get_bits(gb, 2);
1787
        v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1788

    
1789
        if (v->dquant)
1790
        {
1791
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1792
            vop_dquant_decoding(v);
1793
        }
1794

    
1795
        v->ttfrm = 0;
1796
        if (v->vstransform)
1797
        {
1798
            v->ttmbf = get_bits(gb, 1);
1799
            if (v->ttmbf)
1800
            {
1801
                v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1802
            }
1803
        } else {
1804
            v->ttmbf = 1;
1805
            v->ttfrm = TT_8X8;
1806
        }
1807
        break;
1808
    }
1809

    
1810
    /* AC Syntax */
1811
    v->c_ac_table_index = decode012(gb);
1812
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1813
    {
1814
        v->y_ac_table_index = decode012(gb);
1815
    }
1816
    /* DC Syntax */
1817
    v->s.dc_table_index = get_bits(gb, 1);
1818
    if (v->s.pict_type == I_TYPE && v->dquant) {
1819
        av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1820
        vop_dquant_decoding(v);
1821
    }
1822

    
1823
    v->bi_type = 0;
1824
    if(v->s.pict_type == BI_TYPE) {
1825
        v->s.pict_type = B_TYPE;
1826
        v->bi_type = 1;
1827
    }
1828
    return 0;
1829
}
1830

    
1831
/***********************************************************************/
1832
/**
1833
 * @defgroup block VC-1 Block-level functions
1834
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1835
 * @{
1836
 */
1837

    
1838
/**
1839
 * @def GET_MQUANT
1840
 * @brief Get macroblock-level quantizer scale
1841
 */
1842
#define GET_MQUANT()                                           \
1843
  if (v->dquantfrm)                                            \
1844
  {                                                            \
1845
    int edges = 0;                                             \
1846
    if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1847
    {                                                          \
1848
      if (v->dqbilevel)                                        \
1849
      {                                                        \
1850
        mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
1851
      }                                                        \
1852
      else                                                     \
1853
      {                                                        \
1854
        mqdiff = get_bits(gb, 3);                              \
1855
        if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1856
        else mquant = get_bits(gb, 5);                         \
1857
      }                                                        \
1858
    }                                                          \
1859
    if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
1860
        edges = 1 << v->dqsbedge;                              \
1861
    else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1862
        edges = (3 << v->dqsbedge) % 15;                       \
1863
    else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1864
        edges = 15;                                            \
1865
    if((edges&1) && !s->mb_x)                                  \
1866
        mquant = v->altpq;                                     \
1867
    if((edges&2) && s->first_slice_line)                       \
1868
        mquant = v->altpq;                                     \
1869
    if((edges&4) && s->mb_x == (s->mb_width - 1))              \
1870
        mquant = v->altpq;                                     \
1871
    if((edges&8) && s->mb_y == (s->mb_height - 1))             \
1872
        mquant = v->altpq;                                     \
1873
  }
1874

    
1875
/**
1876
 * @def GET_MVDATA(_dmv_x, _dmv_y)
1877
 * @brief Get MV differentials
1878
 * @see MVDATA decoding from 8.3.5.2, p(1)20
1879
 * @param _dmv_x Horizontal differential for decoded MV
1880
 * @param _dmv_y Vertical differential for decoded MV
1881
 */
1882
#define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1883
  index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1884
                       VC1_MV_DIFF_VLC_BITS, 2);                    \
1885
  if (index > 36)                                                   \
1886
  {                                                                 \
1887
    mb_has_coeffs = 1;                                              \
1888
    index -= 37;                                                    \
1889
  }                                                                 \
1890
  else mb_has_coeffs = 0;                                           \
1891
  s->mb_intra = 0;                                                  \
1892
  if (!index) { _dmv_x = _dmv_y = 0; }                              \
1893
  else if (index == 35)                                             \
1894
  {                                                                 \
1895
    _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1896
    _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1897
  }                                                                 \
1898
  else if (index == 36)                                             \
1899
  {                                                                 \
1900
    _dmv_x = 0;                                                     \
1901
    _dmv_y = 0;                                                     \
1902
    s->mb_intra = 1;                                                \
1903
  }                                                                 \
1904
  else                                                              \
1905
  {                                                                 \
1906
    index1 = index%6;                                               \
1907
    if (!s->quarter_sample && index1 == 5) val = 1;                 \
1908
    else                                   val = 0;                 \
1909
    if(size_table[index1] - val > 0)                                \
1910
        val = get_bits(gb, size_table[index1] - val);               \
1911
    else                                   val = 0;                 \
1912
    sign = 0 - (val&1);                                             \
1913
    _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1914
                                                                    \
1915
    index1 = index/6;                                               \
1916
    if (!s->quarter_sample && index1 == 5) val = 1;                 \
1917
    else                                   val = 0;                 \
1918
    if(size_table[index1] - val > 0)                                \
1919
        val = get_bits(gb, size_table[index1] - val);               \
1920
    else                                   val = 0;                 \
1921
    sign = 0 - (val&1);                                             \
1922
    _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1923
  }
1924

    
1925
/** Predict and set motion vector
1926
 */
1927
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)
1928
{
1929
    int xy, wrap, off = 0;
1930
    int16_t *A, *B, *C;
1931
    int px, py;
1932
    int sum;
1933

    
1934
    /* scale MV difference to be quad-pel */
1935
    dmv_x <<= 1 - s->quarter_sample;
1936
    dmv_y <<= 1 - s->quarter_sample;
1937

    
1938
    wrap = s->b8_stride;
1939
    xy = s->block_index[n];
1940

    
1941
    if(s->mb_intra){
1942
        s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1943
        s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1944
        if(mv1) { /* duplicate motion data for 1-MV block */
1945
            s->current_picture.motion_val[0][xy + 1][0] = 0;
1946
            s->current_picture.motion_val[0][xy + 1][1] = 0;
1947
            s->current_picture.motion_val[0][xy + wrap][0] = 0;
1948
            s->current_picture.motion_val[0][xy + wrap][1] = 0;
1949
            s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1950
            s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1951
        }
1952
        return;
1953
    }
1954

    
1955
    C = s->current_picture.motion_val[0][xy - 1];
1956
    A = s->current_picture.motion_val[0][xy - wrap];
1957
    if(mv1)
1958
        off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1959
    else {
1960
        //in 4-MV mode different blocks have different B predictor position
1961
        switch(n){
1962
        case 0:
1963
            off = (s->mb_x > 0) ? -1 : 1;
1964
            break;
1965
        case 1:
1966
            off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1967
            break;
1968
        case 2:
1969
            off = 1;
1970
            break;
1971
        case 3:
1972
            off = -1;
1973
        }
1974
    }
1975
    B = s->current_picture.motion_val[0][xy - wrap + off];
1976

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

    
2051
/** Motion compensation for direct or interpolated blocks in B-frames
2052
 */
2053
static void vc1_interp_mc(VC1Context *v)
2054
{
2055
    MpegEncContext *s = &v->s;
2056
    DSPContext *dsp = &v->s.dsp;
2057
    uint8_t *srcY, *srcU, *srcV;
2058
    int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
2059

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

    
2062
    mx = s->mv[1][0][0];
2063
    my = s->mv[1][0][1];
2064
    uvmx = (mx + ((mx & 3) == 3)) >> 1;
2065
    uvmy = (my + ((my & 3) == 3)) >> 1;
2066
    if(v->fastuvmc) {
2067
        uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
2068
        uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
2069
    }
2070
    srcY = s->next_picture.data[0];
2071
    srcU = s->next_picture.data[1];
2072
    srcV = s->next_picture.data[2];
2073

    
2074
    src_x = s->mb_x * 16 + (mx >> 2);
2075
    src_y = s->mb_y * 16 + (my >> 2);
2076
    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
2077
    uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
2078

    
2079
    src_x   = clip(  src_x, -16, s->mb_width  * 16);
2080
    src_y   = clip(  src_y, -16, s->mb_height * 16);
2081
    uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
2082
    uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
2083

    
2084
    srcY += src_y * s->linesize + src_x;
2085
    srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
2086
    srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
2087

    
2088
    /* for grayscale we should not try to read from unknown area */
2089
    if(s->flags & CODEC_FLAG_GRAY) {
2090
        srcU = s->edge_emu_buffer + 18 * s->linesize;
2091
        srcV = s->edge_emu_buffer + 18 * s->linesize;
2092
    }
2093

    
2094
    if(v->rangeredfrm
2095
       || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
2096
       || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
2097
        uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
2098

    
2099
        srcY -= s->mspel * (1 + s->linesize);
2100
        ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
2101
                            src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
2102
        srcY = s->edge_emu_buffer;
2103
        ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
2104
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2105
        ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
2106
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2107
        srcU = uvbuf;
2108
        srcV = uvbuf + 16;
2109
        /* if we deal with range reduction we need to scale source blocks */
2110
        if(v->rangeredfrm) {
2111
            int i, j;
2112
            uint8_t *src, *src2;
2113

    
2114
            src = srcY;
2115
            for(j = 0; j < 17 + s->mspel*2; j++) {
2116
                for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
2117
                src += s->linesize;
2118
            }
2119
            src = srcU; src2 = srcV;
2120
            for(j = 0; j < 9; j++) {
2121
                for(i = 0; i < 9; i++) {
2122
                    src[i] = ((src[i] - 128) >> 1) + 128;
2123
                    src2[i] = ((src2[i] - 128) >> 1) + 128;
2124
                }
2125
                src += s->uvlinesize;
2126
                src2 += s->uvlinesize;
2127
            }
2128
        }
2129
        srcY += s->mspel * (1 + s->linesize);
2130
    }
2131

    
2132
    mx >>= 1;
2133
    my >>= 1;
2134
    dxy = ((my & 1) << 1) | (mx & 1);
2135

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

    
2138
    if(s->flags & CODEC_FLAG_GRAY) return;
2139
    /* Chroma MC always uses qpel blilinear */
2140
    uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
2141
    uvmx = (uvmx&3)<<1;
2142
    uvmy = (uvmy&3)<<1;
2143
    dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
2144
    dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
2145
}
2146

    
2147
static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2148
{
2149
    int n = bfrac;
2150

    
2151
#if B_FRACTION_DEN==256
2152
    if(inv)
2153
        n -= 256;
2154
    if(!qs)
2155
        return 2 * ((value * n + 255) >> 9);
2156
    return (value * n + 128) >> 8;
2157
#else
2158
    if(inv)
2159
        n -= B_FRACTION_DEN;
2160
    if(!qs)
2161
        return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2162
    return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2163
#endif
2164
}
2165

    
2166
/** Reconstruct motion vector for B-frame and do motion compensation
2167
 */
2168
static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
2169
{
2170
    if(v->use_ic) {
2171
        v->mv_mode2 = v->mv_mode;
2172
        v->mv_mode = MV_PMODE_INTENSITY_COMP;
2173
    }
2174
    if(direct) {
2175
        vc1_mc_1mv(v, 0);
2176
        vc1_interp_mc(v);
2177
        if(v->use_ic) v->mv_mode = v->mv_mode2;
2178
        return;
2179
    }
2180
    if(mode == BMV_TYPE_INTERPOLATED) {
2181
        vc1_mc_1mv(v, 0);
2182
        vc1_interp_mc(v);
2183
        if(v->use_ic) v->mv_mode = v->mv_mode2;
2184
        return;
2185
    }
2186

    
2187
    if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
2188
    vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2189
    if(v->use_ic) v->mv_mode = v->mv_mode2;
2190
}
2191

    
2192
static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
2193
{
2194
    MpegEncContext *s = &v->s;
2195
    int xy, wrap, off = 0;
2196
    int16_t *A, *B, *C;
2197
    int px, py;
2198
    int sum;
2199
    int r_x, r_y;
2200
    const uint8_t *is_intra = v->mb_type[0];
2201

    
2202
    r_x = v->range_x;
2203
    r_y = v->range_y;
2204
    /* scale MV difference to be quad-pel */
2205
    dmv_x[0] <<= 1 - s->quarter_sample;
2206
    dmv_y[0] <<= 1 - s->quarter_sample;
2207
    dmv_x[1] <<= 1 - s->quarter_sample;
2208
    dmv_y[1] <<= 1 - s->quarter_sample;
2209

    
2210
    wrap = s->b8_stride;
2211
    xy = s->block_index[0];
2212

    
2213
    if(s->mb_intra) {
2214
        s->current_picture.motion_val[0][xy][0] =
2215
        s->current_picture.motion_val[0][xy][1] =
2216
        s->current_picture.motion_val[1][xy][0] =
2217
        s->current_picture.motion_val[1][xy][1] = 0;
2218
        return;
2219
    }
2220
    s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2221
    s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2222
    s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2223
    s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2224
    if(direct) {
2225
        s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2226
        s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2227
        s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2228
        s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2229
        return;
2230
    }
2231

    
2232
    if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2233
        C = s->current_picture.motion_val[0][xy - 2];
2234
        A = s->current_picture.motion_val[0][xy - wrap*2];
2235
        off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2236
        B = s->current_picture.motion_val[0][xy - wrap*2 + off];
2237

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

    
2315
        if(!s->first_slice_line) { // predictor A is not out of bounds
2316
            if(s->mb_width == 1) {
2317
                px = A[0];
2318
                py = A[1];
2319
            } else {
2320
                px = mid_pred(A[0], B[0], C[0]);
2321
                py = mid_pred(A[1], B[1], C[1]);
2322
            }
2323
        } else if(s->mb_x) { // predictor C is not out of bounds
2324
            px = C[0];
2325
            py = C[1];
2326
        } else {
2327
            px = py = 0;
2328
        }
2329
        /* Pullback MV as specified in 8.3.5.3.4 */
2330
        {
2331
            int qx, qy, X, Y;
2332
            if(v->profile < PROFILE_ADVANCED) {
2333
                qx = (s->mb_x << 5);
2334
                qy = (s->mb_y << 5);
2335
                X = (s->mb_width << 5) - 4;
2336
                Y = (s->mb_height << 5) - 4;
2337
                if(qx + px < -28) px = -28 - qx;
2338
                if(qy + py < -28) py = -28 - qy;
2339
                if(qx + px > X) px = X - qx;
2340
                if(qy + py > Y) py = Y - qy;
2341
            } else {
2342
                qx = (s->mb_x << 6);
2343
                qy = (s->mb_y << 6);
2344
                X = (s->mb_width << 6) - 4;
2345
                Y = (s->mb_height << 6) - 4;
2346
                if(qx + px < -60) px = -60 - qx;
2347
                if(qy + py < -60) py = -60 - qy;
2348
                if(qx + px > X) px = X - qx;
2349
                if(qy + py > Y) py = Y - qy;
2350
            }
2351
        }
2352
        /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2353
        if(0 && !s->first_slice_line && s->mb_x) {
2354
            if(is_intra[xy - wrap])
2355
                sum = FFABS(px) + FFABS(py);
2356
            else
2357
                sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2358
            if(sum > 32) {
2359
                if(get_bits1(&s->gb)) {
2360
                    px = A[0];
2361
                    py = A[1];
2362
                } else {
2363
                    px = C[0];
2364
                    py = C[1];
2365
                }
2366
            } else {
2367
                if(is_intra[xy - 2])
2368
                    sum = FFABS(px) + FFABS(py);
2369
                else
2370
                    sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2371
                if(sum > 32) {
2372
                    if(get_bits1(&s->gb)) {
2373
                        px = A[0];
2374
                        py = A[1];
2375
                    } else {
2376
                        px = C[0];
2377
                        py = C[1];
2378
                    }
2379
                }
2380
            }
2381
        }
2382
        /* store MV using signed modulus of MV range defined in 4.11 */
2383

    
2384
        s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2385
        s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2386
    }
2387
    s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2388
    s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2389
    s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2390
    s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2391
}
2392

    
2393
/** Get predicted DC value for I-frames only
2394
 * prediction dir: left=0, top=1
2395
 * @param s MpegEncContext
2396
 * @param[in] n block index in the current MB
2397
 * @param dc_val_ptr Pointer to DC predictor
2398
 * @param dir_ptr Prediction direction for use in AC prediction
2399
 */
2400
static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2401
                              int16_t **dc_val_ptr, int *dir_ptr)
2402
{
2403
    int a, b, c, wrap, pred, scale;
2404
    int16_t *dc_val;
2405
    static const uint16_t dcpred[32] = {
2406
    -1, 1024,  512,  341,  256,  205,  171,  146,  128,
2407
         114,  102,   93,   85,   79,   73,   68,   64,
2408
          60,   57,   54,   51,   49,   47,   45,   43,
2409
          41,   39,   38,   37,   35,   34,   33
2410
    };
2411

    
2412
    /* find prediction - wmv3_dc_scale always used here in fact */
2413
    if (n < 4)     scale = s->y_dc_scale;
2414
    else           scale = s->c_dc_scale;
2415

    
2416
    wrap = s->block_wrap[n];
2417
    dc_val= s->dc_val[0] + s->block_index[n];
2418

    
2419
    /* B A
2420
     * C X
2421
     */
2422
    c = dc_val[ - 1];
2423
    b = dc_val[ - 1 - wrap];
2424
    a = dc_val[ - wrap];
2425

    
2426
    if (pq < 9 || !overlap)
2427
    {
2428
        /* Set outer values */
2429
        if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
2430
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
2431
    }
2432
    else
2433
    {
2434
        /* Set outer values */
2435
        if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
2436
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
2437
    }
2438

    
2439
    if (abs(a - b) <= abs(b - c)) {
2440
        pred = c;
2441
        *dir_ptr = 1;//left
2442
    } else {
2443
        pred = a;
2444
        *dir_ptr = 0;//top
2445
    }
2446

    
2447
    /* update predictor */
2448
    *dc_val_ptr = &dc_val[0];
2449
    return pred;
2450
}
2451

    
2452

    
2453
/** Get predicted DC value
2454
 * prediction dir: left=0, top=1
2455
 * @param s MpegEncContext
2456
 * @param[in] n block index in the current MB
2457
 * @param dc_val_ptr Pointer to DC predictor
2458
 * @param dir_ptr Prediction direction for use in AC prediction
2459
 */
2460
static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2461
                              int a_avail, int c_avail,
2462
                              int16_t **dc_val_ptr, int *dir_ptr)
2463
{
2464
    int a, b, c, wrap, pred, scale;
2465
    int16_t *dc_val;
2466
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2467
    int q1, q2 = 0;
2468

    
2469
    /* find prediction - wmv3_dc_scale always used here in fact */
2470
    if (n < 4)     scale = s->y_dc_scale;
2471
    else           scale = s->c_dc_scale;
2472

    
2473
    wrap = s->block_wrap[n];
2474
    dc_val= s->dc_val[0] + s->block_index[n];
2475

    
2476
    /* B A
2477
     * C X
2478
     */
2479
    c = dc_val[ - 1];
2480
    b = dc_val[ - 1 - wrap];
2481
    a = dc_val[ - wrap];
2482
    /* scale predictors if needed */
2483
    q1 = s->current_picture.qscale_table[mb_pos];
2484
    if(c_avail && (n!= 1 && n!=3)) {
2485
        q2 = s->current_picture.qscale_table[mb_pos - 1];
2486
        if(q2 && q2 != q1)
2487
            c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2488
    }
2489
    if(a_avail && (n!= 2 && n!=3)) {
2490
        q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2491
        if(q2 && q2 != q1)
2492
            a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2493
    }
2494
    if(a_avail && c_avail && (n!=3)) {
2495
        int off = mb_pos;
2496
        if(n != 1) off--;
2497
        if(n != 2) off -= s->mb_stride;
2498
        q2 = s->current_picture.qscale_table[off];
2499
        if(q2 && q2 != q1)
2500
            b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2501
    }
2502

    
2503
    if(a_avail && c_avail) {
2504
        if(abs(a - b) <= abs(b - c)) {
2505
            pred = c;
2506
            *dir_ptr = 1;//left
2507
        } else {
2508
            pred = a;
2509
            *dir_ptr = 0;//top
2510
        }
2511
    } else if(a_avail) {
2512
        pred = a;
2513
        *dir_ptr = 0;//top
2514
    } else if(c_avail) {
2515
        pred = c;
2516
        *dir_ptr = 1;//left
2517
    } else {
2518
        pred = 0;
2519
        *dir_ptr = 1;//left
2520
    }
2521

    
2522
    /* update predictor */
2523
    *dc_val_ptr = &dc_val[0];
2524
    return pred;
2525
}
2526

    
2527

    
2528
/**
2529
 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2530
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2531
 * @{
2532
 */
2533

    
2534
static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
2535
{
2536
    int xy, wrap, pred, a, b, c;
2537

    
2538
    xy = s->block_index[n];
2539
    wrap = s->b8_stride;
2540

    
2541
    /* B C
2542
     * A X
2543
     */
2544
    a = s->coded_block[xy - 1       ];
2545
    b = s->coded_block[xy - 1 - wrap];
2546
    c = s->coded_block[xy     - wrap];
2547

    
2548
    if (b == c) {
2549
        pred = a;
2550
    } else {
2551
        pred = c;
2552
    }
2553

    
2554
    /* store value */
2555
    *coded_block_ptr = &s->coded_block[xy];
2556

    
2557
    return pred;
2558
}
2559

    
2560
/**
2561
 * Decode one AC coefficient
2562
 * @param v The VC1 context
2563
 * @param last Last coefficient
2564
 * @param skip How much zero coefficients to skip
2565
 * @param value Decoded AC coefficient value
2566
 * @see 8.1.3.4
2567
 */
2568
static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
2569
{
2570
    GetBitContext *gb = &v->s.gb;
2571
    int index, escape, run = 0, level = 0, lst = 0;
2572

    
2573
    index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2574
    if (index != vc1_ac_sizes[codingset] - 1) {
2575
        run = vc1_index_decode_table[codingset][index][0];
2576
        level = vc1_index_decode_table[codingset][index][1];
2577
        lst = index >= vc1_last_decode_table[codingset];
2578
        if(get_bits(gb, 1))
2579
            level = -level;
2580
    } else {
2581
        escape = decode210(gb);
2582
        if (escape != 2) {
2583
            index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2584
            run = vc1_index_decode_table[codingset][index][0];
2585
            level = vc1_index_decode_table[codingset][index][1];
2586
            lst = index >= vc1_last_decode_table[codingset];
2587
            if(escape == 0) {
2588
                if(lst)
2589
                    level += vc1_last_delta_level_table[codingset][run];
2590
                else
2591
                    level += vc1_delta_level_table[codingset][run];
2592
            } else {
2593
                if(lst)
2594
                    run += vc1_last_delta_run_table[codingset][level] + 1;
2595
                else
2596
                    run += vc1_delta_run_table[codingset][level] + 1;
2597
            }
2598
            if(get_bits(gb, 1))
2599
                level = -level;
2600
        } else {
2601
            int sign;
2602
            lst = get_bits(gb, 1);
2603
            if(v->s.esc3_level_length == 0) {
2604
                if(v->pq < 8 || v->dquantfrm) { // table 59
2605
                    v->s.esc3_level_length = get_bits(gb, 3);
2606
                    if(!v->s.esc3_level_length)
2607
                        v->s.esc3_level_length = get_bits(gb, 2) + 8;
2608
                } else { //table 60
2609
                    v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
2610
                }
2611
                v->s.esc3_run_length = 3 + get_bits(gb, 2);
2612
            }
2613
            run = get_bits(gb, v->s.esc3_run_length);
2614
            sign = get_bits(gb, 1);
2615
            level = get_bits(gb, v->s.esc3_level_length);
2616
            if(sign)
2617
                level = -level;
2618
        }
2619
    }
2620

    
2621
    *last = lst;
2622
    *skip = run;
2623
    *value = level;
2624
}
2625

    
2626
/** Decode intra block in intra frames - should be faster than decode_intra_block
2627
 * @param v VC1Context
2628
 * @param block block to decode
2629
 * @param coded are AC coeffs present or not
2630
 * @param codingset set of VLC to decode data
2631
 */
2632
static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
2633
{
2634
    GetBitContext *gb = &v->s.gb;
2635
    MpegEncContext *s = &v->s;
2636
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
2637
    int run_diff, i;
2638
    int16_t *dc_val;
2639
    int16_t *ac_val, *ac_val2;
2640
    int dcdiff;
2641

    
2642
    /* Get DC differential */
2643
    if (n < 4) {
2644
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2645
    } else {
2646
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2647
    }
2648
    if (dcdiff < 0){
2649
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2650
        return -1;
2651
    }
2652
    if (dcdiff)
2653
    {
2654
        if (dcdiff == 119 /* ESC index value */)
2655
        {
2656
            /* TODO: Optimize */
2657
            if (v->pq == 1) dcdiff = get_bits(gb, 10);
2658
            else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2659
            else dcdiff = get_bits(gb, 8);
2660
        }
2661
        else
2662
        {
2663
            if (v->pq == 1)
2664
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2665
            else if (v->pq == 2)
2666
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2667
        }
2668
        if (get_bits(gb, 1))
2669
            dcdiff = -dcdiff;
2670
    }
2671

    
2672
    /* Prediction */
2673
    dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2674
    *dc_val = dcdiff;
2675

    
2676
    /* Store the quantized DC coeff, used for prediction */
2677
    if (n < 4) {
2678
        block[0] = dcdiff * s->y_dc_scale;
2679
    } else {
2680
        block[0] = dcdiff * s->c_dc_scale;
2681
    }
2682
    /* Skip ? */
2683
    run_diff = 0;
2684
    i = 0;
2685
    if (!coded) {
2686
        goto not_coded;
2687
    }
2688

    
2689
    //AC Decoding
2690
    i = 1;
2691

    
2692
    {
2693
        int last = 0, skip, value;
2694
        const int8_t *zz_table;
2695
        int scale;
2696
        int k;
2697

    
2698
        scale = v->pq * 2 + v->halfpq;
2699

    
2700
        if(v->s.ac_pred) {
2701
            if(!dc_pred_dir)
2702
                zz_table = vc1_horizontal_zz;
2703
            else
2704
                zz_table = vc1_vertical_zz;
2705
        } else
2706
            zz_table = vc1_normal_zz;
2707

    
2708
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2709
        ac_val2 = ac_val;
2710
        if(dc_pred_dir) //left
2711
            ac_val -= 16;
2712
        else //top
2713
            ac_val -= 16 * s->block_wrap[n];
2714

    
2715
        while (!last) {
2716
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2717
            i += skip;
2718
            if(i > 63)
2719
                break;
2720
            block[zz_table[i++]] = value;
2721
        }
2722

    
2723
        /* apply AC prediction if needed */
2724
        if(s->ac_pred) {
2725
            if(dc_pred_dir) { //left
2726
                for(k = 1; k < 8; k++)
2727
                    block[k << 3] += ac_val[k];
2728
            } else { //top
2729
                for(k = 1; k < 8; k++)
2730
                    block[k] += ac_val[k + 8];
2731
            }
2732
        }
2733
        /* save AC coeffs for further prediction */
2734
        for(k = 1; k < 8; k++) {
2735
            ac_val2[k] = block[k << 3];
2736
            ac_val2[k + 8] = block[k];
2737
        }
2738

    
2739
        /* scale AC coeffs */
2740
        for(k = 1; k < 64; k++)
2741
            if(block[k]) {
2742
                block[k] *= scale;
2743
                if(!v->pquantizer)
2744
                    block[k] += (block[k] < 0) ? -v->pq : v->pq;
2745
            }
2746

    
2747
        if(s->ac_pred) i = 63;
2748
    }
2749

    
2750
not_coded:
2751
    if(!coded) {
2752
        int k, scale;
2753
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2754
        ac_val2 = ac_val;
2755

    
2756
        scale = v->pq * 2 + v->halfpq;
2757
        memset(ac_val2, 0, 16 * 2);
2758
        if(dc_pred_dir) {//left
2759
            ac_val -= 16;
2760
            if(s->ac_pred)
2761
                memcpy(ac_val2, ac_val, 8 * 2);
2762
        } else {//top
2763
            ac_val -= 16 * s->block_wrap[n];
2764
            if(s->ac_pred)
2765
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2766
        }
2767

    
2768
        /* apply AC prediction if needed */
2769
        if(s->ac_pred) {
2770
            if(dc_pred_dir) { //left
2771
                for(k = 1; k < 8; k++) {
2772
                    block[k << 3] = ac_val[k] * scale;
2773
                    if(!v->pquantizer && block[k << 3])
2774
                        block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2775
                }
2776
            } else { //top
2777
                for(k = 1; k < 8; k++) {
2778
                    block[k] = ac_val[k + 8] * scale;
2779
                    if(!v->pquantizer && block[k])
2780
                        block[k] += (block[k] < 0) ? -v->pq : v->pq;
2781
                }
2782
            }
2783
            i = 63;
2784
        }
2785
    }
2786
    s->block_last_index[n] = i;
2787

    
2788
    return 0;
2789
}
2790

    
2791
/** Decode intra block in intra frames - should be faster than decode_intra_block
2792
 * @param v VC1Context
2793
 * @param block block to decode
2794
 * @param coded are AC coeffs present or not
2795
 * @param codingset set of VLC to decode data
2796
 */
2797
static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
2798
{
2799
    GetBitContext *gb = &v->s.gb;
2800
    MpegEncContext *s = &v->s;
2801
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
2802
    int run_diff, i;
2803
    int16_t *dc_val;
2804
    int16_t *ac_val, *ac_val2;
2805
    int dcdiff;
2806
    int a_avail = v->a_avail, c_avail = v->c_avail;
2807
    int use_pred = s->ac_pred;
2808
    int scale;
2809
    int q1, q2 = 0;
2810
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2811

    
2812
    /* Get DC differential */
2813
    if (n < 4) {
2814
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2815
    } else {
2816
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2817
    }
2818
    if (dcdiff < 0){
2819
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2820
        return -1;
2821
    }
2822
    if (dcdiff)
2823
    {
2824
        if (dcdiff == 119 /* ESC index value */)
2825
        {
2826
            /* TODO: Optimize */
2827
            if (mquant == 1) dcdiff = get_bits(gb, 10);
2828
            else if (mquant == 2) dcdiff = get_bits(gb, 9);
2829
            else dcdiff = get_bits(gb, 8);
2830
        }
2831
        else
2832
        {
2833
            if (mquant == 1)
2834
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2835
            else if (mquant == 2)
2836
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2837
        }
2838
        if (get_bits(gb, 1))
2839
            dcdiff = -dcdiff;
2840
    }
2841

    
2842
    /* Prediction */
2843
    dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2844
    *dc_val = dcdiff;
2845

    
2846
    /* Store the quantized DC coeff, used for prediction */
2847
    if (n < 4) {
2848
        block[0] = dcdiff * s->y_dc_scale;
2849
    } else {
2850
        block[0] = dcdiff * s->c_dc_scale;
2851
    }
2852
    /* Skip ? */
2853
    run_diff = 0;
2854
    i = 0;
2855

    
2856
    //AC Decoding
2857
    i = 1;
2858

    
2859
    /* check if AC is needed at all and adjust direction if needed */
2860
    if(!a_avail) dc_pred_dir = 1;
2861
    if(!c_avail) dc_pred_dir = 0;
2862
    if(!a_avail && !c_avail) use_pred = 0;
2863
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2864
    ac_val2 = ac_val;
2865

    
2866
    scale = mquant * 2 + v->halfpq;
2867

    
2868
    if(dc_pred_dir) //left
2869
        ac_val -= 16;
2870
    else //top
2871
        ac_val -= 16 * s->block_wrap[n];
2872

    
2873
    q1 = s->current_picture.qscale_table[mb_pos];
2874
    if(dc_pred_dir && c_avail) q2 = s->current_picture.qscale_table[mb_pos - 1];
2875
    if(!dc_pred_dir && a_avail) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2876
    if(n && n<4) q2 = q1;
2877

    
2878
    if(coded) {
2879
        int last = 0, skip, value;
2880
        const int8_t *zz_table;
2881
        int k;
2882

    
2883
        if(v->s.ac_pred) {
2884
            if(!dc_pred_dir)
2885
                zz_table = vc1_horizontal_zz;
2886
            else
2887
                zz_table = vc1_vertical_zz;
2888
        } else
2889
            zz_table = vc1_normal_zz;
2890

    
2891
        while (!last) {
2892
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2893
            i += skip;
2894
            if(i > 63)
2895
                break;
2896
            block[zz_table[i++]] = value;
2897
        }
2898

    
2899
        /* apply AC prediction if needed */
2900
        if(use_pred) {
2901
            /* scale predictors if needed*/
2902
            if(q2 && q1!=q2) {
2903
                q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2904
                q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2905

    
2906
                if(dc_pred_dir) { //left
2907
                    for(k = 1; k < 8; k++)
2908
                        block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2909
                } else { //top
2910
                    for(k = 1; k < 8; k++)
2911
                        block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2912
                }
2913
            } else {
2914
                if(dc_pred_dir) { //left
2915
                    for(k = 1; k < 8; k++)
2916
                        block[k << 3] += ac_val[k];
2917
                } else { //top
2918
                    for(k = 1; k < 8; k++)
2919
                        block[k] += ac_val[k + 8];
2920
                }
2921
            }
2922
        }
2923
        /* save AC coeffs for further prediction */
2924
        for(k = 1; k < 8; k++) {
2925
            ac_val2[k] = block[k << 3];
2926
            ac_val2[k + 8] = block[k];
2927
        }
2928

    
2929
        /* scale AC coeffs */
2930
        for(k = 1; k < 64; k++)
2931
            if(block[k]) {
2932
                block[k] *= scale;
2933
                if(!v->pquantizer)
2934
                    block[k] += (block[k] < 0) ? -mquant : mquant;
2935
            }
2936

    
2937
        if(use_pred) i = 63;
2938
    } else { // no AC coeffs
2939
        int k;
2940

    
2941
        memset(ac_val2, 0, 16 * 2);
2942
        if(dc_pred_dir) {//left
2943
            if(use_pred) {
2944
                memcpy(ac_val2, ac_val, 8 * 2);
2945
                if(q2 && q1!=q2) {
2946
                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2947
                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2948
                    for(k = 1; k < 8; k++)
2949
                        ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2950
                }
2951
            }
2952
        } else {//top
2953
            if(use_pred) {
2954
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2955
                if(q2 && q1!=q2) {
2956
                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2957
                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2958
                    for(k = 1; k < 8; k++)
2959
                        ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2960
                }
2961
            }
2962
        }
2963

    
2964
        /* apply AC prediction if needed */
2965
        if(use_pred) {
2966
            if(dc_pred_dir) { //left
2967
                for(k = 1; k < 8; k++) {
2968
                    block[k << 3] = ac_val2[k] * scale;
2969
                    if(!v->pquantizer && block[k << 3])
2970
                        block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2971
                }
2972
            } else { //top
2973
                for(k = 1; k < 8; k++) {
2974
                    block[k] = ac_val2[k + 8] * scale;
2975
                    if(!v->pquantizer && block[k])
2976
                        block[k] += (block[k] < 0) ? -mquant : mquant;
2977
                }
2978
            }
2979
            i = 63;
2980
        }
2981
    }
2982
    s->block_last_index[n] = i;
2983

    
2984
    return 0;
2985
}
2986

    
2987
/** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2988
 * @param v VC1Context
2989
 * @param block block to decode
2990
 * @param coded are AC coeffs present or not
2991
 * @param mquant block quantizer
2992
 * @param codingset set of VLC to decode data
2993
 */
2994
static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
2995
{
2996
    GetBitContext *gb = &v->s.gb;
2997
    MpegEncContext *s = &v->s;
2998
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
2999
    int run_diff, i;
3000
    int16_t *dc_val;
3001
    int16_t *ac_val, *ac_val2;
3002
    int dcdiff;
3003
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3004
    int a_avail = v->a_avail, c_avail = v->c_avail;
3005
    int use_pred = s->ac_pred;
3006
    int scale;
3007
    int q1, q2 = 0;
3008

    
3009
    /* XXX: Guard against dumb values of mquant */
3010
    mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
3011

    
3012
    /* Set DC scale - y and c use the same */
3013
    s->y_dc_scale = s->y_dc_scale_table[mquant];
3014
    s->c_dc_scale = s->c_dc_scale_table[mquant];
3015

    
3016
    /* Get DC differential */
3017
    if (n < 4) {
3018
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3019
    } else {
3020
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3021
    }
3022
    if (dcdiff < 0){
3023
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3024
        return -1;
3025
    }
3026
    if (dcdiff)
3027
    {
3028
        if (dcdiff == 119 /* ESC index value */)
3029
        {
3030
            /* TODO: Optimize */
3031
            if (mquant == 1) dcdiff = get_bits(gb, 10);
3032
            else if (mquant == 2) dcdiff = get_bits(gb, 9);
3033
            else dcdiff = get_bits(gb, 8);
3034
        }
3035
        else
3036
        {
3037
            if (mquant == 1)
3038
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
3039
            else if (mquant == 2)
3040
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
3041
        }
3042
        if (get_bits(gb, 1))
3043
            dcdiff = -dcdiff;
3044
    }
3045

    
3046
    /* Prediction */
3047
    dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3048
    *dc_val = dcdiff;
3049

    
3050
    /* Store the quantized DC coeff, used for prediction */
3051

    
3052
    if (n < 4) {
3053
        block[0] = dcdiff * s->y_dc_scale;
3054
    } else {
3055
        block[0] = dcdiff * s->c_dc_scale;
3056
    }
3057
    /* Skip ? */
3058
    run_diff = 0;
3059
    i = 0;
3060

    
3061
    //AC Decoding
3062
    i = 1;
3063

    
3064
    /* check if AC is needed at all and adjust direction if needed */
3065
    if(!a_avail) dc_pred_dir = 1;
3066
    if(!c_avail) dc_pred_dir = 0;
3067
    if(!a_avail && !c_avail) use_pred = 0;
3068
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3069
    ac_val2 = ac_val;
3070

    
3071
    scale = mquant * 2 + v->halfpq;
3072

    
3073
    if(dc_pred_dir) //left
3074
        ac_val -= 16;
3075
    else //top
3076
        ac_val -= 16 * s->block_wrap[n];
3077

    
3078
    q1 = s->current_picture.qscale_table[mb_pos];
3079
    if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
3080
    if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3081
    if(n && n<4) q2 = q1;
3082

    
3083
    if(coded) {
3084
        int last = 0, skip, value;
3085
        const int8_t *zz_table;
3086
        int k;
3087

    
3088
        zz_table = vc1_simple_progressive_8x8_zz;
3089

    
3090
        while (!last) {
3091
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3092
            i += skip;
3093
            if(i > 63)
3094
                break;
3095
            block[zz_table[i++]] = value;
3096
        }
3097

    
3098
        /* apply AC prediction if needed */
3099
        if(use_pred) {
3100
            /* scale predictors if needed*/
3101
            if(q2 && q1!=q2) {
3102
                q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3103
                q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3104

    
3105
                if(dc_pred_dir) { //left
3106
                    for(k = 1; k < 8; k++)
3107
                        block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3108
                } else { //top
3109
                    for(k = 1; k < 8; k++)
3110
                        block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3111
                }
3112
            } else {
3113
                if(dc_pred_dir) { //left
3114
                    for(k = 1; k < 8; k++)
3115
                        block[k << 3] += ac_val[k];
3116
                } else { //top
3117
                    for(k = 1; k < 8; k++)
3118
                        block[k] += ac_val[k + 8];
3119
                }
3120
            }
3121
        }
3122
        /* save AC coeffs for further prediction */
3123
        for(k = 1; k < 8; k++) {
3124
            ac_val2[k] = block[k << 3];
3125
            ac_val2[k + 8] = block[k];
3126
        }
3127

    
3128
        /* scale AC coeffs */
3129
        for(k = 1; k < 64; k++)
3130
            if(block[k]) {
3131
                block[k] *= scale;
3132
                if(!v->pquantizer)
3133
                    block[k] += (block[k] < 0) ? -mquant : mquant;
3134
            }
3135

    
3136
        if(use_pred) i = 63;
3137
    } else { // no AC coeffs
3138
        int k;
3139

    
3140
        memset(ac_val2, 0, 16 * 2);
3141
        if(dc_pred_dir) {//left
3142
            if(use_pred) {
3143
                memcpy(ac_val2, ac_val, 8 * 2);
3144
                if(q2 && q1!=q2) {
3145
                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3146
                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3147
                    for(k = 1; k < 8; k++)
3148
                        ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3149
                }
3150
            }
3151
        } else {//top
3152
            if(use_pred) {
3153
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3154
                if(q2 && q1!=q2) {
3155
                    q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3156
                    q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3157
                    for(k = 1; k < 8; k++)
3158
                        ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3159
                }
3160
            }
3161
        }
3162

    
3163
        /* apply AC prediction if needed */
3164
        if(use_pred) {
3165
            if(dc_pred_dir) { //left
3166
                for(k = 1; k < 8; k++) {
3167
                    block[k << 3] = ac_val2[k] * scale;
3168
                    if(!v->pquantizer && block[k << 3])
3169
                        block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3170
                }
3171
            } else { //top
3172
                for(k = 1; k < 8; k++) {
3173
                    block[k] = ac_val2[k + 8] * scale;
3174
                    if(!v->pquantizer && block[k])
3175
                        block[k] += (block[k] < 0) ? -mquant : mquant;
3176
                }
3177
            }
3178
            i = 63;
3179
        }
3180
    }
3181
    s->block_last_index[n] = i;
3182

    
3183
    return 0;
3184
}
3185

    
3186
/** Decode P block
3187
 */
3188
static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
3189
{
3190
    MpegEncContext *s = &v->s;
3191
    GetBitContext *gb = &s->gb;
3192
    int i, j;
3193
    int subblkpat = 0;
3194
    int scale, off, idx, last, skip, value;
3195
    int ttblk = ttmb & 7;
3196

    
3197
    if(ttmb == -1) {
3198
        ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
3199
    }
3200
    if(ttblk == TT_4X4) {
3201
        subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3202
    }
3203
    if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
3204
        subblkpat = decode012(gb);
3205
        if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
3206
        if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
3207
        if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
3208
    }
3209
    scale = 2 * mquant + v->halfpq;
3210

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

    
3303

    
3304
/** Decode one P-frame MB (in Simple/Main profile)
3305
 */
3306
static int vc1_decode_p_mb(VC1Context *v)
3307
{
3308
    MpegEncContext *s = &v->s;
3309
    GetBitContext *gb = &s->gb;
3310
    int i, j;
3311
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3312
    int cbp; /* cbp decoding stuff */
3313
    int mqdiff, mquant; /* MB quantization */
3314
    int ttmb = v->ttfrm; /* MB Transform type */
3315
    int status;
3316

    
3317
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3318
      offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3319
    int mb_has_coeffs = 1; /* last_flag */
3320
    int dmv_x, dmv_y; /* Differential MV components */
3321
    int index, index1; /* LUT indices */
3322
    int val, sign; /* temp values */
3323
    int first_block = 1;
3324
    int dst_idx, off;
3325
    int skipped, fourmv;
3326

    
3327
    mquant = v->pq; /* Loosy initialization */
3328

    
3329
    if (v->mv_type_is_raw)
3330
        fourmv = get_bits1(gb);
3331
    else
3332
        fourmv = v->mv_type_mb_plane[mb_pos];
3333
    if (v->skip_is_raw)
3334
        skipped = get_bits1(gb);
3335
    else
3336
        skipped = v->s.mbskip_table[mb_pos];
3337

    
3338
    s->dsp.clear_blocks(s->block[0]);
3339

    
3340
    if (!fourmv) /* 1MV mode */
3341
    {
3342
        if (!skipped)
3343
        {
3344
            GET_MVDATA(dmv_x, dmv_y);
3345

    
3346
            if (s->mb_intra) {
3347
                s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3348
                s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3349
            }
3350
            s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3351
            vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3352

    
3353
            /* FIXME Set DC val for inter block ? */
3354
            if (s->mb_intra && !mb_has_coeffs)
3355
            {
3356
                GET_MQUANT();
3357
                s->ac_pred = get_bits(gb, 1);
3358
                cbp = 0;
3359
            }
3360
            else if (mb_has_coeffs)
3361
            {
3362
                if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
3363
                cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3364
                GET_MQUANT();
3365
            }
3366
            else
3367
            {
3368
                mquant = v->pq;
3369
                cbp = 0;
3370
            }
3371
            s->current_picture.qscale_table[mb_pos] = mquant;
3372

    
3373
            if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3374
                ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
3375
                                VC1_TTMB_VLC_BITS, 2);
3376
            if(!s->mb_intra) vc1_mc_1mv(v, 0);
3377
            dst_idx = 0;
3378
            for (i=0; i<6; i++)
3379
            {
3380
                s->dc_val[0][s->block_index[i]] = 0;
3381
                dst_idx += i >> 2;
3382
                val = ((cbp >> (5 - i)) & 1);
3383
                off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3384
                v->mb_type[0][s->block_index[i]] = s->mb_intra;
3385
                if(s->mb_intra) {
3386
                    /* check if prediction blocks A and C are available */
3387
                    v->a_avail = v->c_avail = 0;
3388
                    if(i == 2 || i == 3 || !s->first_slice_line)
3389
                        v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3390
                    if(i == 1 || i == 3 || s->mb_x)
3391
                        v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3392

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

    
3496
                    vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
3497
                    if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3498
                    s->dsp.vc1_inv_trans_8x8(s->block[i]);
3499
                    if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3500
                    for(j = 0; j < 64; j++) s->block[i][j] += 128;
3501
                    s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3502
                    if(v->pq >= 9 && v->overlap) {
3503
                        if(v->c_avail)
3504
                            s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3505
                        if(v->a_avail)
3506
                            s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3507
                    }
3508
                } else if(is_coded[i]) {
3509
                    status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3510
                    if(!v->ttmbf && ttmb < 8) ttmb = -1;
3511
                    first_block = 0;
3512
                    if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3513
                        s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3514
                }
3515
            }
3516
            return status;
3517
        }
3518
        else //Skipped MB
3519
        {
3520
            s->mb_intra = 0;
3521
            s->current_picture.qscale_table[mb_pos] = 0;
3522
            for (i=0; i<6; i++) {
3523
                v->mb_type[0][s->block_index[i]] = 0;
3524
                s->dc_val[0][s->block_index[i]] = 0;
3525
            }
3526
            for (i=0; i<4; i++)
3527
            {
3528
                vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
3529
                vc1_mc_4mv_luma(v, i);
3530
            }
3531
            vc1_mc_4mv_chroma(v);
3532
            s->current_picture.qscale_table[mb_pos] = 0;
3533
            return 0;
3534
        }
3535
    }
3536

    
3537
    /* Should never happen */
3538
    return -1;
3539
}
3540

    
3541
/** Decode one B-frame MB (in Main profile)
3542
 */
3543
static void vc1_decode_b_mb(VC1Context *v)
3544
{
3545
    MpegEncContext *s = &v->s;
3546
    GetBitContext *gb = &s->gb;
3547
    int i, j;
3548
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3549
    int cbp = 0; /* cbp decoding stuff */
3550
    int mqdiff, mquant; /* MB quantization */
3551
    int ttmb = v->ttfrm; /* MB Transform type */
3552

    
3553
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3554
      offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3555
    int mb_has_coeffs = 0; /* last_flag */
3556
    int index, index1; /* LUT indices */
3557
    int val, sign; /* temp values */
3558
    int first_block = 1;
3559
    int dst_idx, off;
3560
    int skipped, direct;
3561
    int dmv_x[2], dmv_y[2];
3562
    int bmvtype = BMV_TYPE_BACKWARD;
3563

    
3564
    mquant = v->pq; /* Loosy initialization */
3565
    s->mb_intra = 0;
3566

    
3567
    if (v->dmb_is_raw)
3568
        direct = get_bits1(gb);
3569
    else
3570
        direct = v->direct_mb_plane[mb_pos];
3571
    if (v->skip_is_raw)
3572
        skipped = get_bits1(gb);
3573
    else
3574
        skipped = v->s.mbskip_table[mb_pos];
3575

    
3576
    s->dsp.clear_blocks(s->block[0]);
3577
    dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
3578
    for(i = 0; i < 6; i++) {
3579
        v->mb_type[0][s->block_index[i]] = 0;
3580
        s->dc_val[0][s->block_index[i]] = 0;
3581
    }
3582
    s->current_picture.qscale_table[mb_pos] = 0;
3583

    
3584
    if (!direct) {
3585
        if (!skipped) {
3586
            GET_MVDATA(dmv_x[0], dmv_y[0]);
3587
            dmv_x[1] = dmv_x[0];
3588
            dmv_y[1] = dmv_y[0];
3589
        }
3590
        if(skipped || !s->mb_intra) {
3591
            bmvtype = decode012(gb);
3592
            switch(bmvtype) {
3593
            case 0:
3594
                bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
3595
                break;
3596
            case 1:
3597
                bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
3598
                break;
3599
            case 2:
3600
                bmvtype = BMV_TYPE_INTERPOLATED;
3601
                dmv_x[0] = dmv_y[0] = 0;
3602
            }
3603
        }
3604
    }
3605
    for(i = 0; i < 6; i++)
3606
        v->mb_type[0][s->block_index[i]] = s->mb_intra;
3607

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

    
3677
            vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3678
            if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3679
            s->dsp.vc1_inv_trans_8x8(s->block[i]);
3680
            if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3681
            for(j = 0; j < 64; j++) s->block[i][j] += 128;
3682
            s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3683
        } else if(val) {
3684
            vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3685
            if(!v->ttmbf && ttmb < 8) ttmb = -1;
3686
            first_block = 0;
3687
            if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3688
                s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3689
        }
3690
    }
3691
}
3692

    
3693
/** Decode blocks of I-frame
3694
 */
3695
static void vc1_decode_i_blocks(VC1Context *v)
3696
{
3697
    int k, j;
3698
    MpegEncContext *s = &v->s;
3699
    int cbp, val;
3700
    uint8_t *coded_val;
3701
    int mb_pos;
3702

    
3703
    /* select codingmode used for VLC tables selection */
3704
    switch(v->y_ac_table_index){
3705
    case 0:
3706
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3707
        break;
3708
    case 1:
3709
        v->codingset = CS_HIGH_MOT_INTRA;
3710
        break;
3711
    case 2:
3712
        v->codingset = CS_MID_RATE_INTRA;
3713
        break;
3714
    }
3715

    
3716
    switch(v->c_ac_table_index){
3717
    case 0:
3718
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3719
        break;
3720
    case 1:
3721
        v->codingset2 = CS_HIGH_MOT_INTER;
3722
        break;
3723
    case 2:
3724
        v->codingset2 = CS_MID_RATE_INTER;
3725
        break;
3726
    }
3727

    
3728
    /* Set DC scale - y and c use the same */
3729
    s->y_dc_scale = s->y_dc_scale_table[v->pq];
3730
    s->c_dc_scale = s->c_dc_scale_table[v->pq];
3731

    
3732
    //do frame decode
3733
    s->mb_x = s->mb_y = 0;
3734
    s->mb_intra = 1;
3735
    s->first_slice_line = 1;
3736
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3737
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3738
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3739
            ff_init_block_index(s);
3740
            ff_update_block_index(s);
3741
            s->dsp.clear_blocks(s->block[0]);
3742
            mb_pos = s->mb_x + s->mb_y * s->mb_width;
3743
            s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3744
            s->current_picture.qscale_table[mb_pos] = v->pq;
3745
            s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3746
            s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3747

    
3748
            // do actual MB decoding and displaying
3749
            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3750
            v->s.ac_pred = get_bits(&v->s.gb, 1);
3751

    
3752
            for(k = 0; k < 6; k++) {
3753
                val = ((cbp >> (5 - k)) & 1);
3754

    
3755
                if (k < 4) {
3756
                    int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3757
                    val = val ^ pred;
3758
                    *coded_val = val;
3759
                }
3760
                cbp |= val << (5 - k);
3761

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

    
3764
                s->dsp.vc1_inv_trans_8x8(s->block[k]);
3765
                if(v->pq >= 9 && v->overlap) {
3766
                    for(j = 0; j < 64; j++) s->block[k][j] += 128;
3767
                }
3768
            }
3769

    
3770
            vc1_put_block(v, s->block);
3771
            if(v->pq >= 9 && v->overlap) {
3772
                if(s->mb_x) {
3773
                    s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3774
                    s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3775
                    if(!(s->flags & CODEC_FLAG_GRAY)) {
3776
                        s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3777
                        s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3778
                    }
3779
                }
3780
                s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3781
                s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3782
                if(!s->first_slice_line) {
3783
                    s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3784
                    s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3785
                    if(!(s->flags & CODEC_FLAG_GRAY)) {
3786
                        s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3787
                        s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3788
                    }
3789
                }
3790
                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3791
                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3792
            }
3793

    
3794
            if(get_bits_count(&s->gb) > v->bits) {
3795
                av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3796
                return;
3797
            }
3798
        }
3799
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
3800
        s->first_slice_line = 0;
3801
    }
3802
}
3803

    
3804
/** Decode blocks of I-frame for advanced profile
3805
 */
3806
static void vc1_decode_i_blocks_adv(VC1Context *v)
3807
{
3808
    int k, j;
3809
    MpegEncContext *s = &v->s;
3810
    int cbp, val;
3811
    uint8_t *coded_val;
3812
    int mb_pos;
3813
    int mquant = v->pq;
3814
    int mqdiff;
3815
    int overlap;
3816
    GetBitContext *gb = &s->gb;
3817

    
3818
    /* select codingmode used for VLC tables selection */
3819
    switch(v->y_ac_table_index){
3820
    case 0:
3821
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3822
        break;
3823
    case 1:
3824
        v->codingset = CS_HIGH_MOT_INTRA;
3825
        break;
3826
    case 2:
3827
        v->codingset = CS_MID_RATE_INTRA;
3828
        break;
3829
    }
3830

    
3831
    switch(v->c_ac_table_index){
3832
    case 0:
3833
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3834
        break;
3835
    case 1:
3836
        v->codingset2 = CS_HIGH_MOT_INTER;
3837
        break;
3838
    case 2:
3839
        v->codingset2 = CS_MID_RATE_INTER;
3840
        break;
3841
    }
3842

    
3843
    //do frame decode
3844
    s->mb_x = s->mb_y = 0;
3845
    s->mb_intra = 1;
3846
    s->first_slice_line = 1;
3847
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3848
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3849
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3850
            ff_init_block_index(s);
3851
            ff_update_block_index(s);
3852
            s->dsp.clear_blocks(s->block[0]);
3853
            mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3854
            s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3855
            s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3856
            s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3857

    
3858
            // do actual MB decoding and displaying
3859
            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3860
            if(v->acpred_is_raw)
3861
                v->s.ac_pred = get_bits(&v->s.gb, 1);
3862
            else
3863
                v->s.ac_pred = v->acpred_plane[mb_pos];
3864

    
3865
            if(v->condover == CONDOVER_SELECT) {
3866
                if(v->overflg_is_raw)
3867
                    overlap = get_bits(&v->s.gb, 1);
3868
                else
3869
                    overlap = v->over_flags_plane[mb_pos];
3870
            } else
3871
                overlap = (v->condover == CONDOVER_ALL);
3872

    
3873
            GET_MQUANT();
3874

    
3875
            s->current_picture.qscale_table[mb_pos] = mquant;
3876
            /* Set DC scale - y and c use the same */
3877
            s->y_dc_scale = s->y_dc_scale_table[mquant];
3878
            s->c_dc_scale = s->c_dc_scale_table[mquant];
3879

    
3880
            for(k = 0; k < 6; k++) {
3881
                val = ((cbp >> (5 - k)) & 1);
3882

    
3883
                if (k < 4) {
3884
                    int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3885
                    val = val ^ pred;
3886
                    *coded_val = val;
3887
                }
3888
                cbp |= val << (5 - k);
3889

    
3890
                v->a_avail = !s->first_slice_line || (k==2 || k==3);
3891
                v->c_avail = !!s->mb_x || (k==1 || k==3);
3892

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

    
3895
                s->dsp.vc1_inv_trans_8x8(s->block[k]);
3896
                for(j = 0; j < 64; j++) s->block[k][j] += 128;
3897
            }
3898

    
3899
            vc1_put_block(v, s->block);
3900
            if(overlap) {
3901
                if(s->mb_x) {
3902
                    s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3903
                    s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3904
                    if(!(s->flags & CODEC_FLAG_GRAY)) {
3905
                        s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3906
                        s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3907
                    }
3908
                }
3909
                s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3910
                s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3911
                if(!s->first_slice_line) {
3912
                    s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3913
                    s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3914
                    if(!(s->flags & CODEC_FLAG_GRAY)) {
3915
                        s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3916
                        s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3917
                    }
3918
                }
3919
                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3920
                s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3921
            }
3922

    
3923
            if(get_bits_count(&s->gb) > v->bits) {
3924
                av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3925
                return;
3926
            }
3927
        }
3928
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
3929
        s->first_slice_line = 0;
3930
    }
3931
}
3932

    
3933
static void vc1_decode_p_blocks(VC1Context *v)
3934
{
3935
    MpegEncContext *s = &v->s;
3936

    
3937
    /* select codingmode used for VLC tables selection */
3938
    switch(v->c_ac_table_index){
3939
    case 0:
3940
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3941
        break;
3942
    case 1:
3943
        v->codingset = CS_HIGH_MOT_INTRA;
3944
        break;
3945
    case 2:
3946
        v->codingset = CS_MID_RATE_INTRA;
3947
        break;
3948
    }
3949

    
3950
    switch(v->c_ac_table_index){
3951
    case 0:
3952
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3953
        break;
3954
    case 1:
3955
        v->codingset2 = CS_HIGH_MOT_INTER;
3956
        break;
3957
    case 2:
3958
        v->codingset2 = CS_MID_RATE_INTER;
3959
        break;
3960
    }
3961

    
3962
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3963
    s->first_slice_line = 1;
3964
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3965
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3966
            ff_init_block_index(s);
3967
            ff_update_block_index(s);
3968
            s->dsp.clear_blocks(s->block[0]);
3969

    
3970
            vc1_decode_p_mb(v);
3971
            if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
3972
                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);
3973
                return;
3974
            }
3975
        }
3976
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
3977
        s->first_slice_line = 0;
3978
    }
3979
}
3980

    
3981
static void vc1_decode_b_blocks(VC1Context *v)
3982
{
3983
    MpegEncContext *s = &v->s;
3984

    
3985
    /* select codingmode used for VLC tables selection */
3986
    switch(v->c_ac_table_index){
3987
    case 0:
3988
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3989
        break;
3990
    case 1:
3991
        v->codingset = CS_HIGH_MOT_INTRA;
3992
        break;
3993
    case 2:
3994
        v->codingset = CS_MID_RATE_INTRA;
3995
        break;
3996
    }
3997

    
3998
    switch(v->c_ac_table_index){
3999
    case 0:
4000
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4001
        break;
4002
    case 1:
4003
        v->codingset2 = CS_HIGH_MOT_INTER;
4004
        break;
4005
    case 2:
4006
        v->codingset2 = CS_MID_RATE_INTER;
4007
        break;
4008
    }
4009

    
4010
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4011
    s->first_slice_line = 1;
4012
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4013
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
4014
            ff_init_block_index(s);
4015
            ff_update_block_index(s);
4016
            s->dsp.clear_blocks(s->block[0]);
4017

    
4018
            vc1_decode_b_mb(v);
4019
            if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4020
                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);
4021
                return;
4022
            }
4023
        }
4024
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
4025
        s->first_slice_line = 0;
4026
    }
4027
}
4028

    
4029
static void vc1_decode_skip_blocks(VC1Context *v)
4030
{
4031
    MpegEncContext *s = &v->s;
4032

    
4033
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4034
    s->first_slice_line = 1;
4035
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4036
        s->mb_x = 0;
4037
        ff_init_block_index(s);
4038
        ff_update_block_index(s);
4039
        memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4040
        memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4041
        memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4042
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
4043
        s->first_slice_line = 0;
4044
    }
4045
    s->pict_type = P_TYPE;
4046
}
4047

    
4048
static void vc1_decode_blocks(VC1Context *v)
4049
{
4050

    
4051
    v->s.esc3_level_length = 0;
4052

    
4053
    switch(v->s.pict_type) {
4054
    case I_TYPE:
4055
        if(v->profile == PROFILE_ADVANCED)
4056
            vc1_decode_i_blocks_adv(v);
4057
        else
4058
            vc1_decode_i_blocks(v);
4059
        break;
4060
    case P_TYPE:
4061
        if(v->p_frame_skipped)
4062
            vc1_decode_skip_blocks(v);
4063
        else
4064
            vc1_decode_p_blocks(v);
4065
        break;
4066
    case B_TYPE:
4067
        if(v->bi_type)
4068
            vc1_decode_i_blocks(v);
4069
        else
4070
            vc1_decode_b_blocks(v);
4071
        break;
4072
    }
4073
}
4074

    
4075

    
4076
/** Initialize a VC1/WMV3 decoder
4077
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4078
 * @todo TODO: Decypher remaining bits in extra_data
4079
 */
4080
static int vc1_decode_init(AVCodecContext *avctx)
4081
{
4082
    VC1Context *v = avctx->priv_data;
4083
    MpegEncContext *s = &v->s;
4084
    GetBitContext gb;
4085

    
4086
    if (!avctx->extradata_size || !avctx->extradata) return -1;
4087
    if (!(avctx->flags & CODEC_FLAG_GRAY))
4088
        avctx->pix_fmt = PIX_FMT_YUV420P;
4089
    else
4090
        avctx->pix_fmt = PIX_FMT_GRAY8;
4091
    v->s.avctx = avctx;
4092
    avctx->flags |= CODEC_FLAG_EMU_EDGE;
4093
    v->s.flags |= CODEC_FLAG_EMU_EDGE;
4094

    
4095
    if(ff_h263_decode_init(avctx) < 0)
4096
        return -1;
4097
    if (vc1_init_common(v) < 0) return -1;
4098

    
4099
    avctx->coded_width = avctx->width;
4100
    avctx->coded_height = avctx->height;
4101
    if (avctx->codec_id == CODEC_ID_WMV3)
4102
    {
4103
        int count = 0;
4104

    
4105
        // looks like WMV3 has a sequence header stored in the extradata
4106
        // advanced sequence header may be before the first frame
4107
        // the last byte of the extradata is a version number, 1 for the
4108
        // samples we can decode
4109

    
4110
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
4111

    
4112
        if (decode_sequence_header(avctx, &gb) < 0)
4113
          return -1;
4114

    
4115
        count = avctx->extradata_size*8 - get_bits_count(&gb);
4116
        if (count>0)
4117
        {
4118
            av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
4119
                   count, get_bits(&gb, count));
4120
        }
4121
        else if (count < 0)
4122
        {
4123
            av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
4124
        }
4125
    } else { // VC1/WVC1
4126
        int edata_size = avctx->extradata_size;
4127
        uint8_t *edata = avctx->extradata;
4128

    
4129
        if(avctx->extradata_size < 16) {
4130
            av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", edata_size);
4131
            return -1;
4132
        }
4133
        while(edata_size > 8) {
4134
            // test if we've found header
4135
            if(AV_RB32(edata) == 0x0000010F) {
4136
                edata += 4;
4137
                edata_size -= 4;
4138
                break;
4139
            }
4140
            edata_size--;
4141
            edata++;
4142
        }
4143

    
4144
        init_get_bits(&gb, edata, edata_size*8);
4145

    
4146
        if (decode_sequence_header(avctx, &gb) < 0)
4147
          return -1;
4148

    
4149
        while(edata_size > 8) {
4150
            // test if we've found entry point
4151
            if(AV_RB32(edata) == 0x0000010E) {
4152
                edata += 4;
4153
                edata_size -= 4;
4154
                break;
4155
            }
4156
            edata_size--;
4157
            edata++;
4158
        }
4159

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

    
4162
        if (decode_entry_point(avctx, &gb) < 0)
4163
          return -1;
4164
    }
4165
    avctx->has_b_frames= !!(avctx->max_b_frames);
4166
    s->low_delay = !avctx->has_b_frames;
4167

    
4168
    s->mb_width = (avctx->coded_width+15)>>4;
4169
    s->mb_height = (avctx->coded_height+15)>>4;
4170

    
4171
    /* Allocate mb bitplanes */
4172
    v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
4173
    v->direct_mb_plane = av_malloc(s->mb_stride * s->mb_height);
4174
    v->acpred_plane = av_malloc(s->mb_stride * s->mb_height);
4175
    v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height);
4176

    
4177
    /* allocate block type info in that way so it could be used with s->block_index[] */
4178
    v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
4179
    v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
4180
    v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
4181
    v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
4182

    
4183
    /* Init coded blocks info */
4184
    if (v->profile == PROFILE_ADVANCED)
4185
    {
4186
//        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
4187
//            return -1;
4188
//        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
4189
//            return -1;
4190
    }
4191

    
4192
    return 0;
4193
}
4194

    
4195

    
4196
/** Decode a VC1/WMV3 frame
4197
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
4198
 */
4199
static int vc1_decode_frame(AVCodecContext *avctx,
4200
                            void *data, int *data_size,
4201
                            uint8_t *buf, int buf_size)
4202
{
4203
    VC1Context *v = avctx->priv_data;
4204
    MpegEncContext *s = &v->s;
4205
    AVFrame *pict = data;
4206
    uint8_t *buf2 = NULL;
4207

    
4208
    /* no supplementary picture */
4209
    if (buf_size == 0) {
4210
        /* special case for last picture */
4211
        if (s->low_delay==0 && s->next_picture_ptr) {
4212
            *pict= *(AVFrame*)s->next_picture_ptr;
4213
            s->next_picture_ptr= NULL;
4214

    
4215
            *data_size = sizeof(AVFrame);
4216
        }
4217

    
4218
        return 0;
4219
    }
4220

    
4221
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
4222
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
4223
        int i= ff_find_unused_picture(s, 0);
4224
        s->current_picture_ptr= &s->picture[i];
4225
    }
4226

    
4227
    //for advanced profile we need to unescape buffer
4228
    if (avctx->codec_id == CODEC_ID_VC1) {
4229
        int i, buf_size2;
4230
        buf2 = av_malloc(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
4231
        buf_size2 = 0;
4232
        for(i = 0; i < buf_size; i++) {
4233
            if(buf[i] == 3 && i >= 2 && !buf[i-1] && !buf[i-2] && i < buf_size-1 && buf[i+1] < 4) {
4234
                buf2[buf_size2++] = buf[i+1];
4235
                i++;
4236
            } else
4237
                buf2[buf_size2++] = buf[i];
4238
        }
4239
        init_get_bits(&s->gb, buf2, buf_size2*8);
4240
    } else
4241
        init_get_bits(&s->gb, buf, buf_size*8);
4242
    // do parse frame header
4243
    if(v->profile < PROFILE_ADVANCED) {
4244
        if(vc1_parse_frame_header(v, &s->gb) == -1) {
4245
            av_free(buf2);
4246
            return -1;
4247
        }
4248
    } else {
4249
        if(vc1_parse_frame_header_adv(v, &s->gb) == -1) {
4250
            av_free(buf2);
4251
            return -1;
4252
        }
4253
    }
4254

    
4255
    if(s->pict_type != I_TYPE && !v->res_rtm_flag){
4256
        av_free(buf2);
4257
        return -1;
4258
    }
4259

    
4260
    // for hurry_up==5
4261
    s->current_picture.pict_type= s->pict_type;
4262
    s->current_picture.key_frame= s->pict_type == I_TYPE;
4263

    
4264
    /* skip B-frames if we don't have reference frames */
4265
    if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)){
4266
        av_free(buf2);
4267
        return -1;//buf_size;
4268
    }
4269
    /* skip b frames if we are in a hurry */
4270
    if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
4271
    if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
4272
       || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
4273
       ||  avctx->skip_frame >= AVDISCARD_ALL) {
4274
        av_free(buf2);
4275
        return buf_size;
4276
    }
4277
    /* skip everything if we are in a hurry>=5 */
4278
    if(avctx->hurry_up>=5) {
4279
        av_free(buf2);
4280
        return -1;//buf_size;
4281
    }
4282

    
4283
    if(s->next_p_frame_damaged){
4284
        if(s->pict_type==B_TYPE)
4285
            return buf_size;
4286
        else
4287
            s->next_p_frame_damaged=0;
4288
    }
4289

    
4290
    if(MPV_frame_start(s, avctx) < 0) {
4291
        av_free(buf2);
4292
        return -1;
4293
    }
4294

    
4295
    ff_er_frame_start(s);
4296

    
4297
    v->bits = buf_size * 8;
4298
    vc1_decode_blocks(v);
4299
//av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
4300
//  if(get_bits_count(&s->gb) > buf_size * 8)
4301
//      return -1;
4302
    ff_er_frame_end(s);
4303

    
4304
    MPV_frame_end(s);
4305

    
4306
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
4307
assert(s->current_picture.pict_type == s->pict_type);
4308
    if (s->pict_type == B_TYPE || s->low_delay) {
4309
        *pict= *(AVFrame*)s->current_picture_ptr;
4310
    } else if (s->last_picture_ptr != NULL) {
4311
        *pict= *(AVFrame*)s->last_picture_ptr;
4312
    }
4313

    
4314
    if(s->last_picture_ptr || s->low_delay){
4315
        *data_size = sizeof(AVFrame);
4316
        ff_print_debug_info(s, pict);
4317
    }
4318

    
4319
    /* Return the Picture timestamp as the frame number */
4320
    /* we substract 1 because it is added on utils.c    */
4321
    avctx->frame_number = s->picture_number - 1;
4322

    
4323
    av_free(buf2);
4324
    return buf_size;
4325
}
4326

    
4327

    
4328
/** Close a VC1/WMV3 decoder
4329
 * @warning Initial try at using MpegEncContext stuff
4330
 */
4331
static int vc1_decode_end(AVCodecContext *avctx)
4332
{
4333
    VC1Context *v = avctx->priv_data;
4334

    
4335
    av_freep(&v->hrd_rate);
4336
    av_freep(&v->hrd_buffer);
4337
    MPV_common_end(&v->s);
4338
    av_freep(&v->mv_type_mb_plane);
4339
    av_freep(&v->direct_mb_plane);
4340
    av_freep(&v->acpred_plane);
4341
    av_freep(&v->over_flags_plane);
4342
    av_freep(&v->mb_type_base);
4343
    return 0;
4344
}
4345

    
4346

    
4347
AVCodec vc1_decoder = {
4348
    "vc1",
4349
    CODEC_TYPE_VIDEO,
4350
    CODEC_ID_VC1,
4351
    sizeof(VC1Context),
4352
    vc1_decode_init,
4353
    NULL,
4354
    vc1_decode_end,
4355
    vc1_decode_frame,
4356
    CODEC_CAP_DELAY,
4357
    NULL
4358
};
4359

    
4360
AVCodec wmv3_decoder = {
4361
    "wmv3",
4362
    CODEC_TYPE_VIDEO,
4363
    CODEC_ID_WMV3,
4364
    sizeof(VC1Context),
4365
    vc1_decode_init,
4366
    NULL,
4367
    vc1_decode_end,
4368
    vc1_decode_frame,
4369
    CODEC_CAP_DELAY,
4370
    NULL
4371
};