Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vc1.c @ be3492ec

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

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

    
34
#undef NDEBUG
35
#include <assert.h>
36

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

    
47

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

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

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

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

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

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

    
110
/** @name MV types for B frames */
111
//@{
112
enum BMVTypes {
113
    BMV_TYPE_BACKWARD,
114
    BMV_TYPE_FORWARD,
115
    BMV_TYPE_INTERPOLATED = 3 //XXX: ??
116
};
117
//@}
118

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

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

    
140
/** MV P mode - the 5th element is only used for mode 1 */
141
static const uint8_t mv_pmode_table[2][5] = {
142
  { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV },
143
  { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN }
144
};
145

    
146
/** One more frame type */
147
#define BI_TYPE 7
148

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

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

    
192
static VLC vc1_ac_coeff_table[8];
193
//@}
194

    
195
enum CodingSet {
196
    CS_HIGH_MOT_INTRA = 0,
197
    CS_HIGH_MOT_INTER,
198
    CS_LOW_MOT_INTRA,
199
    CS_LOW_MOT_INTER,
200
    CS_MID_RATE_INTRA,
201
    CS_MID_RATE_INTER,
202
    CS_HIGH_RATE_INTRA,
203
    CS_HIGH_RATE_INTER
204
};
205

    
206
/** Bitplane struct
207
 * We mainly need data and is_raw, so this struct could be avoided
208
 * to save a level of indirection; feel free to modify
209
 * @fixme For now, stride=width
210
 * @warning Data are bits, either 1 or 0
211
 */
212
typedef struct BitPlane {
213
    uint8_t *data;      ///< Data buffer
214
    int width;          ///< Width of the buffer
215
    int stride;         ///< Stride of the buffer
216
    int height;         ///< Plane height
217
    uint8_t is_raw;     ///< Bit values must be read at MB level
218
} BitPlane;
219

    
220

    
221
/** Block data for DC/AC prediction
222
*/
223
typedef struct Block {
224
    uint16_t dc;
225
    int16_t hor_ac[7];
226
    int16_t vert_ac[7];
227
    int16_t dcstep, step;
228
} Block;
229

    
230
/** The VC1 Context
231
 * @fixme Change size wherever another size is more efficient
232
 * Many members are only used for Advanced Profile
233
 */
234
typedef struct VC1Context{
235
    MpegEncContext s;
236

    
237
    int bits;
238

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

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

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

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

    
315

    
316
    /** Luma compensation parameters */
317
    //@{
318
    uint8_t lumscale;
319
    uint8_t lumshift;
320
    //@}
321
    int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs
322
    uint8_t halfpq;       ///< Uniform quant over image and qp+.5
323
    uint8_t respic;       ///< Frame-level flag for resized images
324
    int buffer_fullness;  ///< HRD info
325
    /** Ranges:
326
     * -# 0 -> [-64n 63.f] x [-32, 31.f]
327
     * -# 1 -> [-128, 127.f] x [-64, 63.f]
328
     * -# 2 -> [-512, 511.f] x [-128, 127.f]
329
     * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
330
     */
331
    uint8_t mvrange;
332
    uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use
333
    uint8_t *previous_line_cbpcy; ///< To use for predicted CBPCY
334
    VLC *cbpcy_vlc;               ///< CBPCY VLC table
335
    int tt_index;                 ///< Index for Transform Type tables
336
    BitPlane mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)
337
    BitPlane skip_mb_plane;       ///< bitplane for skipped MBs
338
    BitPlane direct_mb_plane;     ///< bitplane for "direct" MBs
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
    BitPlane ac_pred_plane;       ///< AC prediction flags bitplane
362
    BitPlane over_flags_plane;    ///< Overflags bitplane
363
    uint8_t condover;
364
    uint16_t *hrd_rate, *hrd_buffer;
365
    uint8_t *hrd_fullness;
366
    uint8_t range_mapy_flag;
367
    uint8_t range_mapuv_flag;
368
    uint8_t range_mapy;
369
    uint8_t range_mapuv;
370
    //@}
371
} VC1Context;
372

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

    
386
    for(i = 0; i < len && get_bits1(gb) != stop; i++);
387
    return i;
388
/*  int i = 0, tmp = !stop;
389

390
  while (i != len && tmp != stop)
391
  {
392
    tmp = get_bits(gb, 1);
393
    i++;
394
  }
395
  if (i == len && tmp != stop) return len+1;
396
  return i;*/
397
#else
398
  unsigned int buf;
399
  int log;
400

    
401
  OPEN_READER(re, gb);
402
  UPDATE_CACHE(re, gb);
403
  buf=GET_CACHE(re, gb); //Still not sure
404
  if (stop) buf = ~buf;
405

    
406
  log= av_log2(-buf); //FIXME: -?
407
  if (log < limit){
408
    LAST_SKIP_BITS(re, gb, log+1);
409
    CLOSE_READER(re, gb);
410
    return log;
411
  }
412

    
413
  LAST_SKIP_BITS(re, gb, limit);
414
  CLOSE_READER(re, gb);
415
  return limit;
416
#endif
417
}
418

    
419
static inline int decode210(GetBitContext *gb){
420
    int n;
421
    n = get_bits1(gb);
422
    if (n == 1)
423
        return 0;
424
    else
425
        return 2 - get_bits1(gb);
426
}
427

    
428
/**
429
 * Init VC-1 specific tables and VC1Context members
430
 * @param v The VC1Context to initialize
431
 * @return Status
432
 */
433
static int vc1_init_common(VC1Context *v)
434
{
435
    static int done = 0;
436
    int i = 0;
437

    
438
    /* Set the bit planes */
439
    v->mv_type_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
440
    v->direct_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
441
    v->skip_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
442
    v->ac_pred_plane = v->over_flags_plane = (struct BitPlane) { NULL, 0, 0, 0 };
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
/** Allocate the buffer from a bitplane, given its dimensions
524
 * @param bp Bitplane which buffer is to allocate
525
 * @param[in] width Width of the buffer
526
 * @param[in] height Height of the buffer
527
 * @return Status
528
 * @todo TODO: Take into account stride
529
 * @todo TODO: Allow use of external buffers ?
530
 */
531
static int alloc_bitplane(BitPlane *bp, int width, int height)
532
{
533
    if (!bp || bp->width<0 || bp->height<0) return -1;
534
    bp->data = (uint8_t*)av_malloc(width*height);
535
    if (!bp->data) return -1;
536
    bp->width = bp->stride = width;
537
    bp->height = height;
538
    return 0;
539
}
540

    
541
/** Free the bitplane's buffer
542
 * @param bp Bitplane which buffer is to free
543
 */
544
static void free_bitplane(BitPlane *bp)
545
{
546
    bp->width = bp->stride = bp->height = 0;
547
    if (bp->data) av_freep(&bp->data);
548
}
549

    
550
/** Decode rows by checking if they are skipped
551
 * @param plane Buffer to store decoded bits
552
 * @param[in] width Width of this buffer
553
 * @param[in] height Height of this buffer
554
 * @param[in] stride of this buffer
555
 */
556
static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
557
    int x, y;
558

    
559
    for (y=0; y<height; y++){
560
        if (!get_bits(gb, 1)) //rowskip
561
            memset(plane, 0, width);
562
        else
563
            for (x=0; x<width; x++)
564
                plane[x] = get_bits(gb, 1);
565
        plane += stride;
566
    }
567
}
568

    
569
/** Decode columns by checking if they are skipped
570
 * @param plane Buffer to store decoded bits
571
 * @param[in] width Width of this buffer
572
 * @param[in] height Height of this buffer
573
 * @param[in] stride of this buffer
574
 * @fixme FIXME: Optimize
575
 */
576
static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
577
    int x, y;
578

    
579
    for (x=0; x<width; x++){
580
        if (!get_bits(gb, 1)) //colskip
581
            for (y=0; y<height; y++)
582
                plane[y*stride] = 0;
583
        else
584
            for (y=0; y<height; y++)
585
                plane[y*stride] = get_bits(gb, 1);
586
        plane ++;
587
    }
588
}
589

    
590
/** Decode a bitplane's bits
591
 * @param bp Bitplane where to store the decode bits
592
 * @param v VC-1 context for bit reading and logging
593
 * @return Status
594
 * @fixme FIXME: Optimize
595
 * @todo TODO: Decide if a struct is needed
596
 */
597
static int bitplane_decoding(BitPlane *bp, VC1Context *v)
598
{
599
    GetBitContext *gb = &v->s.gb;
600

    
601
    int imode, x, y, code, offset;
602
    uint8_t invert, *planep = bp->data;
603

    
604
    invert = get_bits(gb, 1);
605
    imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
606

    
607
    bp->is_raw = 0;
608
    switch (imode)
609
    {
610
    case IMODE_RAW:
611
        //Data is actually read in the MB layer (same for all tests == "raw")
612
        bp->is_raw = 1; //invert ignored
613
        return invert;
614
    case IMODE_DIFF2:
615
    case IMODE_NORM2:
616
        if ((bp->height * bp->width) & 1)
617
        {
618
            *planep++ = get_bits(gb, 1);
619
            offset = 1;
620
        }
621
        else offset = 0;
622
        // decode bitplane as one long line
623
        for (y = offset; y < bp->height * bp->width; y += 2) {
624
            code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
625
            *planep++ = code & 1;
626
            offset++;
627
            if(offset == bp->width) {
628
                offset = 0;
629
                planep += bp->stride - bp->width;
630
            }
631
            *planep++ = code >> 1;
632
            offset++;
633
            if(offset == bp->width) {
634
                offset = 0;
635
                planep += bp->stride - bp->width;
636
            }
637
        }
638
        break;
639
    case IMODE_DIFF6:
640
    case IMODE_NORM6:
641
        if(!(bp->height % 3) && (bp->width % 3)) { // use 2x3 decoding
642
            for(y = 0; y < bp->height; y+= 3) {
643
                for(x = bp->width & 1; x < bp->width; x += 2) {
644
                    code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
645
                    if(code < 0){
646
                        av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
647
                        return -1;
648
                    }
649
                    planep[x + 0] = (code >> 0) & 1;
650
                    planep[x + 1] = (code >> 1) & 1;
651
                    planep[x + 0 + bp->stride] = (code >> 2) & 1;
652
                    planep[x + 1 + bp->stride] = (code >> 3) & 1;
653
                    planep[x + 0 + bp->stride * 2] = (code >> 4) & 1;
654
                    planep[x + 1 + bp->stride * 2] = (code >> 5) & 1;
655
                }
656
                planep += bp->stride * 3;
657
            }
658
            if(bp->width & 1) decode_colskip(bp->data, 1, bp->height, bp->stride, &v->s.gb);
659
        } else { // 3x2
660
            for(y = bp->height & 1; y < bp->height; y += 2) {
661
                for(x = bp->width % 3; x < bp->width; x += 3) {
662
                    code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
663
                    if(code < 0){
664
                        av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
665
                        return -1;
666
                    }
667
                    planep[x + 0] = (code >> 0) & 1;
668
                    planep[x + 1] = (code >> 1) & 1;
669
                    planep[x + 2] = (code >> 2) & 1;
670
                    planep[x + 0 + bp->stride] = (code >> 3) & 1;
671
                    planep[x + 1 + bp->stride] = (code >> 4) & 1;
672
                    planep[x + 2 + bp->stride] = (code >> 5) & 1;
673
                }
674
                planep += bp->stride * 2;
675
            }
676
            x = bp->width % 3;
677
            if(x) decode_colskip(bp->data  ,             x, bp->height    , bp->stride, &v->s.gb);
678
            if(bp->height & 1) decode_rowskip(bp->data+x, bp->width - x, bp->height & 1, bp->stride, &v->s.gb);
679
        }
680
        break;
681
    case IMODE_ROWSKIP:
682
        decode_rowskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
683
        break;
684
    case IMODE_COLSKIP:
685
        decode_colskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
686
        break;
687
    default: break;
688
    }
689

    
690
    /* Applying diff operator */
691
    if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
692
    {
693
        planep = bp->data;
694
        planep[0] ^= invert;
695
        for (x=1; x<bp->width; x++)
696
            planep[x] ^= planep[x-1];
697
        for (y=1; y<bp->height; y++)
698
        {
699
            planep += bp->stride;
700
            planep[0] ^= planep[-bp->stride];
701
            for (x=1; x<bp->width; x++)
702
            {
703
                if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;
704
                else                                     planep[x] ^= planep[x-1];
705
            }
706
        }
707
    }
708
    else if (invert)
709
    {
710
        planep = bp->data;
711
        for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride
712
    }
713
    return (imode<<1) + invert;
714
}
715
/** @} */ //Bitplane group
716

    
717
/***********************************************************************/
718
/** VOP Dquant decoding
719
 * @param v VC-1 Context
720
 */
721
static int vop_dquant_decoding(VC1Context *v)
722
{
723
    GetBitContext *gb = &v->s.gb;
724
    int pqdiff;
725

    
726
    //variable size
727
    if (v->dquant == 2)
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
    else
734
    {
735
        v->dquantfrm = get_bits(gb, 1);
736
        if ( v->dquantfrm )
737
        {
738
            v->dqprofile = get_bits(gb, 2);
739
            switch (v->dqprofile)
740
            {
741
            case DQPROFILE_SINGLE_EDGE:
742
            case DQPROFILE_DOUBLE_EDGES:
743
                v->dqsbedge = get_bits(gb, 2);
744
                break;
745
            case DQPROFILE_ALL_MBS:
746
                v->dqbilevel = get_bits(gb, 1);
747
            default: break; //Forbidden ?
748
            }
749
            if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
750
            {
751
                pqdiff = get_bits(gb, 3);
752
                if (pqdiff == 7) v->altpq = get_bits(gb, 5);
753
                else v->altpq = v->pq + pqdiff + 1;
754
            }
755
        }
756
    }
757
    return 0;
758
}
759

    
760

    
761
/** Do inverse transform
762
 */
763
static void vc1_inv_trans(DCTELEM block[64], int M, int N)
764
{
765
    int i;
766
    register int t1,t2,t3,t4,t5,t6,t7,t8;
767
    DCTELEM *src, *dst;
768

    
769
    src = block;
770
    dst = block;
771
    if(M==4){
772
        for(i = 0; i < N; i++){
773
            t1 = 17 * (src[0] + src[2]);
774
            t2 = 17 * (src[0] - src[2]);
775
            t3 = 22 * src[1];
776
            t4 = 22 * src[3];
777
            t5 = 10 * src[1];
778
            t6 = 10 * src[3];
779

    
780
            dst[0] = (t1 + t3 + t6 + 4) >> 3;
781
            dst[1] = (t2 - t4 + t5 + 4) >> 3;
782
            dst[2] = (t2 + t4 - t5 + 4) >> 3;
783
            dst[3] = (t1 - t3 - t6 + 4) >> 3;
784

    
785
            src += 8;
786
            dst += 8;
787
        }
788
    }else{
789
        for(i = 0; i < N; i++){
790
            t1 = 12 * (src[0] + src[4]);
791
            t2 = 12 * (src[0] - src[4]);
792
            t3 = 16 * src[2] +  6 * src[6];
793
            t4 =  6 * src[2] - 16 * src[6];
794

    
795
            t5 = t1 + t3;
796
            t6 = t2 + t4;
797
            t7 = t2 - t4;
798
            t8 = t1 - t3;
799

    
800
            t1 = 16 * src[1] + 15 * src[3] +  9 * src[5] +  4 * src[7];
801
            t2 = 15 * src[1] -  4 * src[3] - 16 * src[5] -  9 * src[7];
802
            t3 =  9 * src[1] - 16 * src[3] +  4 * src[5] + 15 * src[7];
803
            t4 =  4 * src[1] -  9 * src[3] + 15 * src[5] - 16 * src[7];
804

    
805
            dst[0] = (t5 + t1 + 4) >> 3;
806
            dst[1] = (t6 + t2 + 4) >> 3;
807
            dst[2] = (t7 + t3 + 4) >> 3;
808
            dst[3] = (t8 + t4 + 4) >> 3;
809
            dst[4] = (t8 - t4 + 4) >> 3;
810
            dst[5] = (t7 - t3 + 4) >> 3;
811
            dst[6] = (t6 - t2 + 4) >> 3;
812
            dst[7] = (t5 - t1 + 4) >> 3;
813

    
814
            src += 8;
815
            dst += 8;
816
        }
817
    }
818

    
819
    src = block;
820
    dst = block;
821
    if(N==4){
822
        for(i = 0; i < M; i++){
823
            t1 = 17 * (src[ 0] + src[16]);
824
            t2 = 17 * (src[ 0] - src[16]);
825
            t3 = 22 * src[ 8];
826
            t4 = 22 * src[24];
827
            t5 = 10 * src[ 8];
828
            t6 = 10 * src[24];
829

    
830
            dst[ 0] = (t1 + t3 + t6 + 64) >> 7;
831
            dst[ 8] = (t2 - t4 + t5 + 64) >> 7;
832
            dst[16] = (t2 + t4 - t5 + 64) >> 7;
833
            dst[24] = (t1 - t3 - t6 + 64) >> 7;
834

    
835
            src ++;
836
            dst ++;
837
        }
838
    }else{
839
        for(i = 0; i < M; i++){
840
            t1 = 12 * (src[ 0] + src[32]);
841
            t2 = 12 * (src[ 0] - src[32]);
842
            t3 = 16 * src[16] +  6 * src[48];
843
            t4 =  6 * src[16] - 16 * src[48];
844

    
845
            t5 = t1 + t3;
846
            t6 = t2 + t4;
847
            t7 = t2 - t4;
848
            t8 = t1 - t3;
849

    
850
            t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
851
            t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
852
            t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
853
            t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
854

    
855
            dst[ 0] = (t5 + t1 + 64) >> 7;
856
            dst[ 8] = (t6 + t2 + 64) >> 7;
857
            dst[16] = (t7 + t3 + 64) >> 7;
858
            dst[24] = (t8 + t4 + 64) >> 7;
859
            dst[32] = (t8 - t4 + 64 + 1) >> 7;
860
            dst[40] = (t7 - t3 + 64 + 1) >> 7;
861
            dst[48] = (t6 - t2 + 64 + 1) >> 7;
862
            dst[56] = (t5 - t1 + 64 + 1) >> 7;
863

    
864
            src++;
865
            dst++;
866
        }
867
    }
868
}
869

    
870
/** Apply overlap transform
871
 * @todo optimize
872
 * @todo move to DSPContext
873
 */
874
static void vc1_overlap_block(MpegEncContext *s, DCTELEM block[64], int n, int do_hor, int do_vert)
875
{
876
    int i;
877

    
878
    if(do_hor) { //TODO
879
    }
880
    if(do_vert) { //TODO
881
    }
882

    
883
    for(i = 0; i < 64; i++)
884
        block[i] += 128;
885
}
886

    
887

    
888
/** Put block onto picture
889
 * @todo move to DSPContext
890
 */
891
static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
892
{
893
    uint8_t *Y;
894
    int ys, us, vs;
895
    DSPContext *dsp = &v->s.dsp;
896

    
897
    ys = v->s.current_picture.linesize[0];
898
    us = v->s.current_picture.linesize[1];
899
    vs = v->s.current_picture.linesize[2];
900
    Y = v->s.dest[0];
901

    
902
    dsp->put_pixels_clamped(block[0], Y, ys);
903
    dsp->put_pixels_clamped(block[1], Y + 8, ys);
904
    Y += ys * 8;
905
    dsp->put_pixels_clamped(block[2], Y, ys);
906
    dsp->put_pixels_clamped(block[3], Y + 8, ys);
907

    
908
    dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
909
    dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
910
}
911

    
912
/** Do motion compensation over 1 macroblock
913
 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
914
 */
915
static void vc1_mc_1mv(VC1Context *v)
916
{
917
    MpegEncContext *s = &v->s;
918
    DSPContext *dsp = &v->s.dsp;
919
    uint8_t *srcY, *srcU, *srcV;
920
    int dxy, mx, my, src_x, src_y;
921
    int width = s->mb_width * 16, height = s->mb_height * 16;
922

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

    
925
    mx = s->mv[0][0][0] >> s->mspel;
926
    my = s->mv[0][0][1] >> s->mspel;
927
    srcY = s->last_picture.data[0];
928
    srcU = s->last_picture.data[1];
929
    srcV = s->last_picture.data[2];
930

    
931
    if(s->mspel) { // hpel mc
932
        dxy = ((my & 1) << 1) | (mx & 1);
933
        src_x = s->mb_x * 16 + (mx >> 1);
934
        src_y = s->mb_y * 16 + (my >> 1);
935
/*        src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
936
        if (src_x == width)
937
            dxy &= ~1;
938
        src_y = clip(src_y, -16, height);
939
        if (src_y == height)
940
            dxy &= ~2;*/
941
        srcY += src_y * s->linesize + src_x;
942
        srcU += (src_y >> 1) * s->uvlinesize + (src_x >> 1);
943
        srcV += (src_y >> 1) * s->uvlinesize + (src_x >> 1);
944

    
945
        if((unsigned)src_x > s->h_edge_pos - (mx&1) - 16
946
           || (unsigned)src_y > s->v_edge_pos - (my&1) - 16){
947
            uint8_t *uvbuf= s->edge_emu_buffer + 18 * s->linesize;
948

    
949
            ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
950
                             src_x, src_y, s->h_edge_pos, s->v_edge_pos);
951
            srcY = s->edge_emu_buffer;
952
            ff_emulated_edge_mc(uvbuf, srcU, s->uvlinesize, 8+1, 8+1,
953
                             src_x >> 1, src_y >> 1, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
954
            ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
955
                             src_x >> 1, src_y >> 1, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
956
            srcU = uvbuf;
957
            srcV = uvbuf + 16;
958
        }
959
        dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
960
        dsp->put_no_rnd_pixels_tab[1][0](s->dest[1], srcU, s->uvlinesize, 8);
961
        dsp->put_no_rnd_pixels_tab[1][0](s->dest[2], srcV, s->uvlinesize, 8);
962
    } else {
963
        int motion_x = mx, motion_y = my, uvdxy, uvsrc_x, uvsrc_y;
964
        dxy = ((motion_y & 3) << 2) | (motion_x & 3);
965
        src_x = s->mb_x * 16 + (mx >> 2);
966
        src_y = s->mb_y * 16 + (my >> 2);
967

    
968
        mx= motion_x/2;
969
        my= motion_y/2;
970

    
971
        mx= (mx>>1)|(mx&1);
972
        my= (my>>1)|(my&1);
973

    
974
        uvdxy= (mx&1) | ((my&1)<<1);
975
        mx>>=1;
976
        my>>=1;
977

    
978
        uvsrc_x = s->mb_x * 8 + mx;
979
        uvsrc_y = s->mb_y * 8 + my;
980

    
981
        srcY = s->last_picture.data[0] +   src_y *   s->linesize +   src_x;
982
        srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
983
        srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
984

    
985
        if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
986
              || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 16  ){
987
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
988
            ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17, 17,
989
                                src_x, src_y, s->h_edge_pos, s->v_edge_pos);
990
            srcY = s->edge_emu_buffer;
991
            ff_emulated_edge_mc(uvbuf, srcU, s->uvlinesize, 9, 9,
992
                                    uvsrc_x, uvsrc_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
993
            ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 9, 9,
994
                                    uvsrc_x, uvsrc_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
995
            srcU = uvbuf;
996
            srcV = uvbuf + 16;
997
        }
998

    
999
        dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
1000
        dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize, 8);
1001
        dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize, 8);
1002
    }
1003
}
1004

    
1005
/**
1006
 * Decode Simple/Main Profiles sequence header
1007
 * @see Figure 7-8, p16-17
1008
 * @param avctx Codec context
1009
 * @param gb GetBit context initialized from Codec context extra_data
1010
 * @return Status
1011
 */
1012
static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1013
{
1014
    VC1Context *v = avctx->priv_data;
1015

    
1016
    av_log(avctx, AV_LOG_INFO, "Header: %0X\n", show_bits(gb, 32));
1017
    v->profile = get_bits(gb, 2);
1018
    if (v->profile == 2)
1019
    {
1020
        av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1021
        return -1;
1022
    }
1023

    
1024
    if (v->profile == PROFILE_ADVANCED)
1025
    {
1026
        v->level = get_bits(gb, 3);
1027
        if(v->level >= 5)
1028
        {
1029
            av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1030
        }
1031
        v->chromaformat = get_bits(gb, 2);
1032
        if (v->chromaformat != 1)
1033
        {
1034
            av_log(avctx, AV_LOG_ERROR,
1035
                   "Only 4:2:0 chroma format supported\n");
1036
            return -1;
1037
        }
1038
    }
1039
    else
1040
    {
1041
        v->res_sm = get_bits(gb, 2); //reserved
1042
        if (v->res_sm)
1043
        {
1044
            av_log(avctx, AV_LOG_ERROR,
1045
                   "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1046
            return -1;
1047
        }
1048
    }
1049

    
1050
    // (fps-2)/4 (->30)
1051
    v->frmrtq_postproc = get_bits(gb, 3); //common
1052
    // (bitrate-32kbps)/64kbps
1053
    v->bitrtq_postproc = get_bits(gb, 5); //common
1054
    v->s.loop_filter = get_bits(gb, 1); //common
1055
    if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1056
    {
1057
        av_log(avctx, AV_LOG_ERROR,
1058
               "LOOPFILTER shell not be enabled in simple profile\n");
1059
    }
1060

    
1061
    if (v->profile < PROFILE_ADVANCED)
1062
    {
1063
        v->res_x8 = get_bits(gb, 1); //reserved
1064
        if (v->res_x8)
1065
        {
1066
            av_log(avctx, AV_LOG_ERROR,
1067
                   "1 for reserved RES_X8 is forbidden\n");
1068
            //return -1;
1069
        }
1070
        v->multires = get_bits(gb, 1);
1071
        v->res_fasttx = get_bits(gb, 1);
1072
        if (!v->res_fasttx)
1073
        {
1074
            av_log(avctx, AV_LOG_ERROR,
1075
                   "0 for reserved RES_FASTTX is forbidden\n");
1076
            //return -1;
1077
        }
1078
    }
1079

    
1080
    v->fastuvmc =  get_bits(gb, 1); //common
1081
    if (!v->profile && !v->fastuvmc)
1082
    {
1083
        av_log(avctx, AV_LOG_ERROR,
1084
               "FASTUVMC unavailable in Simple Profile\n");
1085
        return -1;
1086
    }
1087
    v->extended_mv =  get_bits(gb, 1); //common
1088
    if (!v->profile && v->extended_mv)
1089
    {
1090
        av_log(avctx, AV_LOG_ERROR,
1091
               "Extended MVs unavailable in Simple Profile\n");
1092
        return -1;
1093
    }
1094
    v->dquant =  get_bits(gb, 2); //common
1095
    v->vstransform =  get_bits(gb, 1); //common
1096

    
1097
    if (v->profile < PROFILE_ADVANCED)
1098
    {
1099
        v->res_transtab = get_bits(gb, 1);
1100
        if (v->res_transtab)
1101
        {
1102
            av_log(avctx, AV_LOG_ERROR,
1103
                   "1 for reserved RES_TRANSTAB is forbidden\n");
1104
            return -1;
1105
        }
1106
    }
1107

    
1108
    v->overlap = get_bits(gb, 1); //common
1109

    
1110
    if (v->profile < PROFILE_ADVANCED)
1111
    {
1112
        v->s.resync_marker = get_bits(gb, 1);
1113
        v->rangered = get_bits(gb, 1);
1114
        if (v->rangered && v->profile == PROFILE_SIMPLE)
1115
        {
1116
            av_log(avctx, AV_LOG_INFO,
1117
                   "RANGERED should be set to 0 in simple profile\n");
1118
        }
1119
    }
1120

    
1121
    v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1122
    v->quantizer_mode = get_bits(gb, 2); //common
1123

    
1124
    if (v->profile < PROFILE_ADVANCED)
1125
    {
1126
        v->finterpflag = get_bits(gb, 1); //common
1127
        v->res_rtm_flag = get_bits(gb, 1); //reserved
1128
        if (!v->res_rtm_flag)
1129
        {
1130
            av_log(avctx, AV_LOG_ERROR,
1131
                   "0 for reserved RES_RTM_FLAG is forbidden\n");
1132
            //return -1;
1133
        }
1134
        av_log(avctx, AV_LOG_DEBUG,
1135
               "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1136
               "LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"
1137
               "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1138
               "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1139
               v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1140
               v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1141
               v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1142
               v->dquant, v->quantizer_mode, avctx->max_b_frames
1143
               );
1144
        return 0;
1145
    }
1146
    return -1;
1147
}
1148

    
1149

    
1150
static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1151
{
1152
    int pqindex, lowquant, status;
1153

    
1154
    if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1155
    skip_bits(gb, 2); //framecnt unused
1156
    v->rangeredfrm = 0;
1157
    if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1158
    v->s.pict_type = get_bits(gb, 1);
1159
    if (v->s.avctx->max_b_frames) {
1160
        if (!v->s.pict_type) {
1161
            if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1162
            else v->s.pict_type = B_TYPE;
1163
        } else v->s.pict_type = P_TYPE;
1164
    } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1165

    
1166
    if(v->s.pict_type == I_TYPE)
1167
        get_bits(gb, 7); // skip buffer fullness
1168

    
1169
    /* Quantizer stuff */
1170
    pqindex = get_bits(gb, 5);
1171
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1172
        v->pq = pquant_table[0][pqindex];
1173
    else
1174
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1175

    
1176
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1177
        v->pquantizer = pqindex < 9;
1178
    if (v->quantizer_mode == QUANT_UNIFORM || v->quantizer_mode == QUANT_NON_UNIFORM)
1179
        v->pquantizer = v->quantizer_mode == QUANT_UNIFORM;
1180
    v->pqindex = pqindex;
1181
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1182
    else v->halfpq = 0;
1183
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1184
        v->pquantizer = get_bits(gb, 1);
1185
    v->dquantfrm = 0;
1186

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

    
1190
    //TODO: complete parsing for P/B/BI frames
1191
    switch(v->s.pict_type) {
1192
    case P_TYPE:
1193
        if (v->pq < 5) v->tt_index = 0;
1194
        else if(v->pq < 13) v->tt_index = 1;
1195
        else v->tt_index = 2;
1196

    
1197
        if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1198
        v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1199
        v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1200
        v->range_x = 1 << (v->k_x - 1);
1201
        v->range_y = 1 << (v->k_y - 1);
1202
        if (v->profile == PROFILE_ADVANCED)
1203
        {
1204
            if (v->postprocflag) v->postproc = get_bits(gb, 1);
1205
        }
1206
        else
1207
            if (v->multires) v->respic = get_bits(gb, 2);
1208
        lowquant = (v->pq > 12) ? 0 : 1;
1209
        v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1210
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1211
        {
1212
            v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];
1213
            v->lumscale = get_bits(gb, 6);
1214
            v->lumshift = get_bits(gb, 6);
1215
        }
1216
        if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1217
            v->s.mspel = 1;
1218
        else
1219
            v->s.mspel = 0;
1220

    
1221
if(v->mv_mode != MV_PMODE_1MV && v->mv_mode != MV_PMODE_1MV_HPEL && v->mv_mode != MV_PMODE_1MV_HPEL_BILIN) {
1222
    av_log(v->s.avctx, AV_LOG_ERROR, "Only 1MV P-frames are supported by now\n");
1223
    return -1;
1224
}
1225
        if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1226
                 v->mv_mode2 == MV_PMODE_MIXED_MV)
1227
                || v->mv_mode == MV_PMODE_MIXED_MV)
1228
        {
1229
            status = bitplane_decoding(&v->mv_type_mb_plane, v);
1230
            if (status < 0) return -1;
1231
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1232
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1233
        }
1234
        status = bitplane_decoding(&v->skip_mb_plane, v);
1235
        if (status < 0) return -1;
1236
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1237
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1238

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

    
1243
        if (v->dquant)
1244
        {
1245
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1246
            vop_dquant_decoding(v);
1247
        }
1248

    
1249
        v->ttfrm = 0; //FIXME Is that so ?
1250
        if (v->vstransform)
1251
        {
1252
            v->ttmbf = get_bits(gb, 1);
1253
            if (v->ttmbf)
1254
            {
1255
                v->ttfrm = get_bits(gb, 2);
1256
            }
1257
        }
1258
        break;
1259
    case B_TYPE:
1260
        break;
1261
    }
1262

    
1263
    /* AC Syntax */
1264
    v->c_ac_table_index = decode012(gb);
1265
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1266
    {
1267
        v->y_ac_table_index = decode012(gb);
1268
    }
1269
    /* DC Syntax */
1270
    v->s.dc_table_index = get_bits(gb, 1);
1271

    
1272
    return 0;
1273
}
1274

    
1275
/***********************************************************************/
1276
/**
1277
 * @defgroup block VC-1 Block-level functions
1278
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1279
 * @todo TODO: Integrate to MpegEncContext facilities
1280
 * @{
1281
 */
1282

    
1283
/**
1284
 * @def GET_MQUANT
1285
 * @brief Get macroblock-level quantizer scale
1286
 * @warning XXX: qdiff to the frame quant, not previous quant ?
1287
 * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1288
 */
1289
#define GET_MQUANT()                                           \
1290
  if (v->dquantfrm)                                            \
1291
  {                                                            \
1292
    if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1293
    {                                                          \
1294
      if (v->dqbilevel)                                        \
1295
      {                                                        \
1296
        mquant = (get_bits(gb, 1)) ? v->pq : v->altpq;         \
1297
      }                                                        \
1298
      else                                                     \
1299
      {                                                        \
1300
        mqdiff = get_bits(gb, 3);                              \
1301
        if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1302
        else mquant = get_bits(gb, 5);                         \
1303
      }                                                        \
1304
    }                                                          \
1305
    else mquant = v->pq;                                       \
1306
  }
1307

    
1308
/**
1309
 * @def GET_MVDATA(_dmv_x, _dmv_y)
1310
 * @brief Get MV differentials
1311
 * @see MVDATA decoding from 8.3.5.2, p(1)20
1312
 * @param _dmv_x Horizontal differential for decoded MV
1313
 * @param _dmv_y Vertical differential for decoded MV
1314
 * @todo TODO: Use MpegEncContext arrays to store them
1315
 */
1316
#define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1317
  index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1318
                       VC1_MV_DIFF_VLC_BITS, 2);                    \
1319
  if (index > 36)                                                   \
1320
  {                                                                 \
1321
    mb_has_coeffs = 1;                                              \
1322
    index -= 37;                                                    \
1323
  }                                                                 \
1324
  else mb_has_coeffs = 0;                                           \
1325
  s->mb_intra = 0;                                                  \
1326
  if (!index) { _dmv_x = _dmv_y = 0; }                              \
1327
  else if (index == 35)                                             \
1328
  {                                                                 \
1329
    _dmv_x = get_bits(gb, v->k_x - s->mspel);                       \
1330
    _dmv_y = get_bits(gb, v->k_y - s->mspel);                       \
1331
  }                                                                 \
1332
  else if (index == 36)                                             \
1333
  {                                                                 \
1334
    _dmv_x = 0;                                                     \
1335
    _dmv_y = 0;                                                     \
1336
    s->mb_intra = 1;                                                \
1337
  }                                                                 \
1338
  else                                                              \
1339
  {                                                                 \
1340
    index1 = index%6;                                               \
1341
    if (s->mspel && index1 == 5) val = 1;                           \
1342
    else                         val = 0;                           \
1343
    val = get_bits(gb, size_table[index1] - val);                   \
1344
    sign = 0 - (val&1);                                             \
1345
    _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1346
                                                                    \
1347
    index1 = index/6;                                               \
1348
    if (s->mspel && index1 == 5) val = 1;                           \
1349
    else                          val = 0;                          \
1350
    val = get_bits(gb, size_table[index1] - val);                   \
1351
    sign = 0 - (val&1);                                             \
1352
    _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1353
  }
1354

    
1355
/** Predict and set motion vector
1356
 */
1357
static inline void vc1_pred_mv(MpegEncContext *s, int dmv_x, int dmv_y, int mv1, int r_x, int r_y)
1358
{
1359
    int xy, wrap, off;
1360
    int16_t *A, *B, *C;
1361
    int px, py;
1362
    int sum;
1363
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1364

    
1365
    /* scale MV difference to be quad-pel */
1366
    dmv_x <<= s->mspel;
1367
    dmv_y <<= s->mspel;
1368

    
1369
    wrap = s->b8_stride;
1370
    xy = s->block_index[0];
1371

    
1372
    C = s->current_picture.motion_val[0][xy - (1 << mv1)];
1373
    A = s->current_picture.motion_val[0][xy - (wrap << mv1)];
1374
    off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1375
    B = s->current_picture.motion_val[0][xy + ((off - wrap) << mv1)];
1376

    
1377
    if(!s->first_slice_line) { // predictor A is not out of bounds
1378
        if(s->mb_width == 1) {
1379
            px = A[0];
1380
            py = A[1];
1381
        } else {
1382
            px = mid_pred(A[0], B[0], C[0]);
1383
            py = mid_pred(A[1], B[1], C[1]);
1384
        }
1385
    } else if(s->mb_x) { // predictor C is not out of bounds
1386
        px = C[0];
1387
        py = C[1];
1388
    } else {
1389
        px = py = 0;
1390
    }
1391
    if(s->mb_intra) px = py = 0;
1392

    
1393
    /* Pullback MV as specified in 8.3.5.3.4 */
1394
    {
1395
        int qx, qy, X, Y;
1396
        qx = s->mb_x << 6; //FIXME: add real block coords for 4MV mode
1397
        qy = s->mb_y << 6;
1398
        X = (s->mb_width << 6) - 4;
1399
        Y = (s->mb_height << 6) - 4;
1400
        if(mv1) {
1401
            if(qx + px < -60) px = -60 - qx;
1402
            if(qy + py < -60) py = -60 - qy;
1403
        } else {
1404
            if(qx + px < -28) px = -28 - qx;
1405
            if(qy + py < -28) py = -28 - qy;
1406
        }
1407
        if(qx + px > X) px = X - qx;
1408
        if(qy + py > Y) py = Y - qy;
1409
    }
1410
    /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1411
    if(!s->mb_intra && !s->first_slice_line && s->mb_x) {
1412
        if(IS_INTRA(s->current_picture.mb_type[mb_pos - s->mb_stride]))
1413
            sum = ABS(px) + ABS(py);
1414
        else
1415
            sum = ABS(px - A[0]) + ABS(py - A[1]);
1416
        if(sum > 32) {
1417
            if(get_bits1(&s->gb)) {
1418
                px = A[0];
1419
                py = A[1];
1420
            } else {
1421
                px = C[0];
1422
                py = C[1];
1423
            }
1424
        } else {
1425
            if(IS_INTRA(s->current_picture.mb_type[mb_pos - 1]))
1426
                sum = ABS(px) + ABS(py);
1427
            else
1428
                sum = ABS(px - C[0]) + ABS(py - C[1]);
1429
            if(sum > 32) {
1430
                if(get_bits1(&s->gb)) {
1431
                    px = A[0];
1432
                    py = A[1];
1433
                } else {
1434
                    px = C[0];
1435
                    py = C[1];
1436
                }
1437
            }
1438
        }
1439
    }
1440
    /* store MV using signed modulus of MV range defined in 4.11 */
1441
    s->mv[0][0][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1442
    s->mv[0][0][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1443
}
1444

    
1445
/** Get predicted DC value for I-frames only
1446
 * prediction dir: left=0, top=1
1447
 * @param s MpegEncContext
1448
 * @param[in] n block index in the current MB
1449
 * @param dc_val_ptr Pointer to DC predictor
1450
 * @param dir_ptr Prediction direction for use in AC prediction
1451
 */
1452
static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1453
                              int16_t **dc_val_ptr, int *dir_ptr)
1454
{
1455
    int a, b, c, wrap, pred, scale;
1456
    int16_t *dc_val;
1457
    static const uint16_t dcpred[32] = {
1458
    -1, 1024,  512,  341,  256,  205,  171,  146,  128,
1459
         114,  102,   93,   85,   79,   73,   68,   64,
1460
          60,   57,   54,   51,   49,   47,   45,   43,
1461
          41,   39,   38,   37,   35,   34,   33
1462
    };
1463

    
1464
    /* find prediction - wmv3_dc_scale always used here in fact */
1465
    if (n < 4)     scale = s->y_dc_scale;
1466
    else           scale = s->c_dc_scale;
1467

    
1468
    wrap = s->block_wrap[n];
1469
    dc_val= s->dc_val[0] + s->block_index[n];
1470

    
1471
    /* B A
1472
     * C X
1473
     */
1474
    c = dc_val[ - 1];
1475
    b = dc_val[ - 1 - wrap];
1476
    a = dc_val[ - wrap];
1477

    
1478
    if (pq < 9 || !overlap)
1479
    {
1480
        /* Set outer values */
1481
        if (!s->mb_y && (n!=2 && n!=3)) b=a=dcpred[scale];
1482
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1483
    }
1484
    else
1485
    {
1486
        /* Set outer values */
1487
        if (!s->mb_y && (n!=2 && n!=3)) b=a=0;
1488
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1489
    }
1490

    
1491
    if (abs(a - b) <= abs(b - c)) {
1492
        pred = c;
1493
        *dir_ptr = 1;//left
1494
    } else {
1495
        pred = a;
1496
        *dir_ptr = 0;//top
1497
    }
1498

    
1499
    /* update predictor */
1500
    *dc_val_ptr = &dc_val[0];
1501
    return pred;
1502
}
1503

    
1504

    
1505
/** Get predicted DC value
1506
 * prediction dir: left=0, top=1
1507
 * @param s MpegEncContext
1508
 * @param[in] n block index in the current MB
1509
 * @param dc_val_ptr Pointer to DC predictor
1510
 * @param dir_ptr Prediction direction for use in AC prediction
1511
 */
1512
static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1513
                              int a_avail, int c_avail,
1514
                              int16_t **dc_val_ptr, int *dir_ptr)
1515
{
1516
    int a, b, c, wrap, pred, scale;
1517
    int16_t *dc_val;
1518
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1519
    int mb_pos2, q1, q2;
1520

    
1521
    /* find prediction - wmv3_dc_scale always used here in fact */
1522
    if (n < 4)     scale = s->y_dc_scale;
1523
    else           scale = s->c_dc_scale;
1524

    
1525
    wrap = s->block_wrap[n];
1526
    dc_val= s->dc_val[0] + s->block_index[n];
1527

    
1528
    /* B A
1529
     * C X
1530
     */
1531
    c = dc_val[ - 1];
1532
    b = dc_val[ - 1 - wrap];
1533
    a = dc_val[ - wrap];
1534

    
1535
    if(a_avail && c_avail) {
1536
        if(abs(a - b) <= abs(b - c)) {
1537
            pred = c;
1538
            *dir_ptr = 1;//left
1539
        } else {
1540
            pred = a;
1541
            *dir_ptr = 0;//top
1542
        }
1543
    } else if(a_avail) {
1544
        pred = a;
1545
        *dir_ptr = 0;//top
1546
    } else if(c_avail) {
1547
        pred = c;
1548
        *dir_ptr = 1;//left
1549
    } else {
1550
        pred = 0;
1551
        *dir_ptr = 1;//left
1552
    }
1553

    
1554
    /* scale coeffs if needed */
1555
    mb_pos2 = mb_pos - *dir_ptr - (1 - *dir_ptr) * s->mb_stride;
1556
    q1 = s->current_picture.qscale_table[mb_pos];
1557
    q2 = s->current_picture.qscale_table[mb_pos2];
1558
    if(0 && q1 && q2 && q1 != q2) {
1559
        q1 = s->y_dc_scale_table[q1];
1560
        q2 = s->y_dc_scale_table[q2];
1561
        pred = (pred * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1562
    }
1563

    
1564
    /* update predictor */
1565
    *dc_val_ptr = &dc_val[0];
1566
    return pred;
1567
}
1568

    
1569

    
1570
/**
1571
 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
1572
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1573
 * @todo TODO: Integrate to MpegEncContext facilities
1574
 * @{
1575
 */
1576

    
1577
static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1578
{
1579
    int xy, wrap, pred, a, b, c;
1580

    
1581
    xy = s->block_index[n];
1582
    wrap = s->b8_stride;
1583

    
1584
    /* B C
1585
     * A X
1586
     */
1587
    a = s->coded_block[xy - 1       ];
1588
    b = s->coded_block[xy - 1 - wrap];
1589
    c = s->coded_block[xy     - wrap];
1590

    
1591
    if (b == c) {
1592
        pred = a;
1593
    } else {
1594
        pred = c;
1595
    }
1596

    
1597
    /* store value */
1598
    *coded_block_ptr = &s->coded_block[xy];
1599

    
1600
    return pred;
1601
}
1602

    
1603
/**
1604
 * Decode one AC coefficient
1605
 * @param v The VC1 context
1606
 * @param last Last coefficient
1607
 * @param skip How much zero coefficients to skip
1608
 * @param value Decoded AC coefficient value
1609
 * @see 8.1.3.4
1610
 */
1611
static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
1612
{
1613
    GetBitContext *gb = &v->s.gb;
1614
    int index, escape, run = 0, level = 0, lst = 0;
1615

    
1616
    index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1617
    if (index != vc1_ac_sizes[codingset] - 1) {
1618
        run = vc1_index_decode_table[codingset][index][0];
1619
        level = vc1_index_decode_table[codingset][index][1];
1620
        lst = index >= vc1_last_decode_table[codingset];
1621
        if(get_bits(gb, 1))
1622
            level = -level;
1623
    } else {
1624
        escape = decode210(gb);
1625
        if (escape == 0) {
1626
            index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1627
            run = vc1_index_decode_table[codingset][index][0];
1628
            level = vc1_index_decode_table[codingset][index][1];
1629
            lst = index >= vc1_last_decode_table[codingset];
1630
            if(lst)
1631
                level += vc1_last_delta_level_table[codingset][run];
1632
            else
1633
                level += vc1_delta_level_table[codingset][run];
1634
            if(get_bits(gb, 1))
1635
                level = -level;
1636
        } else if (escape == 1) {
1637
            index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1638
            run = vc1_index_decode_table[codingset][index][0];
1639
            level = vc1_index_decode_table[codingset][index][1];
1640
            lst = index >= vc1_last_decode_table[codingset];
1641
            if(lst)
1642
                run += vc1_last_delta_run_table[codingset][level] + 1;
1643
            else
1644
                run += vc1_delta_run_table[codingset][level] + 1;
1645
            if(get_bits(gb, 1))
1646
                level = -level;
1647
        } else {
1648
            int sign;
1649
            lst = get_bits(gb, 1);
1650
            if(v->s.esc3_level_length == 0) {
1651
                if(v->pq < 8 || v->dquantfrm) { // table 59
1652
                    v->s.esc3_level_length = get_bits(gb, 3);
1653
                    if(!v->s.esc3_level_length)
1654
                        v->s.esc3_level_length = get_bits(gb, 2) + 8;
1655
                } else { //table 60
1656
                    v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
1657
                }
1658
                v->s.esc3_run_length = 3 + get_bits(gb, 2);
1659
            }
1660
            run = get_bits(gb, v->s.esc3_run_length);
1661
            sign = get_bits(gb, 1);
1662
            level = get_bits(gb, v->s.esc3_level_length);
1663
            if(sign)
1664
                level = -level;
1665
        }
1666
    }
1667

    
1668
    *last = lst;
1669
    *skip = run;
1670
    *value = level;
1671
}
1672

    
1673
/** Decode intra block in intra frames - should be faster than decode_intra_block
1674
 * @param v VC1Context
1675
 * @param block block to decode
1676
 * @param coded are AC coeffs present or not
1677
 * @param codingset set of VLC to decode data
1678
 */
1679
static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
1680
{
1681
    GetBitContext *gb = &v->s.gb;
1682
    MpegEncContext *s = &v->s;
1683
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
1684
    int run_diff, i;
1685
    int16_t *dc_val;
1686
    int16_t *ac_val, *ac_val2;
1687
    int dcdiff;
1688

    
1689
    /* Get DC differential */
1690
    if (n < 4) {
1691
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1692
    } else {
1693
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1694
    }
1695
    if (dcdiff < 0){
1696
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1697
        return -1;
1698
    }
1699
    if (dcdiff)
1700
    {
1701
        if (dcdiff == 119 /* ESC index value */)
1702
        {
1703
            /* TODO: Optimize */
1704
            if (v->pq == 1) dcdiff = get_bits(gb, 10);
1705
            else if (v->pq == 2) dcdiff = get_bits(gb, 9);
1706
            else dcdiff = get_bits(gb, 8);
1707
        }
1708
        else
1709
        {
1710
            if (v->pq == 1)
1711
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1712
            else if (v->pq == 2)
1713
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1714
        }
1715
        if (get_bits(gb, 1))
1716
            dcdiff = -dcdiff;
1717
    }
1718

    
1719
    /* Prediction */
1720
    dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
1721
    *dc_val = dcdiff;
1722

    
1723
    /* Store the quantized DC coeff, used for prediction */
1724

    
1725
    if (n < 4) {
1726
        block[0] = dcdiff * s->y_dc_scale;
1727
    } else {
1728
        block[0] = dcdiff * s->c_dc_scale;
1729
    }
1730
    /* Skip ? */
1731
    run_diff = 0;
1732
    i = 0;
1733
    if (!coded) {
1734
        goto not_coded;
1735
    }
1736

    
1737
    //AC Decoding
1738
    i = 1;
1739

    
1740
    {
1741
        int last = 0, skip, value;
1742
        const int8_t *zz_table;
1743
        int scale;
1744
        int k;
1745

    
1746
        scale = v->pq * 2 + v->halfpq;
1747

    
1748
        if(v->s.ac_pred) {
1749
            if(!dc_pred_dir)
1750
                zz_table = vc1_horizontal_zz;
1751
            else
1752
                zz_table = vc1_vertical_zz;
1753
        } else
1754
            zz_table = vc1_normal_zz;
1755

    
1756
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1757
        ac_val2 = ac_val;
1758
        if(dc_pred_dir) //left
1759
            ac_val -= 16;
1760
        else //top
1761
            ac_val -= 16 * s->block_wrap[n];
1762

    
1763
        while (!last) {
1764
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
1765
            i += skip;
1766
            if(i > 63)
1767
                break;
1768
            block[zz_table[i++]] = value;
1769
        }
1770

    
1771
        /* apply AC prediction if needed */
1772
        if(s->ac_pred) {
1773
            if(dc_pred_dir) { //left
1774
                for(k = 1; k < 8; k++)
1775
                    block[k << 3] += ac_val[k];
1776
            } else { //top
1777
                for(k = 1; k < 8; k++)
1778
                    block[k] += ac_val[k + 8];
1779
            }
1780
        }
1781
        /* save AC coeffs for further prediction */
1782
        for(k = 1; k < 8; k++) {
1783
            ac_val2[k] = block[k << 3];
1784
            ac_val2[k + 8] = block[k];
1785
        }
1786

    
1787
        /* scale AC coeffs */
1788
        for(k = 1; k < 64; k++)
1789
            if(block[k]) {
1790
                block[k] *= scale;
1791
                if(!v->pquantizer)
1792
                    block[k] += (block[k] < 0) ? -v->pq : v->pq;
1793
            }
1794

    
1795
        if(s->ac_pred) i = 63;
1796
    }
1797

    
1798
not_coded:
1799
    if(!coded) {
1800
        int k, scale;
1801
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1802
        ac_val2 = ac_val;
1803

    
1804
        scale = v->pq * 2 + v->halfpq;
1805
        memset(ac_val2, 0, 16 * 2);
1806
        if(dc_pred_dir) {//left
1807
            ac_val -= 16;
1808
            if(s->ac_pred)
1809
                memcpy(ac_val2, ac_val, 8 * 2);
1810
        } else {//top
1811
            ac_val -= 16 * s->block_wrap[n];
1812
            if(s->ac_pred)
1813
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
1814
        }
1815

    
1816
        /* apply AC prediction if needed */
1817
        if(s->ac_pred) {
1818
            if(dc_pred_dir) { //left
1819
                for(k = 1; k < 8; k++) {
1820
                    block[k << 3] = ac_val[k] * scale;
1821
                    if(!v->pquantizer)
1822
                        block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
1823
                }
1824
            } else { //top
1825
                for(k = 1; k < 8; k++) {
1826
                    block[k] = ac_val[k + 8] * scale;
1827
                    if(!v->pquantizer)
1828
                        block[k] += (block[k] < 0) ? -v->pq : v->pq;
1829
                }
1830
            }
1831
            i = 63;
1832
        }
1833
    }
1834
    s->block_last_index[n] = i;
1835

    
1836
    return 0;
1837
}
1838

    
1839
/** Decode intra block in inter frames - more generic version than vc1_decode_i_block
1840
 * @param v VC1Context
1841
 * @param block block to decode
1842
 * @param coded are AC coeffs present or not
1843
 * @param mquant block quantizer
1844
 * @param codingset set of VLC to decode data
1845
 */
1846
static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
1847
{
1848
    GetBitContext *gb = &v->s.gb;
1849
    MpegEncContext *s = &v->s;
1850
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
1851
    int run_diff, i;
1852
    int16_t *dc_val;
1853
    int16_t *ac_val, *ac_val2;
1854
    int dcdiff;
1855
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1856
    int a_avail, c_avail;
1857

    
1858
    /* XXX: Guard against dumb values of mquant */
1859
    mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
1860

    
1861
    /* Set DC scale - y and c use the same */
1862
    s->y_dc_scale = s->y_dc_scale_table[mquant];
1863
    s->c_dc_scale = s->c_dc_scale_table[mquant];
1864

    
1865
    /* check if prediction blocks A and C are available */
1866
    a_avail = c_avail = 0;
1867
    if((n == 2 || n == 3) || (s->mb_y && IS_INTRA(s->current_picture.mb_type[mb_pos - s->mb_stride])))
1868
        a_avail = 1;
1869
    if((n == 1 || n == 3) || (s->mb_x && IS_INTRA(s->current_picture.mb_type[mb_pos - 1])))
1870
        c_avail = 1;
1871
    /* Get DC differential */
1872
    if (n < 4) {
1873
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1874
    } else {
1875
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1876
    }
1877
    if (dcdiff < 0){
1878
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1879
        return -1;
1880
    }
1881
    if (dcdiff)
1882
    {
1883
        if (dcdiff == 119 /* ESC index value */)
1884
        {
1885
            /* TODO: Optimize */
1886
            if (mquant == 1) dcdiff = get_bits(gb, 10);
1887
            else if (mquant == 2) dcdiff = get_bits(gb, 9);
1888
            else dcdiff = get_bits(gb, 8);
1889
        }
1890
        else
1891
        {
1892
            if (mquant == 1)
1893
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1894
            else if (mquant == 2)
1895
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1896
        }
1897
        if (get_bits(gb, 1))
1898
            dcdiff = -dcdiff;
1899
    }
1900

    
1901
    /* Prediction */
1902
    dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
1903
    *dc_val = dcdiff;
1904

    
1905
    /* Store the quantized DC coeff, used for prediction */
1906

    
1907
    if (n < 4) {
1908
        block[0] = dcdiff * s->y_dc_scale;
1909
    } else {
1910
        block[0] = dcdiff * s->c_dc_scale;
1911
    }
1912
    /* Skip ? */
1913
    run_diff = 0;
1914
    i = 0;
1915
    if (!coded) {
1916
        goto not_coded;
1917
    }
1918

    
1919
    //AC Decoding
1920
    i = 1;
1921

    
1922
    {
1923
        int last = 0, skip, value;
1924
        const int8_t *zz_table;
1925
        int scale;
1926
        int k;
1927

    
1928
        scale = mquant * 2 + v->halfpq;
1929

    
1930
        if(v->s.ac_pred) {
1931
            if(!dc_pred_dir)
1932
                zz_table = vc1_horizontal_zz;
1933
            else
1934
                zz_table = vc1_vertical_zz;
1935
        } else
1936
            zz_table = vc1_normal_zz;
1937

    
1938
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1939
        ac_val2 = ac_val;
1940
        if(dc_pred_dir) //left
1941
            ac_val -= 16;
1942
        else //top
1943
            ac_val -= 16 * s->block_wrap[n];
1944

    
1945
        while (!last) {
1946
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
1947
            i += skip;
1948
            if(i > 63)
1949
                break;
1950
            block[zz_table[i++]] = value;
1951
        }
1952

    
1953
        /* apply AC prediction if needed */
1954
        if(s->ac_pred) {
1955
            /* scale predictors if needed*/
1956
            int mb_pos2, q1, q2;
1957

    
1958
            mb_pos2 = mb_pos - dc_pred_dir - (1 - dc_pred_dir) * s->mb_stride;
1959
            q1 = s->current_picture.qscale_table[mb_pos];
1960
            q2 = s->current_picture.qscale_table[mb_pos2];
1961

    
1962
            if(!c_avail) {
1963
                memset(ac_val, 0, 8 * sizeof(ac_val[0]));
1964
                dc_pred_dir = 0;
1965
            }
1966
            if(!a_avail) {
1967
                memset(ac_val + 8, 0, 8 * sizeof(ac_val[0]));
1968
                dc_pred_dir = 1;
1969
            }
1970
            if(!q1 && q1 && q2 && q1 != q2) {
1971
                q1 = q1 * 2 - 1;
1972
                q2 = q2 * 2 - 1;
1973

    
1974
                if(dc_pred_dir) { //left
1975
                    for(k = 1; k < 8; k++)
1976
                        block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1977
                } else { //top
1978
                    for(k = 1; k < 8; k++)
1979
                        block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1980
                }
1981
            } else {
1982
                if(dc_pred_dir) { //left
1983
                    for(k = 1; k < 8; k++)
1984
                        block[k << 3] += ac_val[k];
1985
                } else { //top
1986
                    for(k = 1; k < 8; k++)
1987
                        block[k] += ac_val[k + 8];
1988
                }
1989
            }
1990
        }
1991
        /* save AC coeffs for further prediction */
1992
        for(k = 1; k < 8; k++) {
1993
            ac_val2[k] = block[k << 3];
1994
            ac_val2[k + 8] = block[k];
1995
        }
1996

    
1997
        /* scale AC coeffs */
1998
        for(k = 1; k < 64; k++)
1999
            if(block[k]) {
2000
                block[k] *= scale;
2001
                if(!v->pquantizer)
2002
                    block[k] += (block[k] < 0) ? -mquant : mquant;
2003
            }
2004

    
2005
        if(s->ac_pred) i = 63;
2006
    }
2007

    
2008
not_coded:
2009
    if(!coded) {
2010
        int k, scale;
2011
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2012
        ac_val2 = ac_val;
2013

    
2014
        if(!c_avail) {
2015
            memset(ac_val, 0, 8 * sizeof(ac_val[0]));
2016
            dc_pred_dir = 0;
2017
        }
2018
        if(!a_avail) {
2019
            memset(ac_val + 8, 0, 8 * sizeof(ac_val[0]));
2020
            dc_pred_dir = 1;
2021
        }
2022

    
2023
        scale = mquant * 2 + v->halfpq;
2024
        memset(ac_val2, 0, 16 * 2);
2025
        if(dc_pred_dir) {//left
2026
            ac_val -= 16;
2027
            if(s->ac_pred)
2028
                memcpy(ac_val2, ac_val, 8 * 2);
2029
        } else {//top
2030
            ac_val -= 16 * s->block_wrap[n];
2031
            if(s->ac_pred)
2032
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2033
        }
2034

    
2035
        /* apply AC prediction if needed */
2036
        if(s->ac_pred) {
2037
            if(dc_pred_dir) { //left
2038
                for(k = 1; k < 8; k++) {
2039
                    block[k << 3] = ac_val[k] * scale;
2040
                    if(!v->pquantizer)
2041
                        block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2042
                }
2043
            } else { //top
2044
                for(k = 1; k < 8; k++) {
2045
                    block[k] = ac_val[k + 8] * scale;
2046
                    if(!v->pquantizer)
2047
                        block[k] += (block[k] < 0) ? -mquant : mquant;
2048
                }
2049
            }
2050
            i = 63;
2051
        }
2052
    }
2053
    s->block_last_index[n] = i;
2054

    
2055
    return 0;
2056
}
2057

    
2058
/** Decode P block
2059
 */
2060
static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
2061
{
2062
    MpegEncContext *s = &v->s;
2063
    GetBitContext *gb = &s->gb;
2064
    int i, j;
2065
    int subblkpat = 0;
2066
    int scale, off, idx, last, skip, value;
2067
    int ttblk = ttmb & 7;
2068

    
2069
    if(ttmb == -1) {
2070
        ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
2071
    }
2072
    if(ttblk == TT_4X4) {
2073
        subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
2074
    }
2075
    if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
2076
        subblkpat = decode012(gb);
2077
        if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
2078
        if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
2079
    }
2080
    scale = 2 * mquant;
2081

    
2082
    // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2083
    if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
2084
        ttblk = TT_8X4;
2085
        subblkpat = 2 - (ttblk == TT_8X4_TOP);
2086
    }
2087
    if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
2088
        ttblk = TT_4X8;
2089
        subblkpat = 2 - (ttblk == TT_4X8_LEFT);
2090
    }
2091

    
2092
    switch(ttblk) {
2093
    case TT_8X8:
2094
        i = 0;
2095
        last = 0;
2096
        while (!last) {
2097
            vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2098
            i += skip;
2099
            if(i > 63)
2100
                break;
2101
            idx = vc1_simple_progressive_8x8_zz[i++];
2102
            block[idx] = value * scale;
2103
        }
2104
        vc1_inv_trans(block, 8, 8);
2105
        break;
2106
    case TT_4X4:
2107
        for(j = 0; j < 4; j++) {
2108
            last = subblkpat & (1 << (3 - j));
2109
            i = 0;
2110
            off = (j & 1) * 4 + (j & 2) * 32;
2111
            while (!last) {
2112
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2113
                i += skip;
2114
                if(i > 15)
2115
                    break;
2116
                idx = vc1_simple_progressive_4x4_zz[i++];
2117
                block[idx + off] = value * scale;
2118
            }
2119
            vc1_inv_trans(block + off, 4, 4);
2120
        }
2121
        break;
2122
    case TT_8X4:
2123
        for(j = 0; j < 2; j++) {
2124
            last = subblkpat & (1 << (1 - j));
2125
            i = 0;
2126
            off = j * 32;
2127
            while (!last) {
2128
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2129
                i += skip;
2130
                if(i > 31)
2131
                    break;
2132
                idx = vc1_simple_progressive_8x4_zz[i++];
2133
                block[idx + off] = value * scale;
2134
            }
2135
            if(!(subblkpat & (1 << (1 - j)))) vc1_inv_trans(block + off, 8, 4);
2136
        }
2137
        break;
2138
    case TT_4X8:
2139
        for(j = 0; j < 2; j++) {
2140
            last = subblkpat & (1 << (1 - j));
2141
            i = 0;
2142
            off = j * 4;
2143
            while (!last) {
2144
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2145
                i += skip;
2146
                if(i > 31)
2147
                    break;
2148
                idx = vc1_simple_progressive_8x4_zz[i++];
2149
                block[idx + off] = value * scale;
2150
            }
2151
            vc1_inv_trans(block + off, 4, 8);
2152
        }
2153
        break;
2154
    }
2155
    return 0;
2156
}
2157

    
2158

    
2159
/** Decode one P-frame MB (in Simple/Main profile)
2160
 * @todo TODO: Extend to AP
2161
 * @fixme FIXME: DC value for inter blocks not set
2162
 */
2163
static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64])
2164
{
2165
    MpegEncContext *s = &v->s;
2166
    GetBitContext *gb = &s->gb;
2167
    int i, j, mb_offset = s->mb_x + s->mb_y*s->mb_width; /* XXX: mb_stride */
2168
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2169
    int cbp; /* cbp decoding stuff */
2170
    int hybrid_pred; /* Prediction types */
2171
    int mqdiff, mquant; /* MB quantization */
2172
    int ttmb = v->ttmb; /* MB Transform type */
2173
    int status;
2174

    
2175
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2176
      offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2177
    int mb_has_coeffs = 1; /* last_flag */
2178
    int dmv_x, dmv_y; /* Differential MV components */
2179
    int index, index1; /* LUT indices */
2180
    int val, sign; /* temp values */
2181
    int first_block = 1;
2182
    int dst_idx, off;
2183

    
2184
    mquant = v->pq; /* Loosy initialization */
2185

    
2186
    if (v->mv_type_mb_plane.is_raw)
2187
        v->mv_type_mb_plane.data[mb_offset] = get_bits(gb, 1);
2188
    if (v->skip_mb_plane.is_raw)
2189
        v->skip_mb_plane.data[mb_offset] = get_bits(gb, 1);
2190
    s->current_picture.mbskip_table[mb_pos] = v->skip_mb_plane.data[mb_offset];
2191
    if (!v->mv_type_mb_plane.data[mb_offset]) /* 1MV mode */
2192
    {
2193
        if (!v->skip_mb_plane.data[mb_offset])
2194
        {
2195
            GET_MVDATA(dmv_x, dmv_y);
2196

    
2197
            s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
2198
            vc1_pred_mv(s, dmv_x, dmv_y, 1, v->range_x, v->range_y);
2199

    
2200
            /* FIXME Set DC val for inter block ? */
2201
            if (s->mb_intra && !mb_has_coeffs)
2202
            {
2203
                GET_MQUANT();
2204
                s->ac_pred = get_bits(gb, 1);
2205
                cbp = 0;
2206
            }
2207
            else if (mb_has_coeffs)
2208
            {
2209
                if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2210
                cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2211
                GET_MQUANT();
2212
            }
2213
            else
2214
            {
2215
                mquant = v->pq;
2216
                cbp = 0;
2217
            }
2218
            s->current_picture.qscale_table[mb_pos] = mquant;
2219

    
2220
            if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2221
                ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2222
                                VC1_TTMB_VLC_BITS, 2);
2223
            s->dsp.clear_blocks(block[0]);
2224
            vc1_mc_1mv(v);
2225
            dst_idx = 0;
2226
            for (i=0; i<6; i++)
2227
            {
2228
                s->dc_val[0][s->block_index[i]] = 0;
2229
                dst_idx += i >> 2;
2230
                val = ((cbp >> (5 - i)) & 1);
2231
                off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2232
                if(s->mb_intra) {
2233
                    vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2234
                    vc1_inv_trans(s->block[i], 8, 8);
2235
                    for(j = 0; j < 64; j++) s->block[i][j] += 128;
2236
                    s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2237
                } else if(val) {
2238
                    vc1_decode_p_block(v, block[i], i, mquant, ttmb, first_block);
2239
                    if(!v->ttmbf && ttmb < 8) ttmb = -1;
2240
                    first_block = 0;
2241
                    s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2242
                }
2243
            }
2244
        }
2245
        else //Skipped
2246
        {
2247
            s->mb_intra = 0;
2248
            s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
2249
            vc1_pred_mv(s, 0, 0, 1, v->range_x, v->range_y);
2250
            vc1_mc_1mv(v);
2251
            return 0;
2252
        }
2253
    } //1MV mode
2254
    else //4MV mode
2255
    {//FIXME: looks not conforming to standard and is not even theoretically complete
2256
        if (!v->skip_mb_plane.data[mb_offset] /* unskipped MB */)
2257
        {
2258
            int blk_intra[4], blk_coded[4];
2259
            /* Get CBPCY */
2260
            cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2261
            for (i=0; i<4; i++)
2262
            {
2263
                val = ((cbp >> (5 - i)) & 1);
2264
                blk_intra[i] = 0;
2265
                blk_coded[i] = val;
2266
                if(val) {
2267
                    GET_MVDATA(dmv_x, dmv_y);
2268
                    blk_intra[i] = s->mb_intra;
2269
                }
2270
                if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2271
                    hybrid_pred = get_bits(gb, 1);
2272
            }
2273
            if((blk_intra[0] | blk_intra[1] | blk_intra[2] | blk_intra[3]) ||
2274
                (blk_coded[0] | blk_coded[1] | blk_coded[2] | blk_coded[3])) {
2275
                GET_MQUANT();
2276

    
2277
                if (s->mb_intra /* One of the 4 blocks is intra */
2278
                    /* non-zero pred for that block */)
2279
                    s->ac_pred = get_bits(gb, 1);
2280
                if (!v->ttmbf)
2281
                    ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2282
                                    VC1_TTMB_VLC_BITS, 12);
2283
                for(i = 0; i < 6; i++) {
2284
                    val = ((cbp >> (5 - i)) & 1);
2285
                    if(i & 4 || blk_intra[i] || val) {
2286
                        if(i < 4 && blk_intra[i])
2287
                            status = vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2288
                        else
2289
                            status = vc1_decode_p_block(v, block[i], i, mquant, ttmb, 0);
2290
                    }
2291
                }
2292
            }
2293
            return status;
2294
        }
2295
        else //Skipped MB
2296
        {
2297
            /* XXX: Skipped => cbp=0 and mquant doesn't matter ? */
2298
            for (i=0; i<4; i++)
2299
            {
2300
                if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2301
                    hybrid_pred = get_bits(gb, 1);
2302
            }
2303
            /* TODO: blah */
2304
            return 0;
2305
        }
2306
    }
2307

    
2308
    /* Should never happen */
2309
    return -1;
2310
}
2311

    
2312
/** Decode blocks of I-frame
2313
 */
2314
static void vc1_decode_i_blocks(VC1Context *v)
2315
{
2316
    int k;
2317
    MpegEncContext *s = &v->s;
2318
    int cbp, val;
2319
    uint8_t *coded_val;
2320
    int mb_pos;
2321

    
2322
    /* select codingmode used for VLC tables selection */
2323
    switch(v->y_ac_table_index){
2324
    case 0:
2325
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2326
        break;
2327
    case 1:
2328
        v->codingset = CS_HIGH_MOT_INTRA;
2329
        break;
2330
    case 2:
2331
        v->codingset = CS_MID_RATE_INTRA;
2332
        break;
2333
    }
2334

    
2335
    switch(v->c_ac_table_index){
2336
    case 0:
2337
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2338
        break;
2339
    case 1:
2340
        v->codingset2 = CS_HIGH_MOT_INTER;
2341
        break;
2342
    case 2:
2343
        v->codingset2 = CS_MID_RATE_INTER;
2344
        break;
2345
    }
2346

    
2347
    /* Set DC scale - y and c use the same */
2348
    s->y_dc_scale = s->y_dc_scale_table[v->pq];
2349
    s->c_dc_scale = s->c_dc_scale_table[v->pq];
2350

    
2351
    //do frame decode
2352
    s->mb_x = s->mb_y = 0;
2353
    s->mb_intra = 1;
2354
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2355
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2356
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2357
            ff_init_block_index(s);
2358
            ff_update_block_index(s);
2359
            s->dsp.clear_blocks(s->block[0]);
2360
            mb_pos = s->mb_x + s->mb_y * s->mb_width;
2361
            s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2362
            s->current_picture.qscale_table[mb_pos] = v->pq;
2363

    
2364
            // do actual MB decoding and displaying
2365
            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2366
            v->s.ac_pred = get_bits(&v->s.gb, 1);
2367

    
2368
            for(k = 0; k < 6; k++) {
2369
                val = ((cbp >> (5 - k)) & 1);
2370
                if (k < 4) {
2371
                    int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2372
                    val = val ^ pred;
2373
                    *coded_val = val;
2374
                }
2375
                cbp |= val << (5 - k);
2376

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

    
2379
                vc1_inv_trans(s->block[k], 8, 8);
2380
                if(v->pq >= 9 && v->overlap) {
2381
                    vc1_overlap_block(s, s->block[k], k, (s->mb_y || k>1), (s->mb_x || (k != 0 && k != 2)));
2382
                }
2383
            }
2384

    
2385
            vc1_put_block(v, s->block);
2386

    
2387
            if(get_bits_count(&s->gb) > v->bits) {
2388
                av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
2389
                return;
2390
            }
2391
        }
2392
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
2393
    }
2394
}
2395

    
2396
static void vc1_decode_p_blocks(VC1Context *v)
2397
{
2398
    MpegEncContext *s = &v->s;
2399

    
2400
    /* select codingmode used for VLC tables selection */
2401
    switch(v->c_ac_table_index){
2402
    case 0:
2403
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2404
        break;
2405
    case 1:
2406
        v->codingset = CS_HIGH_MOT_INTRA;
2407
        break;
2408
    case 2:
2409
        v->codingset = CS_MID_RATE_INTRA;
2410
        break;
2411
    }
2412

    
2413
    switch(v->c_ac_table_index){
2414
    case 0:
2415
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2416
        break;
2417
    case 1:
2418
        v->codingset2 = CS_HIGH_MOT_INTER;
2419
        break;
2420
    case 2:
2421
        v->codingset2 = CS_MID_RATE_INTER;
2422
        break;
2423
    }
2424

    
2425
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2426
    s->first_slice_line = 1;
2427
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2428
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2429
            ff_init_block_index(s);
2430
            ff_update_block_index(s);
2431
            s->dsp.clear_blocks(s->block[0]);
2432

    
2433
            vc1_decode_p_mb(v, s->block);
2434
            if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
2435
                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);
2436
                return;
2437
            }
2438
        }
2439
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
2440
        s->first_slice_line = 0;
2441
    }
2442
}
2443

    
2444
static void vc1_decode_blocks(VC1Context *v)
2445
{
2446

    
2447
    v->s.esc3_level_length = 0;
2448

    
2449
    switch(v->s.pict_type) {
2450
    case I_TYPE:
2451
        vc1_decode_i_blocks(v);
2452
        break;
2453
    case P_TYPE:
2454
        vc1_decode_p_blocks(v);
2455
        break;
2456
    }
2457
}
2458

    
2459

    
2460
/** Initialize a VC1/WMV3 decoder
2461
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2462
 * @todo TODO: Decypher remaining bits in extra_data
2463
 */
2464
static int vc1_decode_init(AVCodecContext *avctx)
2465
{
2466
    VC1Context *v = avctx->priv_data;
2467
    MpegEncContext *s = &v->s;
2468
    GetBitContext gb;
2469

    
2470
    if (!avctx->extradata_size || !avctx->extradata) return -1;
2471
    avctx->pix_fmt = PIX_FMT_YUV420P;
2472
    v->s.avctx = avctx;
2473

    
2474
    if(ff_h263_decode_init(avctx) < 0)
2475
        return -1;
2476
    if (vc1_init_common(v) < 0) return -1;
2477

    
2478
    av_log(avctx, AV_LOG_INFO, "This decoder is not supposed to produce picture. Dont report this as a bug!\n");
2479
    av_log(avctx, AV_LOG_INFO, "If you see a picture, don't believe your eyes.\n");
2480

    
2481
    avctx->flags |= CODEC_FLAG_EMU_EDGE;
2482
    avctx->coded_width = avctx->width;
2483
    avctx->coded_height = avctx->height;
2484
    if (avctx->codec_id == CODEC_ID_WMV3)
2485
    {
2486
        int count = 0;
2487

    
2488
        // looks like WMV3 has a sequence header stored in the extradata
2489
        // advanced sequence header may be before the first frame
2490
        // the last byte of the extradata is a version number, 1 for the
2491
        // samples we can decode
2492

    
2493
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2494

    
2495
        if (decode_sequence_header(avctx, &gb) < 0)
2496
          return -1;
2497

    
2498
        count = avctx->extradata_size*8 - get_bits_count(&gb);
2499
        if (count>0)
2500
        {
2501
            av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2502
                   count, get_bits(&gb, count));
2503
        }
2504
        else if (count < 0)
2505
        {
2506
            av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2507
        }
2508
    }
2509
    avctx->has_b_frames= !!(avctx->max_b_frames);
2510

    
2511
    s->mb_width = (avctx->coded_width+15)>>4;
2512
    s->mb_height = (avctx->coded_height+15)>>4;
2513

    
2514
    /* Allocate mb bitplanes */
2515
    if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
2516
        return -1;
2517
    if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
2518
        return -1;
2519
    if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)
2520
        return -1;
2521
    if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)
2522
        return -1;
2523

    
2524
    /* For predictors */
2525
    v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);
2526
    if (!v->previous_line_cbpcy) return -1;
2527

    
2528
    /* Init coded blocks info */
2529
    if (v->profile == PROFILE_ADVANCED)
2530
    {
2531
        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2532
            return -1;
2533
        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2534
            return -1;
2535
    }
2536

    
2537
    return 0;
2538
}
2539

    
2540

    
2541
/** Decode a VC1/WMV3 frame
2542
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2543
 * @warning Initial try at using MpegEncContext stuff
2544
 */
2545
static int vc1_decode_frame(AVCodecContext *avctx,
2546
                            void *data, int *data_size,
2547
                            uint8_t *buf, int buf_size)
2548
{
2549
    VC1Context *v = avctx->priv_data;
2550
    MpegEncContext *s = &v->s;
2551
    AVFrame *pict = data;
2552

    
2553
    /* no supplementary picture */
2554
    if (buf_size == 0) {
2555
        /* special case for last picture */
2556
        if (s->low_delay==0 && s->next_picture_ptr) {
2557
            *pict= *(AVFrame*)s->next_picture_ptr;
2558
            s->next_picture_ptr= NULL;
2559

    
2560
            *data_size = sizeof(AVFrame);
2561
        }
2562

    
2563
        return 0;
2564
    }
2565

    
2566
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2567
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2568
        int i= ff_find_unused_picture(s, 0);
2569
        s->current_picture_ptr= &s->picture[i];
2570
    }
2571

    
2572
    avctx->has_b_frames= !s->low_delay;
2573

    
2574
    init_get_bits(&s->gb, buf, buf_size*8);
2575
    // do parse frame header
2576
    if(vc1_parse_frame_header(v, &s->gb) == -1)
2577
        return -1;
2578

    
2579
    if(s->pict_type != I_TYPE && s->pict_type != P_TYPE)return -1;
2580

    
2581
    // for hurry_up==5
2582
    s->current_picture.pict_type= s->pict_type;
2583
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2584

    
2585
    /* skip B-frames if we don't have reference frames */
2586
    if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return -1;//buf_size;
2587
    /* skip b frames if we are in a hurry */
2588
    if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
2589
    if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
2590
       || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
2591
       ||  avctx->skip_frame >= AVDISCARD_ALL)
2592
        return buf_size;
2593
    /* skip everything if we are in a hurry>=5 */
2594
    if(avctx->hurry_up>=5) return -1;//buf_size;
2595

    
2596
    if(s->next_p_frame_damaged){
2597
        if(s->pict_type==B_TYPE)
2598
            return buf_size;
2599
        else
2600
            s->next_p_frame_damaged=0;
2601
    }
2602

    
2603
    if(MPV_frame_start(s, avctx) < 0)
2604
        return -1;
2605

    
2606
    ff_er_frame_start(s);
2607

    
2608
    v->bits = buf_size * 8;
2609
    vc1_decode_blocks(v);
2610
//av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
2611
//  if(get_bits_count(&s->gb) > buf_size * 8)
2612
//      return -1;
2613
    ff_er_frame_end(s);
2614

    
2615
    MPV_frame_end(s);
2616

    
2617
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2618
assert(s->current_picture.pict_type == s->pict_type);
2619
    if (s->pict_type == B_TYPE || s->low_delay) {
2620
        *pict= *(AVFrame*)s->current_picture_ptr;
2621
    } else if (s->last_picture_ptr != NULL) {
2622
        *pict= *(AVFrame*)s->last_picture_ptr;
2623
    }
2624

    
2625
    if(s->last_picture_ptr || s->low_delay){
2626
        *data_size = sizeof(AVFrame);
2627
        ff_print_debug_info(s, pict);
2628
    }
2629

    
2630
    /* Return the Picture timestamp as the frame number */
2631
    /* we substract 1 because it is added on utils.c    */
2632
    avctx->frame_number = s->picture_number - 1;
2633

    
2634
    return buf_size;
2635
}
2636

    
2637

    
2638
/** Close a VC1/WMV3 decoder
2639
 * @warning Initial try at using MpegEncContext stuff
2640
 */
2641
static int vc1_decode_end(AVCodecContext *avctx)
2642
{
2643
    VC1Context *v = avctx->priv_data;
2644

    
2645
    av_freep(&v->hrd_rate);
2646
    av_freep(&v->hrd_buffer);
2647
    MPV_common_end(&v->s);
2648
    free_bitplane(&v->mv_type_mb_plane);
2649
    free_bitplane(&v->skip_mb_plane);
2650
    free_bitplane(&v->direct_mb_plane);
2651
    return 0;
2652
}
2653

    
2654

    
2655
AVCodec vc1_decoder = {
2656
    "vc1",
2657
    CODEC_TYPE_VIDEO,
2658
    CODEC_ID_VC1,
2659
    sizeof(VC1Context),
2660
    vc1_decode_init,
2661
    NULL,
2662
    vc1_decode_end,
2663
    vc1_decode_frame,
2664
    CODEC_CAP_DELAY,
2665
    NULL
2666
};
2667

    
2668
AVCodec wmv3_decoder = {
2669
    "wmv3",
2670
    CODEC_TYPE_VIDEO,
2671
    CODEC_ID_WMV3,
2672
    sizeof(VC1Context),
2673
    vc1_decode_init,
2674
    NULL,
2675
    vc1_decode_end,
2676
    vc1_decode_frame,
2677
    CODEC_CAP_DELAY,
2678
    NULL
2679
};