Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vc1.c @ 3f6d6af6

History | View | Annotate | Download (84.9 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
/** The VC1 Context
207
 * @fixme Change size wherever another size is more efficient
208
 * Many members are only used for Advanced Profile
209
 */
210
typedef struct VC1Context{
211
    MpegEncContext s;
212

    
213
    int bits;
214

    
215
    /** Simple/Main Profile sequence header */
216
    //@{
217
    int res_sm;           ///< reserved, 2b
218
    int res_x8;           ///< reserved
219
    int multires;         ///< frame-level RESPIC syntax element present
220
    int res_fasttx;       ///< reserved, always 1
221
    int res_transtab;     ///< reserved, always 0
222
    int rangered;         ///< RANGEREDFRM (range reduction) syntax element present
223
                          ///< at frame level
224
    int res_rtm_flag;     ///< reserved, set to 1
225
    int reserved;         ///< reserved
226
    //@}
227

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

    
245
    /** Sequence header data for all Profiles
246
     * TODO: choose between ints, uint8_ts and monobit flags
247
     */
248
    //@{
249
    int profile;          ///< 2bits, Profile
250
    int frmrtq_postproc;  ///< 3bits,
251
    int bitrtq_postproc;  ///< 5bits, quantized framerate-based postprocessing strength
252
    int fastuvmc;         ///< Rounding of qpel vector to hpel ? (not in Simple)
253
    int extended_mv;      ///< Ext MV in P/B (not in Simple)
254
    int dquant;           ///< How qscale varies with MBs, 2bits (not in Simple)
255
    int vstransform;      ///< variable-size [48]x[48] transform type + info
256
    int overlap;          ///< overlapped transforms in use
257
    int quantizer_mode;   ///< 2bits, quantizer mode used for sequence, see QUANT_*
258
    int finterpflag;      ///< INTERPFRM present
259
    //@}
260

    
261
    /** Frame decoding info for all profiles */
262
    //@{
263
    uint8_t mv_mode;      ///< MV coding monde
264
    uint8_t mv_mode2;     ///< Secondary MV coding mode (B frames)
265
    int k_x;              ///< Number of bits for MVs (depends on MV range)
266
    int k_y;              ///< Number of bits for MVs (depends on MV range)
267
    int range_x, range_y; ///< MV range
268
    uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale
269
    /** pquant parameters */
270
    //@{
271
    uint8_t dquantfrm;
272
    uint8_t dqprofile;
273
    uint8_t dqsbedge;
274
    uint8_t dqbilevel;
275
    //@}
276
    /** AC coding set indexes
277
     * @see 8.1.1.10, p(1)10
278
     */
279
    //@{
280
    int c_ac_table_index; ///< Chroma index from ACFRM element
281
    int y_ac_table_index; ///< Luma index from AC2FRM element
282
    //@}
283
    int ttfrm;            ///< Transform type info present at frame level
284
    uint8_t ttmbf;        ///< Transform type flag
285
    int ttmb;             ///< Transform type
286
    uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
287
    int codingset;        ///< index of current table set from 11.8 to use for luma block decoding
288
    int codingset2;       ///< index of current table set from 11.8 to use for chroma block decoding
289
    int pqindex;          ///< raw pqindex used in coding set selection
290
    int a_avail, c_avail;
291

    
292

    
293
    /** Luma compensation parameters */
294
    //@{
295
    uint8_t lumscale;
296
    uint8_t lumshift;
297
    //@}
298
    int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs
299
    uint8_t halfpq;       ///< Uniform quant over image and qp+.5
300
    uint8_t respic;       ///< Frame-level flag for resized images
301
    int buffer_fullness;  ///< HRD info
302
    /** Ranges:
303
     * -# 0 -> [-64n 63.f] x [-32, 31.f]
304
     * -# 1 -> [-128, 127.f] x [-64, 63.f]
305
     * -# 2 -> [-512, 511.f] x [-128, 127.f]
306
     * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
307
     */
308
    uint8_t mvrange;
309
    uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use
310
    uint8_t *previous_line_cbpcy; ///< To use for predicted CBPCY
311
    VLC *cbpcy_vlc;               ///< CBPCY VLC table
312
    int tt_index;                 ///< Index for Transform Type tables
313
    uint8_t* mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)
314
    uint8_t* skip_mb_plane;       ///< bitplane for skipped MBs
315
//    BitPlane direct_mb_plane;     ///< bitplane for "direct" MBs
316
    int mv_type_is_raw;           ///< mv type mb plane is not coded
317
    int skip_is_raw;              ///< skip mb plane is not coded
318

    
319
    /** Frame decoding info for S/M profiles only */
320
    //@{
321
    uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
322
    uint8_t interpfrm;
323
    //@}
324

    
325
    /** Frame decoding info for Advanced profile */
326
    //@{
327
    uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
328
    uint8_t numpanscanwin;
329
    uint8_t tfcntr;
330
    uint8_t rptfrm, tff, rff;
331
    uint16_t topleftx;
332
    uint16_t toplefty;
333
    uint16_t bottomrightx;
334
    uint16_t bottomrighty;
335
    uint8_t uvsamp;
336
    uint8_t postproc;
337
    int hrd_num_leaky_buckets;
338
    uint8_t bit_rate_exponent;
339
    uint8_t buffer_size_exponent;
340
//    BitPlane ac_pred_plane;       ///< AC prediction flags bitplane
341
//    BitPlane over_flags_plane;    ///< Overflags bitplane
342
    uint8_t condover;
343
    uint16_t *hrd_rate, *hrd_buffer;
344
    uint8_t *hrd_fullness;
345
    uint8_t range_mapy_flag;
346
    uint8_t range_mapuv_flag;
347
    uint8_t range_mapy;
348
    uint8_t range_mapuv;
349
    //@}
350
} VC1Context;
351

    
352
/**
353
 * Get unary code of limited length
354
 * @fixme FIXME Slow and ugly
355
 * @param gb GetBitContext
356
 * @param[in] stop The bitstop value (unary code of 1's or 0's)
357
 * @param[in] len Maximum length
358
 * @return Unary length/index
359
 */
360
static int get_prefix(GetBitContext *gb, int stop, int len)
361
{
362
#if 1
363
    int i;
364

    
365
    for(i = 0; i < len && get_bits1(gb) != stop; i++);
366
    return i;
367
/*  int i = 0, tmp = !stop;
368

369
  while (i != len && tmp != stop)
370
  {
371
    tmp = get_bits(gb, 1);
372
    i++;
373
  }
374
  if (i == len && tmp != stop) return len+1;
375
  return i;*/
376
#else
377
  unsigned int buf;
378
  int log;
379

    
380
  OPEN_READER(re, gb);
381
  UPDATE_CACHE(re, gb);
382
  buf=GET_CACHE(re, gb); //Still not sure
383
  if (stop) buf = ~buf;
384

    
385
  log= av_log2(-buf); //FIXME: -?
386
  if (log < limit){
387
    LAST_SKIP_BITS(re, gb, log+1);
388
    CLOSE_READER(re, gb);
389
    return log;
390
  }
391

    
392
  LAST_SKIP_BITS(re, gb, limit);
393
  CLOSE_READER(re, gb);
394
  return limit;
395
#endif
396
}
397

    
398
static inline int decode210(GetBitContext *gb){
399
    int n;
400
    n = get_bits1(gb);
401
    if (n == 1)
402
        return 0;
403
    else
404
        return 2 - get_bits1(gb);
405
}
406

    
407
/**
408
 * Init VC-1 specific tables and VC1Context members
409
 * @param v The VC1Context to initialize
410
 * @return Status
411
 */
412
static int vc1_init_common(VC1Context *v)
413
{
414
    static int done = 0;
415
    int i = 0;
416

    
417
    v->hrd_rate = v->hrd_buffer = NULL;
418

    
419
    /* VLC tables */
420
    if(!done)
421
    {
422
        done = 1;
423
        init_vlc(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
424
                 vc1_bfraction_bits, 1, 1,
425
                 vc1_bfraction_codes, 1, 1, 1);
426
        init_vlc(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
427
                 vc1_norm2_bits, 1, 1,
428
                 vc1_norm2_codes, 1, 1, 1);
429
        init_vlc(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
430
                 vc1_norm6_bits, 1, 1,
431
                 vc1_norm6_codes, 2, 2, 1);
432
        init_vlc(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
433
                 vc1_imode_bits, 1, 1,
434
                 vc1_imode_codes, 1, 1, 1);
435
        for (i=0; i<3; i++)
436
        {
437
            init_vlc(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
438
                     vc1_ttmb_bits[i], 1, 1,
439
                     vc1_ttmb_codes[i], 2, 2, 1);
440
            init_vlc(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
441
                     vc1_ttblk_bits[i], 1, 1,
442
                     vc1_ttblk_codes[i], 1, 1, 1);
443
            init_vlc(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
444
                     vc1_subblkpat_bits[i], 1, 1,
445
                     vc1_subblkpat_codes[i], 1, 1, 1);
446
        }
447
        for(i=0; i<4; i++)
448
        {
449
            init_vlc(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
450
                     vc1_4mv_block_pattern_bits[i], 1, 1,
451
                     vc1_4mv_block_pattern_codes[i], 1, 1, 1);
452
            init_vlc(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
453
                     vc1_cbpcy_p_bits[i], 1, 1,
454
                     vc1_cbpcy_p_codes[i], 2, 2, 1);
455
            init_vlc(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
456
                     vc1_mv_diff_bits[i], 1, 1,
457
                     vc1_mv_diff_codes[i], 2, 2, 1);
458
        }
459
        for(i=0; i<8; i++)
460
            init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
461
                     &vc1_ac_tables[i][0][1], 8, 4,
462
                     &vc1_ac_tables[i][0][0], 8, 4, 1);
463
        init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
464
                 &ff_msmp4_mb_i_table[0][1], 4, 2,
465
                 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
466
    }
467

    
468
    /* Other defaults */
469
    v->pq = -1;
470
    v->mvrange = 0; /* 7.1.1.18, p80 */
471

    
472
    return 0;
473
}
474

    
475
/***********************************************************************/
476
/**
477
 * @defgroup bitplane VC9 Bitplane decoding
478
 * @see 8.7, p56
479
 * @{
480
 */
481

    
482
/** @addtogroup bitplane
483
 * Imode types
484
 * @{
485
 */
486
enum Imode {
487
    IMODE_RAW,
488
    IMODE_NORM2,
489
    IMODE_DIFF2,
490
    IMODE_NORM6,
491
    IMODE_DIFF6,
492
    IMODE_ROWSKIP,
493
    IMODE_COLSKIP
494
};
495
/** @} */ //imode defines
496

    
497
/** Decode rows by checking if they are skipped
498
 * @param plane Buffer to store decoded bits
499
 * @param[in] width Width of this buffer
500
 * @param[in] height Height of this buffer
501
 * @param[in] stride of this buffer
502
 */
503
static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
504
    int x, y;
505

    
506
    for (y=0; y<height; y++){
507
        if (!get_bits(gb, 1)) //rowskip
508
            memset(plane, 0, width);
509
        else
510
            for (x=0; x<width; x++)
511
                plane[x] = get_bits(gb, 1);
512
        plane += stride;
513
    }
514
}
515

    
516
/** Decode columns by checking if they are skipped
517
 * @param plane Buffer to store decoded bits
518
 * @param[in] width Width of this buffer
519
 * @param[in] height Height of this buffer
520
 * @param[in] stride of this buffer
521
 * @fixme FIXME: Optimize
522
 */
523
static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
524
    int x, y;
525

    
526
    for (x=0; x<width; x++){
527
        if (!get_bits(gb, 1)) //colskip
528
            for (y=0; y<height; y++)
529
                plane[y*stride] = 0;
530
        else
531
            for (y=0; y<height; y++)
532
                plane[y*stride] = get_bits(gb, 1);
533
        plane ++;
534
    }
535
}
536

    
537
/** Decode a bitplane's bits
538
 * @param bp Bitplane where to store the decode bits
539
 * @param v VC-1 context for bit reading and logging
540
 * @return Status
541
 * @fixme FIXME: Optimize
542
 * @todo TODO: Decide if a struct is needed
543
 */
544
static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
545
{
546
    GetBitContext *gb = &v->s.gb;
547

    
548
    int imode, x, y, code, offset;
549
    uint8_t invert, *planep = data;
550
    int width, height, stride;
551

    
552
    width = v->s.mb_width;
553
    height = v->s.mb_height;
554
    stride = v->s.mb_stride;
555
    invert = get_bits(gb, 1);
556
    imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
557

    
558
    *raw_flag = 0;
559
    switch (imode)
560
    {
561
    case IMODE_RAW:
562
        //Data is actually read in the MB layer (same for all tests == "raw")
563
        *raw_flag = 1; //invert ignored
564
        return invert;
565
    case IMODE_DIFF2:
566
    case IMODE_NORM2:
567
        if ((height * width) & 1)
568
        {
569
            *planep++ = get_bits(gb, 1);
570
            offset = 1;
571
        }
572
        else offset = 0;
573
        // decode bitplane as one long line
574
        for (y = offset; y < height * width; y += 2) {
575
            code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
576
            *planep++ = code & 1;
577
            offset++;
578
            if(offset == width) {
579
                offset = 0;
580
                planep += stride - width;
581
            }
582
            *planep++ = code >> 1;
583
            offset++;
584
            if(offset == width) {
585
                offset = 0;
586
                planep += stride - width;
587
            }
588
        }
589
        break;
590
    case IMODE_DIFF6:
591
    case IMODE_NORM6:
592
        if(!(height % 3) && (width % 3)) { // use 2x3 decoding
593
            for(y = 0; y < height; y+= 3) {
594
                for(x = width & 1; x < width; x += 2) {
595
                    code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
596
                    if(code < 0){
597
                        av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
598
                        return -1;
599
                    }
600
                    planep[x + 0] = (code >> 0) & 1;
601
                    planep[x + 1] = (code >> 1) & 1;
602
                    planep[x + 0 + stride] = (code >> 2) & 1;
603
                    planep[x + 1 + stride] = (code >> 3) & 1;
604
                    planep[x + 0 + stride * 2] = (code >> 4) & 1;
605
                    planep[x + 1 + stride * 2] = (code >> 5) & 1;
606
                }
607
                planep += stride * 3;
608
            }
609
            if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
610
        } else { // 3x2
611
            for(y = height & 1; y < height; y += 2) {
612
                for(x = width % 3; x < width; x += 3) {
613
                    code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
614
                    if(code < 0){
615
                        av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
616
                        return -1;
617
                    }
618
                    planep[x + 0] = (code >> 0) & 1;
619
                    planep[x + 1] = (code >> 1) & 1;
620
                    planep[x + 2] = (code >> 2) & 1;
621
                    planep[x + 0 + stride] = (code >> 3) & 1;
622
                    planep[x + 1 + stride] = (code >> 4) & 1;
623
                    planep[x + 2 + stride] = (code >> 5) & 1;
624
                }
625
                planep += stride * 2;
626
            }
627
            x = width % 3;
628
            if(x) decode_colskip(data  ,             x, height    , stride, &v->s.gb);
629
            if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
630
        }
631
        break;
632
    case IMODE_ROWSKIP:
633
        decode_rowskip(data, width, height, stride, &v->s.gb);
634
        break;
635
    case IMODE_COLSKIP:
636
        decode_colskip(data, width, height, stride, &v->s.gb);
637
        break;
638
    default: break;
639
    }
640

    
641
    /* Applying diff operator */
642
    if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
643
    {
644
        planep = data;
645
        planep[0] ^= invert;
646
        for (x=1; x<width; x++)
647
            planep[x] ^= planep[x-1];
648
        for (y=1; y<height; y++)
649
        {
650
            planep += stride;
651
            planep[0] ^= planep[-stride];
652
            for (x=1; x<width; x++)
653
            {
654
                if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
655
                else                                 planep[x] ^= planep[x-1];
656
            }
657
        }
658
    }
659
    else if (invert)
660
    {
661
        planep = data;
662
        for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
663
    }
664
    return (imode<<1) + invert;
665
}
666

    
667
/** @} */ //Bitplane group
668

    
669
/***********************************************************************/
670
/** VOP Dquant decoding
671
 * @param v VC-1 Context
672
 */
673
static int vop_dquant_decoding(VC1Context *v)
674
{
675
    GetBitContext *gb = &v->s.gb;
676
    int pqdiff;
677

    
678
    //variable size
679
    if (v->dquant == 2)
680
    {
681
        pqdiff = get_bits(gb, 3);
682
        if (pqdiff == 7) v->altpq = get_bits(gb, 5);
683
        else v->altpq = v->pq + pqdiff + 1;
684
    }
685
    else
686
    {
687
        v->dquantfrm = get_bits(gb, 1);
688
        if ( v->dquantfrm )
689
        {
690
            v->dqprofile = get_bits(gb, 2);
691
            switch (v->dqprofile)
692
            {
693
            case DQPROFILE_SINGLE_EDGE:
694
            case DQPROFILE_DOUBLE_EDGES:
695
                v->dqsbedge = get_bits(gb, 2);
696
                break;
697
            case DQPROFILE_ALL_MBS:
698
                v->dqbilevel = get_bits(gb, 1);
699
            default: break; //Forbidden ?
700
            }
701
            if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
702
            {
703
                pqdiff = get_bits(gb, 3);
704
                if (pqdiff == 7) v->altpq = get_bits(gb, 5);
705
                else v->altpq = v->pq + pqdiff + 1;
706
            }
707
        }
708
    }
709
    return 0;
710
}
711

    
712

    
713
/** Do inverse transform
714
 */
715
static void vc1_inv_trans(DCTELEM block[64], int M, int N)
716
{
717
    int i;
718
    register int t1,t2,t3,t4,t5,t6,t7,t8;
719
    DCTELEM *src, *dst;
720

    
721
    src = block;
722
    dst = block;
723
    if(M==4){
724
        for(i = 0; i < N; i++){
725
            t1 = 17 * (src[0] + src[2]);
726
            t2 = 17 * (src[0] - src[2]);
727
            t3 = 22 * src[1];
728
            t4 = 22 * src[3];
729
            t5 = 10 * src[1];
730
            t6 = 10 * src[3];
731

    
732
            dst[0] = (t1 + t3 + t6 + 4) >> 3;
733
            dst[1] = (t2 - t4 + t5 + 4) >> 3;
734
            dst[2] = (t2 + t4 - t5 + 4) >> 3;
735
            dst[3] = (t1 - t3 - t6 + 4) >> 3;
736

    
737
            src += 8;
738
            dst += 8;
739
        }
740
    }else{
741
        for(i = 0; i < N; i++){
742
            t1 = 12 * (src[0] + src[4]);
743
            t2 = 12 * (src[0] - src[4]);
744
            t3 = 16 * src[2] +  6 * src[6];
745
            t4 =  6 * src[2] - 16 * src[6];
746

    
747
            t5 = t1 + t3;
748
            t6 = t2 + t4;
749
            t7 = t2 - t4;
750
            t8 = t1 - t3;
751

    
752
            t1 = 16 * src[1] + 15 * src[3] +  9 * src[5] +  4 * src[7];
753
            t2 = 15 * src[1] -  4 * src[3] - 16 * src[5] -  9 * src[7];
754
            t3 =  9 * src[1] - 16 * src[3] +  4 * src[5] + 15 * src[7];
755
            t4 =  4 * src[1] -  9 * src[3] + 15 * src[5] - 16 * src[7];
756

    
757
            dst[0] = (t5 + t1 + 4) >> 3;
758
            dst[1] = (t6 + t2 + 4) >> 3;
759
            dst[2] = (t7 + t3 + 4) >> 3;
760
            dst[3] = (t8 + t4 + 4) >> 3;
761
            dst[4] = (t8 - t4 + 4) >> 3;
762
            dst[5] = (t7 - t3 + 4) >> 3;
763
            dst[6] = (t6 - t2 + 4) >> 3;
764
            dst[7] = (t5 - t1 + 4) >> 3;
765

    
766
            src += 8;
767
            dst += 8;
768
        }
769
    }
770

    
771
    src = block;
772
    dst = block;
773
    if(N==4){
774
        for(i = 0; i < M; i++){
775
            t1 = 17 * (src[ 0] + src[16]);
776
            t2 = 17 * (src[ 0] - src[16]);
777
            t3 = 22 * src[ 8];
778
            t4 = 22 * src[24];
779
            t5 = 10 * src[ 8];
780
            t6 = 10 * src[24];
781

    
782
            dst[ 0] = (t1 + t3 + t6 + 64) >> 7;
783
            dst[ 8] = (t2 - t4 + t5 + 64) >> 7;
784
            dst[16] = (t2 + t4 - t5 + 64) >> 7;
785
            dst[24] = (t1 - t3 - t6 + 64) >> 7;
786

    
787
            src ++;
788
            dst ++;
789
        }
790
    }else{
791
        for(i = 0; i < M; i++){
792
            t1 = 12 * (src[ 0] + src[32]);
793
            t2 = 12 * (src[ 0] - src[32]);
794
            t3 = 16 * src[16] +  6 * src[48];
795
            t4 =  6 * src[16] - 16 * src[48];
796

    
797
            t5 = t1 + t3;
798
            t6 = t2 + t4;
799
            t7 = t2 - t4;
800
            t8 = t1 - t3;
801

    
802
            t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
803
            t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
804
            t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
805
            t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
806

    
807
            dst[ 0] = (t5 + t1 + 64) >> 7;
808
            dst[ 8] = (t6 + t2 + 64) >> 7;
809
            dst[16] = (t7 + t3 + 64) >> 7;
810
            dst[24] = (t8 + t4 + 64) >> 7;
811
            dst[32] = (t8 - t4 + 64 + 1) >> 7;
812
            dst[40] = (t7 - t3 + 64 + 1) >> 7;
813
            dst[48] = (t6 - t2 + 64 + 1) >> 7;
814
            dst[56] = (t5 - t1 + 64 + 1) >> 7;
815

    
816
            src++;
817
            dst++;
818
        }
819
    }
820
}
821

    
822
/** Apply overlap transform
823
 * @todo optimize
824
 * @todo move to DSPContext
825
 */
826
static void vc1_overlap_block(MpegEncContext *s, DCTELEM block[64], int n, int do_hor, int do_vert)
827
{
828
    int i;
829

    
830
    if(do_hor) { //TODO
831
    }
832
    if(do_vert) { //TODO
833
    }
834

    
835
    for(i = 0; i < 64; i++)
836
        block[i] += 128;
837
}
838

    
839

    
840
static void vc1_v_overlap(uint8_t* src, int stride)
841
{
842
    int i;
843
    int a, b, c, d;
844
    for(i = 0; i < 8; i++) {
845
        a = src[-2*stride];
846
        b = src[-stride];
847
        c = src[0];
848
        d = src[stride];
849

    
850
        src[-2*stride] = (7*a + d) >> 3;
851
        src[-stride] = (-a + 7*b + c + d) >> 3;
852
        src[0] = (a + b + 7*c - d) >> 3;
853
        src[stride] = (a + 7*d) >> 3;
854
        src++;
855
    }
856
}
857

    
858
static void vc1_h_overlap(uint8_t* src, int stride)
859
{
860
    int i;
861
    int a, b, c, d;
862
    for(i = 0; i < 8; i++) {
863
        a = src[-2];
864
        b = src[-1];
865
        c = src[0];
866
        d = src[1];
867

    
868
        src[-2] = (7*a + d) >> 3;
869
        src[-1] = (-a + 7*b + c + d) >> 3;
870
        src[0] = (a + b + 7*c - d) >> 3;
871
        src[1] = (a + 7*d) >> 3;
872
        src += stride;
873
    }
874
}
875

    
876
/** Put block onto picture
877
 * @todo move to DSPContext
878
 */
879
static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
880
{
881
    uint8_t *Y;
882
    int ys, us, vs;
883
    DSPContext *dsp = &v->s.dsp;
884

    
885
    ys = v->s.current_picture.linesize[0];
886
    us = v->s.current_picture.linesize[1];
887
    vs = v->s.current_picture.linesize[2];
888
    Y = v->s.dest[0];
889

    
890
    dsp->put_pixels_clamped(block[0], Y, ys);
891
    dsp->put_pixels_clamped(block[1], Y + 8, ys);
892
    Y += ys * 8;
893
    dsp->put_pixels_clamped(block[2], Y, ys);
894
    dsp->put_pixels_clamped(block[3], Y + 8, ys);
895

    
896
    dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
897
    dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
898
}
899

    
900
/* clip motion vector as specified in 8.3.6.5 */
901
#define CLIP_RANGE(mv, src, lim, bs)      \
902
    if(mv < -bs) mv = -bs - src * bs; \
903
    if(mv > lim) mv = lim - src * bs;
904

    
905
/** Do motion compensation over 1 macroblock
906
 * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
907
 */
908
static void vc1_mc_1mv(VC1Context *v)
909
{
910
    MpegEncContext *s = &v->s;
911
    DSPContext *dsp = &v->s.dsp;
912
    uint8_t *srcY, *srcU, *srcV;
913
    int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
914

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

    
917
    mx = s->mv[0][0][0];
918
    my = s->mv[0][0][1];
919
    uvmx = (mx + ((mx & 3) == 3)) >> 1;
920
    uvmy = (my + ((my & 3) == 3)) >> 1;
921
    srcY = s->last_picture.data[0];
922
    srcU = s->last_picture.data[1];
923
    srcV = s->last_picture.data[2];
924

    
925
    if(v->fastuvmc) { // XXX: 8.3.5.4.5 specifies something different
926
        uvmx = (uvmx + 1) & ~1;
927
        uvmy = (uvmy + 1) & ~1;
928
    }
929

    
930
    src_x = s->mb_x * 16 + (mx >> 2);
931
    src_y = s->mb_y * 16 + (my >> 2);
932
    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
933
    uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
934

    
935
    CLIP_RANGE(  src_x, s->mb_x, s->mb_width  * 16, 16);
936
    CLIP_RANGE(  src_y, s->mb_y, s->mb_height * 16, 16);
937
    CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width  *  8,  8);
938
    CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height *  8,  8);
939

    
940
    srcY += src_y * s->linesize + src_x;
941
    srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
942
    srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
943

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

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

    
959
    if(!s->quarter_sample) { // hpel mc
960
        mx >>= 1;
961
        my >>= 1;
962
        dxy = ((my & 1) << 1) | (mx & 1);
963
        uvdxy = 0;
964

    
965
        dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
966
    } else {
967
        dxy = ((my & 3) << 2) | (mx & 3);
968
        uvdxy = ((uvmy & 1) << 1) | (uvmx & 1);
969

    
970
        dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
971
    }
972
    dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize, 8);
973
    dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize, 8);
974
//    dsp->put_mspel_pixels_tab[uvdxy](s->dest[1], srcU, s->uvlinesize);
975
//    dsp->put_mspel_pixels_tab[uvdxy](s->dest[2], srcV, s->uvlinesize);
976
}
977

    
978
/**
979
 * Decode Simple/Main Profiles sequence header
980
 * @see Figure 7-8, p16-17
981
 * @param avctx Codec context
982
 * @param gb GetBit context initialized from Codec context extra_data
983
 * @return Status
984
 */
985
static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
986
{
987
    VC1Context *v = avctx->priv_data;
988

    
989
    av_log(avctx, AV_LOG_INFO, "Header: %0X\n", show_bits(gb, 32));
990
    v->profile = get_bits(gb, 2);
991
    if (v->profile == 2)
992
    {
993
        av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
994
        return -1;
995
    }
996

    
997
    if (v->profile == PROFILE_ADVANCED)
998
    {
999
        v->level = get_bits(gb, 3);
1000
        if(v->level >= 5)
1001
        {
1002
            av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1003
        }
1004
        v->chromaformat = get_bits(gb, 2);
1005
        if (v->chromaformat != 1)
1006
        {
1007
            av_log(avctx, AV_LOG_ERROR,
1008
                   "Only 4:2:0 chroma format supported\n");
1009
            return -1;
1010
        }
1011
    }
1012
    else
1013
    {
1014
        v->res_sm = get_bits(gb, 2); //reserved
1015
        if (v->res_sm)
1016
        {
1017
            av_log(avctx, AV_LOG_ERROR,
1018
                   "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1019
            return -1;
1020
        }
1021
    }
1022

    
1023
    // (fps-2)/4 (->30)
1024
    v->frmrtq_postproc = get_bits(gb, 3); //common
1025
    // (bitrate-32kbps)/64kbps
1026
    v->bitrtq_postproc = get_bits(gb, 5); //common
1027
    v->s.loop_filter = get_bits(gb, 1); //common
1028
    if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1029
    {
1030
        av_log(avctx, AV_LOG_ERROR,
1031
               "LOOPFILTER shell not be enabled in simple profile\n");
1032
    }
1033

    
1034
    if (v->profile < PROFILE_ADVANCED)
1035
    {
1036
        v->res_x8 = get_bits(gb, 1); //reserved
1037
        if (v->res_x8)
1038
        {
1039
            av_log(avctx, AV_LOG_ERROR,
1040
                   "1 for reserved RES_X8 is forbidden\n");
1041
            //return -1;
1042
        }
1043
        v->multires = get_bits(gb, 1);
1044
        v->res_fasttx = get_bits(gb, 1);
1045
        if (!v->res_fasttx)
1046
        {
1047
            av_log(avctx, AV_LOG_ERROR,
1048
                   "0 for reserved RES_FASTTX is forbidden\n");
1049
            //return -1;
1050
        }
1051
    }
1052

    
1053
    v->fastuvmc =  get_bits(gb, 1); //common
1054
    if (!v->profile && !v->fastuvmc)
1055
    {
1056
        av_log(avctx, AV_LOG_ERROR,
1057
               "FASTUVMC unavailable in Simple Profile\n");
1058
        return -1;
1059
    }
1060
    v->extended_mv =  get_bits(gb, 1); //common
1061
    if (!v->profile && v->extended_mv)
1062
    {
1063
        av_log(avctx, AV_LOG_ERROR,
1064
               "Extended MVs unavailable in Simple Profile\n");
1065
        return -1;
1066
    }
1067
    v->dquant =  get_bits(gb, 2); //common
1068
    v->vstransform =  get_bits(gb, 1); //common
1069

    
1070
    if (v->profile < PROFILE_ADVANCED)
1071
    {
1072
        v->res_transtab = get_bits(gb, 1);
1073
        if (v->res_transtab)
1074
        {
1075
            av_log(avctx, AV_LOG_ERROR,
1076
                   "1 for reserved RES_TRANSTAB is forbidden\n");
1077
            return -1;
1078
        }
1079
    }
1080

    
1081
    v->overlap = get_bits(gb, 1); //common
1082

    
1083
    if (v->profile < PROFILE_ADVANCED)
1084
    {
1085
        v->s.resync_marker = get_bits(gb, 1);
1086
        v->rangered = get_bits(gb, 1);
1087
        if (v->rangered && v->profile == PROFILE_SIMPLE)
1088
        {
1089
            av_log(avctx, AV_LOG_INFO,
1090
                   "RANGERED should be set to 0 in simple profile\n");
1091
        }
1092
    }
1093

    
1094
    v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1095
    v->quantizer_mode = get_bits(gb, 2); //common
1096

    
1097
    if (v->profile < PROFILE_ADVANCED)
1098
    {
1099
        v->finterpflag = get_bits(gb, 1); //common
1100
        v->res_rtm_flag = get_bits(gb, 1); //reserved
1101
        if (!v->res_rtm_flag)
1102
        {
1103
            av_log(avctx, AV_LOG_ERROR,
1104
                   "0 for reserved RES_RTM_FLAG is forbidden\n");
1105
            //return -1;
1106
        }
1107
        av_log(avctx, AV_LOG_DEBUG,
1108
               "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1109
               "LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"
1110
               "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1111
               "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1112
               v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1113
               v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1114
               v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1115
               v->dquant, v->quantizer_mode, avctx->max_b_frames
1116
               );
1117
        return 0;
1118
    }
1119
    return -1;
1120
}
1121

    
1122

    
1123
static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1124
{
1125
    int pqindex, lowquant, status;
1126

    
1127
    if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1128
    skip_bits(gb, 2); //framecnt unused
1129
    v->rangeredfrm = 0;
1130
    if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1131
    v->s.pict_type = get_bits(gb, 1);
1132
    if (v->s.avctx->max_b_frames) {
1133
        if (!v->s.pict_type) {
1134
            if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1135
            else v->s.pict_type = B_TYPE;
1136
        } else v->s.pict_type = P_TYPE;
1137
    } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1138

    
1139
    if(v->s.pict_type == I_TYPE)
1140
        get_bits(gb, 7); // skip buffer fullness
1141

    
1142
    /* Quantizer stuff */
1143
    pqindex = get_bits(gb, 5);
1144
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1145
        v->pq = pquant_table[0][pqindex];
1146
    else
1147
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1148

    
1149
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1150
        v->pquantizer = pqindex < 9;
1151
    if (v->quantizer_mode == QUANT_UNIFORM || v->quantizer_mode == QUANT_NON_UNIFORM)
1152
        v->pquantizer = v->quantizer_mode == QUANT_UNIFORM;
1153
    v->pqindex = pqindex;
1154
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1155
    else v->halfpq = 0;
1156
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1157
        v->pquantizer = get_bits(gb, 1);
1158
    v->dquantfrm = 0;
1159

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

    
1163
    //TODO: complete parsing for P/B/BI frames
1164
    switch(v->s.pict_type) {
1165
    case P_TYPE:
1166
        if (v->pq < 5) v->tt_index = 0;
1167
        else if(v->pq < 13) v->tt_index = 1;
1168
        else v->tt_index = 2;
1169

    
1170
        if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1171
        v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1172
        v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1173
        v->range_x = 1 << (v->k_x - 1);
1174
        v->range_y = 1 << (v->k_y - 1);
1175
        if (v->profile == PROFILE_ADVANCED)
1176
        {
1177
            if (v->postprocflag) v->postproc = get_bits(gb, 1);
1178
        }
1179
        else
1180
            if (v->multires) v->respic = get_bits(gb, 2);
1181
        lowquant = (v->pq > 12) ? 0 : 1;
1182
        v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1183
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1184
        {
1185
            v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];
1186
            v->lumscale = get_bits(gb, 6);
1187
            v->lumshift = get_bits(gb, 6);
1188
        }
1189
        if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1190
            v->s.quarter_sample = 0;
1191
        else
1192
            v->s.quarter_sample = 1;
1193

    
1194
if(v->mv_mode != MV_PMODE_1MV && v->mv_mode != MV_PMODE_1MV_HPEL && v->mv_mode != MV_PMODE_1MV_HPEL_BILIN) {
1195
    av_log(v->s.avctx, AV_LOG_ERROR, "Only 1MV P-frames are supported by now\n");
1196
    return -1;
1197
}
1198
        if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1199
                 v->mv_mode2 == MV_PMODE_MIXED_MV)
1200
                || v->mv_mode == MV_PMODE_MIXED_MV)
1201
        {
1202
            status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1203
            if (status < 0) return -1;
1204
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1205
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1206
        } else {
1207
            v->mv_type_is_raw = 0;
1208
            memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1209
        }
1210
        status = bitplane_decoding(v->skip_mb_plane, &v->skip_is_raw, v);
1211
        if (status < 0) return -1;
1212
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1213
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1214

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

    
1219
        if (v->dquant)
1220
        {
1221
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1222
            vop_dquant_decoding(v);
1223
        }
1224

    
1225
        v->ttfrm = 0; //FIXME Is that so ?
1226
        if (v->vstransform)
1227
        {
1228
            v->ttmbf = get_bits(gb, 1);
1229
            if (v->ttmbf)
1230
            {
1231
                v->ttfrm = get_bits(gb, 2);
1232
            }
1233
        }
1234
        break;
1235
    case B_TYPE:
1236
        break;
1237
    }
1238

    
1239
    /* AC Syntax */
1240
    v->c_ac_table_index = decode012(gb);
1241
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1242
    {
1243
        v->y_ac_table_index = decode012(gb);
1244
    }
1245
    /* DC Syntax */
1246
    v->s.dc_table_index = get_bits(gb, 1);
1247

    
1248
    return 0;
1249
}
1250

    
1251
/***********************************************************************/
1252
/**
1253
 * @defgroup block VC-1 Block-level functions
1254
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1255
 * @todo TODO: Integrate to MpegEncContext facilities
1256
 * @{
1257
 */
1258

    
1259
/**
1260
 * @def GET_MQUANT
1261
 * @brief Get macroblock-level quantizer scale
1262
 * @warning XXX: qdiff to the frame quant, not previous quant ?
1263
 * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1264
 */
1265
#define GET_MQUANT()                                           \
1266
  if (v->dquantfrm)                                            \
1267
  {                                                            \
1268
    if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1269
    {                                                          \
1270
      if (v->dqbilevel)                                        \
1271
      {                                                        \
1272
        mquant = (get_bits(gb, 1)) ? v->pq : v->altpq;         \
1273
      }                                                        \
1274
      else                                                     \
1275
      {                                                        \
1276
        mqdiff = get_bits(gb, 3);                              \
1277
        if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1278
        else mquant = get_bits(gb, 5);                         \
1279
      }                                                        \
1280
    }                                                          \
1281
    else mquant = v->pq;                                       \
1282
  }
1283

    
1284
/**
1285
 * @def GET_MVDATA(_dmv_x, _dmv_y)
1286
 * @brief Get MV differentials
1287
 * @see MVDATA decoding from 8.3.5.2, p(1)20
1288
 * @param _dmv_x Horizontal differential for decoded MV
1289
 * @param _dmv_y Vertical differential for decoded MV
1290
 * @todo TODO: Use MpegEncContext arrays to store them
1291
 */
1292
#define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1293
  index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1294
                       VC1_MV_DIFF_VLC_BITS, 2);                    \
1295
  if (index > 36)                                                   \
1296
  {                                                                 \
1297
    mb_has_coeffs = 1;                                              \
1298
    index -= 37;                                                    \
1299
  }                                                                 \
1300
  else mb_has_coeffs = 0;                                           \
1301
  s->mb_intra = 0;                                                  \
1302
  if (!index) { _dmv_x = _dmv_y = 0; }                              \
1303
  else if (index == 35)                                             \
1304
  {                                                                 \
1305
    _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1306
    _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1307
  }                                                                 \
1308
  else if (index == 36)                                             \
1309
  {                                                                 \
1310
    _dmv_x = 0;                                                     \
1311
    _dmv_y = 0;                                                     \
1312
    s->mb_intra = 1;                                                \
1313
  }                                                                 \
1314
  else                                                              \
1315
  {                                                                 \
1316
    index1 = index%6;                                               \
1317
    if (!s->quarter_sample && index1 == 5) val = 1;                 \
1318
    else                                   val = 0;                 \
1319
    if(size_table[index1] - val > 0)                                \
1320
        val = get_bits(gb, size_table[index1] - val);               \
1321
    else                                   val = 0;                 \
1322
    sign = 0 - (val&1);                                             \
1323
    _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1324
                                                                    \
1325
    index1 = index/6;                                               \
1326
    if (!s->quarter_sample && index1 == 5) val = 1;                 \
1327
    else                                   val = 0;                 \
1328
    if(size_table[index1] - val > 0)                                \
1329
        val = get_bits(gb, size_table[index1] - val);               \
1330
    else                                   val = 0;                 \
1331
    sign = 0 - (val&1);                                             \
1332
    _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1333
  }
1334

    
1335
/** Predict and set motion vector
1336
 */
1337
static inline void vc1_pred_mv(MpegEncContext *s, int dmv_x, int dmv_y, int mv1, int r_x, int r_y)
1338
{
1339
    int xy, wrap, off;
1340
    int16_t *A, *B, *C;
1341
    int px, py;
1342
    int sum;
1343
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1344

    
1345
    /* scale MV difference to be quad-pel */
1346
    dmv_x <<= 1 - s->quarter_sample;
1347
    dmv_y <<= 1 - s->quarter_sample;
1348

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

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

    
1357
    if(!s->first_slice_line) { // predictor A is not out of bounds
1358
        if(s->mb_width == 1) {
1359
            px = A[0];
1360
            py = A[1];
1361
        } else {
1362
            px = mid_pred(A[0], B[0], C[0]);
1363
            py = mid_pred(A[1], B[1], C[1]);
1364
        }
1365
    } else if(s->mb_x) { // predictor C is not out of bounds
1366
        px = C[0];
1367
        py = C[1];
1368
    } else {
1369
        px = py = 0;
1370
    }
1371
    if(s->mb_intra) px = py = 0;
1372

    
1373
    /* Pullback MV as specified in 8.3.5.3.4 */
1374
    {
1375
        int qx, qy, X, Y;
1376
        qx = s->mb_x << 6; //FIXME: add real block coords for 4MV mode
1377
        qy = s->mb_y << 6;
1378
        X = (s->mb_width << 6) - 4;
1379
        Y = (s->mb_height << 6) - 4;
1380
        if(mv1) {
1381
            if(qx + px < -60) px = -60 - qx;
1382
            if(qy + py < -60) py = -60 - qy;
1383
        } else {
1384
            if(qx + px < -28) px = -28 - qx;
1385
            if(qy + py < -28) py = -28 - qy;
1386
        }
1387
        if(qx + px > X) px = X - qx;
1388
        if(qy + py > Y) py = Y - qy;
1389
    }
1390
    /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1391
    if(!s->mb_intra && !s->first_slice_line && s->mb_x) {
1392
        if(IS_INTRA(s->current_picture.mb_type[mb_pos - s->mb_stride]))
1393
            sum = ABS(px) + ABS(py);
1394
        else
1395
            sum = ABS(px - A[0]) + ABS(py - A[1]);
1396
        if(sum > 32) {
1397
            if(get_bits1(&s->gb)) {
1398
                px = A[0];
1399
                py = A[1];
1400
            } else {
1401
                px = C[0];
1402
                py = C[1];
1403
            }
1404
        } else {
1405
            if(IS_INTRA(s->current_picture.mb_type[mb_pos - 1]))
1406
                sum = ABS(px) + ABS(py);
1407
            else
1408
                sum = ABS(px - C[0]) + ABS(py - C[1]);
1409
            if(sum > 32) {
1410
                if(get_bits1(&s->gb)) {
1411
                    px = A[0];
1412
                    py = A[1];
1413
                } else {
1414
                    px = C[0];
1415
                    py = C[1];
1416
                }
1417
            }
1418
        }
1419
    }
1420
    /* store MV using signed modulus of MV range defined in 4.11 */
1421
    s->mv[0][0][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1422
    s->mv[0][0][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1423
}
1424

    
1425
/** Get predicted DC value for I-frames only
1426
 * prediction dir: left=0, top=1
1427
 * @param s MpegEncContext
1428
 * @param[in] n block index in the current MB
1429
 * @param dc_val_ptr Pointer to DC predictor
1430
 * @param dir_ptr Prediction direction for use in AC prediction
1431
 */
1432
static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1433
                              int16_t **dc_val_ptr, int *dir_ptr)
1434
{
1435
    int a, b, c, wrap, pred, scale;
1436
    int16_t *dc_val;
1437
    static const uint16_t dcpred[32] = {
1438
    -1, 1024,  512,  341,  256,  205,  171,  146,  128,
1439
         114,  102,   93,   85,   79,   73,   68,   64,
1440
          60,   57,   54,   51,   49,   47,   45,   43,
1441
          41,   39,   38,   37,   35,   34,   33
1442
    };
1443

    
1444
    /* find prediction - wmv3_dc_scale always used here in fact */
1445
    if (n < 4)     scale = s->y_dc_scale;
1446
    else           scale = s->c_dc_scale;
1447

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

    
1451
    /* B A
1452
     * C X
1453
     */
1454
    c = dc_val[ - 1];
1455
    b = dc_val[ - 1 - wrap];
1456
    a = dc_val[ - wrap];
1457

    
1458
    if (pq < 9 || !overlap)
1459
    {
1460
        /* Set outer values */
1461
        if (!s->mb_y && (n!=2 && n!=3)) b=a=dcpred[scale];
1462
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1463
    }
1464
    else
1465
    {
1466
        /* Set outer values */
1467
        if (!s->mb_y && (n!=2 && n!=3)) b=a=0;
1468
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1469
    }
1470

    
1471
    if (abs(a - b) <= abs(b - c)) {
1472
        pred = c;
1473
        *dir_ptr = 1;//left
1474
    } else {
1475
        pred = a;
1476
        *dir_ptr = 0;//top
1477
    }
1478

    
1479
    /* update predictor */
1480
    *dc_val_ptr = &dc_val[0];
1481
    return pred;
1482
}
1483

    
1484

    
1485
/** Get predicted DC value
1486
 * prediction dir: left=0, top=1
1487
 * @param s MpegEncContext
1488
 * @param[in] n block index in the current MB
1489
 * @param dc_val_ptr Pointer to DC predictor
1490
 * @param dir_ptr Prediction direction for use in AC prediction
1491
 */
1492
static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1493
                              int a_avail, int c_avail,
1494
                              int16_t **dc_val_ptr, int *dir_ptr)
1495
{
1496
    int a, b, c, wrap, pred, scale;
1497
    int16_t *dc_val;
1498
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1499
    int mb_pos2, q1, q2;
1500

    
1501
    /* find prediction - wmv3_dc_scale always used here in fact */
1502
    if (n < 4)     scale = s->y_dc_scale;
1503
    else           scale = s->c_dc_scale;
1504

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

    
1508
    /* B A
1509
     * C X
1510
     */
1511
    c = dc_val[ - 1];
1512
    b = dc_val[ - 1 - wrap];
1513
    a = dc_val[ - wrap];
1514

    
1515
    if(a_avail && c_avail) {
1516
        if(abs(a - b) <= abs(b - c)) {
1517
            pred = c;
1518
            *dir_ptr = 1;//left
1519
        } else {
1520
            pred = a;
1521
            *dir_ptr = 0;//top
1522
        }
1523
    } else if(a_avail) {
1524
        pred = a;
1525
        *dir_ptr = 0;//top
1526
    } else if(c_avail) {
1527
        pred = c;
1528
        *dir_ptr = 1;//left
1529
    } else {
1530
        pred = 0;
1531
        *dir_ptr = 1;//left
1532
    }
1533

    
1534
    /* scale coeffs if needed */
1535
    mb_pos2 = mb_pos - *dir_ptr - (1 - *dir_ptr) * s->mb_stride;
1536
    q1 = s->current_picture.qscale_table[mb_pos];
1537
    q2 = s->current_picture.qscale_table[mb_pos2];
1538
    if(0 && q1 && q2 && q1 != q2) {
1539
        q1 = s->y_dc_scale_table[q1];
1540
        q2 = s->y_dc_scale_table[q2];
1541
        pred = (pred * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1542
    }
1543

    
1544
    /* update predictor */
1545
    *dc_val_ptr = &dc_val[0];
1546
    return pred;
1547
}
1548

    
1549

    
1550
/**
1551
 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
1552
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1553
 * @todo TODO: Integrate to MpegEncContext facilities
1554
 * @{
1555
 */
1556

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

    
1561
    xy = s->block_index[n];
1562
    wrap = s->b8_stride;
1563

    
1564
    /* B C
1565
     * A X
1566
     */
1567
    a = s->coded_block[xy - 1       ];
1568
    b = s->coded_block[xy - 1 - wrap];
1569
    c = s->coded_block[xy     - wrap];
1570

    
1571
    if (b == c) {
1572
        pred = a;
1573
    } else {
1574
        pred = c;
1575
    }
1576

    
1577
    /* store value */
1578
    *coded_block_ptr = &s->coded_block[xy];
1579

    
1580
    return pred;
1581
}
1582

    
1583
/**
1584
 * Decode one AC coefficient
1585
 * @param v The VC1 context
1586
 * @param last Last coefficient
1587
 * @param skip How much zero coefficients to skip
1588
 * @param value Decoded AC coefficient value
1589
 * @see 8.1.3.4
1590
 */
1591
static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
1592
{
1593
    GetBitContext *gb = &v->s.gb;
1594
    int index, escape, run = 0, level = 0, lst = 0;
1595

    
1596
    index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1597
    if (index != vc1_ac_sizes[codingset] - 1) {
1598
        run = vc1_index_decode_table[codingset][index][0];
1599
        level = vc1_index_decode_table[codingset][index][1];
1600
        lst = index >= vc1_last_decode_table[codingset];
1601
        if(get_bits(gb, 1))
1602
            level = -level;
1603
    } else {
1604
        escape = decode210(gb);
1605
        if (escape != 2) {
1606
            index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1607
            run = vc1_index_decode_table[codingset][index][0];
1608
            level = vc1_index_decode_table[codingset][index][1];
1609
            lst = index >= vc1_last_decode_table[codingset];
1610
            if(escape == 0) {
1611
                if(lst)
1612
                    level += vc1_last_delta_level_table[codingset][run];
1613
                else
1614
                    level += vc1_delta_level_table[codingset][run];
1615
            } else {
1616
                if(lst)
1617
                    run += vc1_last_delta_run_table[codingset][level] + 1;
1618
                else
1619
                    run += vc1_delta_run_table[codingset][level] + 1;
1620
            }
1621
            if(get_bits(gb, 1))
1622
                level = -level;
1623
        } else {
1624
            int sign;
1625
            lst = get_bits(gb, 1);
1626
            if(v->s.esc3_level_length == 0) {
1627
                if(v->pq < 8 || v->dquantfrm) { // table 59
1628
                    v->s.esc3_level_length = get_bits(gb, 3);
1629
                    if(!v->s.esc3_level_length)
1630
                        v->s.esc3_level_length = get_bits(gb, 2) + 8;
1631
                } else { //table 60
1632
                    v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
1633
                }
1634
                v->s.esc3_run_length = 3 + get_bits(gb, 2);
1635
            }
1636
            run = get_bits(gb, v->s.esc3_run_length);
1637
            sign = get_bits(gb, 1);
1638
            level = get_bits(gb, v->s.esc3_level_length);
1639
            if(sign)
1640
                level = -level;
1641
        }
1642
    }
1643

    
1644
    *last = lst;
1645
    *skip = run;
1646
    *value = level;
1647
}
1648

    
1649
/** Decode intra block in intra frames - should be faster than decode_intra_block
1650
 * @param v VC1Context
1651
 * @param block block to decode
1652
 * @param coded are AC coeffs present or not
1653
 * @param codingset set of VLC to decode data
1654
 */
1655
static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
1656
{
1657
    GetBitContext *gb = &v->s.gb;
1658
    MpegEncContext *s = &v->s;
1659
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
1660
    int run_diff, i;
1661
    int16_t *dc_val;
1662
    int16_t *ac_val, *ac_val2;
1663
    int dcdiff;
1664

    
1665
    /* Get DC differential */
1666
    if (n < 4) {
1667
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1668
    } else {
1669
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1670
    }
1671
    if (dcdiff < 0){
1672
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1673
        return -1;
1674
    }
1675
    if (dcdiff)
1676
    {
1677
        if (dcdiff == 119 /* ESC index value */)
1678
        {
1679
            /* TODO: Optimize */
1680
            if (v->pq == 1) dcdiff = get_bits(gb, 10);
1681
            else if (v->pq == 2) dcdiff = get_bits(gb, 9);
1682
            else dcdiff = get_bits(gb, 8);
1683
        }
1684
        else
1685
        {
1686
            if (v->pq == 1)
1687
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1688
            else if (v->pq == 2)
1689
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1690
        }
1691
        if (get_bits(gb, 1))
1692
            dcdiff = -dcdiff;
1693
    }
1694

    
1695
    /* Prediction */
1696
    dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
1697
    *dc_val = dcdiff;
1698

    
1699
    /* Store the quantized DC coeff, used for prediction */
1700

    
1701
    if (n < 4) {
1702
        block[0] = dcdiff * s->y_dc_scale;
1703
    } else {
1704
        block[0] = dcdiff * s->c_dc_scale;
1705
    }
1706
    /* Skip ? */
1707
    run_diff = 0;
1708
    i = 0;
1709
    if (!coded) {
1710
        goto not_coded;
1711
    }
1712

    
1713
    //AC Decoding
1714
    i = 1;
1715

    
1716
    {
1717
        int last = 0, skip, value;
1718
        const int8_t *zz_table;
1719
        int scale;
1720
        int k;
1721

    
1722
        scale = v->pq * 2 + v->halfpq;
1723

    
1724
        if(v->s.ac_pred) {
1725
            if(!dc_pred_dir)
1726
                zz_table = vc1_horizontal_zz;
1727
            else
1728
                zz_table = vc1_vertical_zz;
1729
        } else
1730
            zz_table = vc1_normal_zz;
1731

    
1732
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1733
        ac_val2 = ac_val;
1734
        if(dc_pred_dir) //left
1735
            ac_val -= 16;
1736
        else //top
1737
            ac_val -= 16 * s->block_wrap[n];
1738

    
1739
        while (!last) {
1740
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
1741
            i += skip;
1742
            if(i > 63)
1743
                break;
1744
            block[zz_table[i++]] = value;
1745
        }
1746

    
1747
        /* apply AC prediction if needed */
1748
        if(s->ac_pred) {
1749
            if(dc_pred_dir) { //left
1750
                for(k = 1; k < 8; k++)
1751
                    block[k << 3] += ac_val[k];
1752
            } else { //top
1753
                for(k = 1; k < 8; k++)
1754
                    block[k] += ac_val[k + 8];
1755
            }
1756
        }
1757
        /* save AC coeffs for further prediction */
1758
        for(k = 1; k < 8; k++) {
1759
            ac_val2[k] = block[k << 3];
1760
            ac_val2[k + 8] = block[k];
1761
        }
1762

    
1763
        /* scale AC coeffs */
1764
        for(k = 1; k < 64; k++)
1765
            if(block[k]) {
1766
                block[k] *= scale;
1767
                if(!v->pquantizer)
1768
                    block[k] += (block[k] < 0) ? -v->pq : v->pq;
1769
            }
1770

    
1771
        if(s->ac_pred) i = 63;
1772
    }
1773

    
1774
not_coded:
1775
    if(!coded) {
1776
        int k, scale;
1777
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1778
        ac_val2 = ac_val;
1779

    
1780
        scale = v->pq * 2 + v->halfpq;
1781
        memset(ac_val2, 0, 16 * 2);
1782
        if(dc_pred_dir) {//left
1783
            ac_val -= 16;
1784
            if(s->ac_pred)
1785
                memcpy(ac_val2, ac_val, 8 * 2);
1786
        } else {//top
1787
            ac_val -= 16 * s->block_wrap[n];
1788
            if(s->ac_pred)
1789
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
1790
        }
1791

    
1792
        /* apply AC prediction if needed */
1793
        if(s->ac_pred) {
1794
            if(dc_pred_dir) { //left
1795
                for(k = 1; k < 8; k++) {
1796
                    block[k << 3] = ac_val[k] * scale;
1797
                    if(!v->pquantizer)
1798
                        block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
1799
                }
1800
            } else { //top
1801
                for(k = 1; k < 8; k++) {
1802
                    block[k] = ac_val[k + 8] * scale;
1803
                    if(!v->pquantizer)
1804
                        block[k] += (block[k] < 0) ? -v->pq : v->pq;
1805
                }
1806
            }
1807
            i = 63;
1808
        }
1809
    }
1810
    s->block_last_index[n] = i;
1811

    
1812
    return 0;
1813
}
1814

    
1815
/** Decode intra block in inter frames - more generic version than vc1_decode_i_block
1816
 * @param v VC1Context
1817
 * @param block block to decode
1818
 * @param coded are AC coeffs present or not
1819
 * @param mquant block quantizer
1820
 * @param codingset set of VLC to decode data
1821
 */
1822
static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
1823
{
1824
    GetBitContext *gb = &v->s.gb;
1825
    MpegEncContext *s = &v->s;
1826
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
1827
    int run_diff, i;
1828
    int16_t *dc_val;
1829
    int16_t *ac_val, *ac_val2;
1830
    int dcdiff;
1831
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1832
    int a_avail = v->a_avail, c_avail = v->c_avail;
1833

    
1834
    /* XXX: Guard against dumb values of mquant */
1835
    mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
1836

    
1837
    /* Set DC scale - y and c use the same */
1838
    s->y_dc_scale = s->y_dc_scale_table[mquant];
1839
    s->c_dc_scale = s->c_dc_scale_table[mquant];
1840

    
1841
    /* Get DC differential */
1842
    if (n < 4) {
1843
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1844
    } else {
1845
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1846
    }
1847
    if (dcdiff < 0){
1848
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1849
        return -1;
1850
    }
1851
    if (dcdiff)
1852
    {
1853
        if (dcdiff == 119 /* ESC index value */)
1854
        {
1855
            /* TODO: Optimize */
1856
            if (mquant == 1) dcdiff = get_bits(gb, 10);
1857
            else if (mquant == 2) dcdiff = get_bits(gb, 9);
1858
            else dcdiff = get_bits(gb, 8);
1859
        }
1860
        else
1861
        {
1862
            if (mquant == 1)
1863
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1864
            else if (mquant == 2)
1865
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1866
        }
1867
        if (get_bits(gb, 1))
1868
            dcdiff = -dcdiff;
1869
    }
1870

    
1871
    /* Prediction */
1872
    dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
1873
    *dc_val = dcdiff;
1874

    
1875
    /* Store the quantized DC coeff, used for prediction */
1876

    
1877
    if (n < 4) {
1878
        block[0] = dcdiff * s->y_dc_scale;
1879
    } else {
1880
        block[0] = dcdiff * s->c_dc_scale;
1881
    }
1882
    /* Skip ? */
1883
    run_diff = 0;
1884
    i = 0;
1885
    if (!coded) {
1886
        goto not_coded;
1887
    }
1888

    
1889
    //AC Decoding
1890
    i = 1;
1891

    
1892
    {
1893
        int last = 0, skip, value;
1894
        const int8_t *zz_table;
1895
        int scale;
1896
        int k;
1897

    
1898
        scale = mquant * 2;
1899

    
1900
        zz_table = vc1_simple_progressive_8x8_zz;
1901

    
1902
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1903
        ac_val2 = ac_val;
1904
        if(dc_pred_dir) //left
1905
            ac_val -= 16;
1906
        else //top
1907
            ac_val -= 16 * s->block_wrap[n];
1908

    
1909
        while (!last) {
1910
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
1911
            i += skip;
1912
            if(i > 63)
1913
                break;
1914
            block[zz_table[i++]] = value;
1915
        }
1916

    
1917
        /* apply AC prediction if needed */
1918
        if(s->ac_pred && (v->a_avail || v->c_avail)) {
1919
            /* scale predictors if needed*/
1920
            int mb_pos2, q1, q2;
1921

    
1922
            mb_pos2 = mb_pos - dc_pred_dir - (1 - dc_pred_dir) * s->mb_stride;
1923
            q1 = s->current_picture.qscale_table[mb_pos];
1924
            q2 = s->current_picture.qscale_table[mb_pos2];
1925

    
1926
            if(!c_avail) {
1927
                memset(ac_val, 0, 8 * sizeof(ac_val[0]));
1928
                dc_pred_dir = 0;
1929
            }
1930
            if(!a_avail) {
1931
                memset(ac_val + 8, 0, 8 * sizeof(ac_val[0]));
1932
                dc_pred_dir = 1;
1933
            }
1934
            if(q2 && q1 != q2) {
1935
                q1 = q1 * 2 - 1;
1936
                q2 = q2 * 2 - 1;
1937

    
1938
                if(dc_pred_dir) { //left
1939
                    for(k = 1; k < 8; k++)
1940
                        block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1941
                } else { //top
1942
                    for(k = 1; k < 8; k++)
1943
                        block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1944
                }
1945
            } else {
1946
                if(dc_pred_dir) { //left
1947
                    for(k = 1; k < 8; k++)
1948
                        block[k << 3] += ac_val[k];
1949
                } else { //top
1950
                    for(k = 1; k < 8; k++)
1951
                        block[k] += ac_val[k + 8];
1952
                }
1953
            }
1954
        }
1955
        /* save AC coeffs for further prediction */
1956
        for(k = 1; k < 8; k++) {
1957
            ac_val2[k] = block[k << 3];
1958
            ac_val2[k + 8] = block[k];
1959
        }
1960

    
1961
        /* scale AC coeffs */
1962
        for(k = 1; k < 64; k++)
1963
            if(block[k]) {
1964
                block[k] *= scale;
1965
                if(!v->pquantizer)
1966
                    block[k] += (block[k] < 0) ? -mquant : mquant;
1967
            }
1968

    
1969
        if(s->ac_pred) i = 63;
1970
    }
1971

    
1972
not_coded:
1973
    if(!coded) {
1974
        int k, scale;
1975
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1976
        ac_val2 = ac_val;
1977

    
1978
        if(!c_avail) {
1979
            memset(ac_val, 0, 8 * sizeof(ac_val[0]));
1980
            dc_pred_dir = 0;
1981
        }
1982
        if(!a_avail) {
1983
            memset(ac_val + 8, 0, 8 * sizeof(ac_val[0]));
1984
            dc_pred_dir = 1;
1985
        }
1986

    
1987
        scale = mquant * 2;
1988
        memset(ac_val2, 0, 16 * 2);
1989
        if(dc_pred_dir) {//left
1990
            ac_val -= 16;
1991
            if(s->ac_pred && (v->a_avail || v->c_avail))
1992
                memcpy(ac_val2, ac_val, 8 * 2);
1993
        } else {//top
1994
            ac_val -= 16 * s->block_wrap[n];
1995
            if(s->ac_pred && (v->a_avail || v->c_avail))
1996
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
1997
        }
1998

    
1999
        /* apply AC prediction if needed */
2000
        if(s->ac_pred && (v->a_avail || v->c_avail)) {
2001
            if(dc_pred_dir) { //left
2002
                for(k = 1; k < 8; k++) {
2003
                    block[k << 3] = ac_val[k] * scale;
2004
                    if(!v->pquantizer)
2005
                        block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2006
                }
2007
            } else { //top
2008
                for(k = 1; k < 8; k++) {
2009
                    block[k] = ac_val[k + 8] * scale;
2010
                    if(!v->pquantizer)
2011
                        block[k] += (block[k] < 0) ? -mquant : mquant;
2012
                }
2013
            }
2014
            i = 63;
2015
        }
2016
    }
2017
    s->block_last_index[n] = i;
2018

    
2019
    return 0;
2020
}
2021

    
2022
/** Decode P block
2023
 */
2024
static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
2025
{
2026
    MpegEncContext *s = &v->s;
2027
    GetBitContext *gb = &s->gb;
2028
    int i, j;
2029
    int subblkpat = 0;
2030
    int scale, off, idx, last, skip, value;
2031
    int ttblk = ttmb & 7;
2032

    
2033
    if(ttmb == -1) {
2034
        ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
2035
    }
2036
    if(ttblk == TT_4X4) {
2037
        subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
2038
    }
2039
    if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
2040
        subblkpat = decode012(gb);
2041
        if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
2042
        if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
2043
        if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
2044
    }
2045
    scale = 2 * mquant;
2046

    
2047
    // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2048
    if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
2049
        ttblk = TT_8X4;
2050
        subblkpat = 2 - (ttblk == TT_8X4_TOP);
2051
    }
2052
    if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
2053
        ttblk = TT_4X8;
2054
        subblkpat = 2 - (ttblk == TT_4X8_LEFT);
2055
    }
2056
    switch(ttblk) {
2057
    case TT_8X8:
2058
        i = 0;
2059
        last = 0;
2060
        while (!last) {
2061
            vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2062
            i += skip;
2063
            if(i > 63)
2064
                break;
2065
            idx = vc1_simple_progressive_8x8_zz[i++];
2066
            block[idx] = value * scale;
2067
        }
2068
        vc1_inv_trans(block, 8, 8);
2069
        break;
2070
    case TT_4X4:
2071
        for(j = 0; j < 4; j++) {
2072
            last = subblkpat & (1 << (3 - j));
2073
            i = 0;
2074
            off = (j & 1) * 4 + (j & 2) * 16;
2075
            while (!last) {
2076
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2077
                i += skip;
2078
                if(i > 15)
2079
                    break;
2080
                idx = vc1_simple_progressive_4x4_zz[i++];
2081
                block[idx + off] = value * scale;
2082
            }
2083
            if(!(subblkpat & (1 << (3 - j))))
2084
                vc1_inv_trans(block + off, 4, 4);
2085
        }
2086
        break;
2087
    case TT_8X4:
2088
        for(j = 0; j < 2; j++) {
2089
            last = subblkpat & (1 << (1 - j));
2090
            i = 0;
2091
            off = j * 32;
2092
            while (!last) {
2093
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2094
                i += skip;
2095
                if(i > 31)
2096
                    break;
2097
                idx = vc1_simple_progressive_8x4_zz[i++];
2098
                block[idx + off] = value * scale;
2099
            }
2100
            if(!(subblkpat & (1 << (1 - j))))
2101
                vc1_inv_trans(block + off, 8, 4);
2102
        }
2103
        break;
2104
    case TT_4X8:
2105
        for(j = 0; j < 2; j++) {
2106
            last = subblkpat & (1 << (1 - j));
2107
            i = 0;
2108
            off = j * 4;
2109
            while (!last) {
2110
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2111
                i += skip;
2112
                if(i > 31)
2113
                    break;
2114
                idx = vc1_simple_progressive_4x8_zz[i++];
2115
                block[idx + off] = value * scale;
2116
            }
2117
            if(!(subblkpat & (1 << (1 - j))))
2118
                vc1_inv_trans(block + off, 4, 8);
2119
        }
2120
        break;
2121
    }
2122
    return 0;
2123
}
2124

    
2125

    
2126
/** Decode one P-frame MB (in Simple/Main profile)
2127
 * @todo TODO: Extend to AP
2128
 * @fixme FIXME: DC value for inter blocks not set
2129
 */
2130
static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64])
2131
{
2132
    MpegEncContext *s = &v->s;
2133
    GetBitContext *gb = &s->gb;
2134
    int i, j;
2135
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2136
    int cbp; /* cbp decoding stuff */
2137
    int hybrid_pred; /* Prediction types */
2138
    int mqdiff, mquant; /* MB quantization */
2139
    int ttmb = v->ttmb; /* MB Transform type */
2140
    int status;
2141

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

    
2152
    mquant = v->pq; /* Loosy initialization */
2153

    
2154
    if (v->mv_type_is_raw)
2155
        fourmv = get_bits1(gb);
2156
    else
2157
        fourmv = v->mv_type_mb_plane[mb_pos];
2158
    if (v->skip_is_raw)
2159
        skipped = get_bits1(gb);
2160
    else
2161
        skipped = v->skip_mb_plane[mb_pos];
2162

    
2163
    if (!fourmv) /* 1MV mode */
2164
    {
2165
        if (!skipped)
2166
        {
2167
            GET_MVDATA(dmv_x, dmv_y);
2168

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

    
2172
            /* FIXME Set DC val for inter block ? */
2173
            if (s->mb_intra && !mb_has_coeffs)
2174
            {
2175
                GET_MQUANT();
2176
                s->ac_pred = get_bits(gb, 1);
2177
                cbp = 0;
2178
            }
2179
            else if (mb_has_coeffs)
2180
            {
2181
                if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2182
                cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2183
                GET_MQUANT();
2184
            }
2185
            else
2186
            {
2187
                mquant = v->pq;
2188
                cbp = 0;
2189
            }
2190
            s->current_picture.qscale_table[mb_pos] = mquant;
2191

    
2192
            if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2193
                ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2194
                                VC1_TTMB_VLC_BITS, 2);
2195
            s->dsp.clear_blocks(block[0]);
2196
            vc1_mc_1mv(v);
2197
            dst_idx = 0;
2198
            for (i=0; i<6; i++)
2199
            {
2200
                s->dc_val[0][s->block_index[i]] = 0;
2201
                dst_idx += i >> 2;
2202
                val = ((cbp >> (5 - i)) & 1);
2203
                off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2204
                if(s->mb_intra) {
2205
                    /* check if prediction blocks A and C are available */
2206
                    v->a_avail = v->c_avail = 0;
2207
                    if((i == 2 || i == 3) || (s->mb_y && IS_INTRA(s->current_picture.mb_type[mb_pos - s->mb_stride])))
2208
                        v->a_avail = 1;
2209
                    if((i == 1 || i == 3) || (s->mb_x && IS_INTRA(s->current_picture.mb_type[mb_pos - 1])))
2210
                        v->c_avail = 1;
2211

    
2212
                    vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2213
                    vc1_inv_trans(block[i], 8, 8);
2214
                    for(j = 0; j < 64; j++) block[i][j] += 128;
2215
                    s->dsp.put_pixels_clamped(block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2216
                    /* TODO: proper loop filtering */
2217
                    if(v->pq >= 9 && v->overlap) {
2218
                        if(v->a_avail)
2219
                            s->dsp.h263_v_loop_filter(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), s->y_dc_scale);
2220
                        if(v->c_avail)
2221
                            s->dsp.h263_h_loop_filter(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2), s->y_dc_scale);
2222
                    }
2223
                } else if(val) {
2224
                    vc1_decode_p_block(v, block[i], i, mquant, ttmb, first_block);
2225
                    if(!v->ttmbf && ttmb < 8) ttmb = -1;
2226
                    first_block = 0;
2227
                    s->dsp.add_pixels_clamped(block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2228
                }
2229
            }
2230
        }
2231
        else //Skipped
2232
        {
2233
            s->mb_intra = 0;
2234
            s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
2235
            vc1_pred_mv(s, 0, 0, 1, v->range_x, v->range_y);
2236
            vc1_mc_1mv(v);
2237
            return 0;
2238
        }
2239
    } //1MV mode
2240
    else //4MV mode
2241
    {//FIXME: looks not conforming to standard and is not even theoretically complete
2242
        if (!skipped /* unskipped MB */)
2243
        {
2244
            int blk_intra[4], blk_coded[4];
2245
            /* Get CBPCY */
2246
            cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2247
            for (i=0; i<4; i++)
2248
            {
2249
                val = ((cbp >> (5 - i)) & 1);
2250
                blk_intra[i] = 0;
2251
                blk_coded[i] = val;
2252
                if(val) {
2253
                    GET_MVDATA(dmv_x, dmv_y);
2254
                    blk_intra[i] = s->mb_intra;
2255
                }
2256
                if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2257
                    hybrid_pred = get_bits(gb, 1);
2258
            }
2259
            if((blk_intra[0] | blk_intra[1] | blk_intra[2] | blk_intra[3]) ||
2260
                (blk_coded[0] | blk_coded[1] | blk_coded[2] | blk_coded[3])) {
2261
                GET_MQUANT();
2262

    
2263
                if (s->mb_intra /* One of the 4 blocks is intra */
2264
                    /* non-zero pred for that block */)
2265
                    s->ac_pred = get_bits(gb, 1);
2266
                if (!v->ttmbf)
2267
                    ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2268
                                    VC1_TTMB_VLC_BITS, 12);
2269
                for(i = 0; i < 6; i++) {
2270
                    val = ((cbp >> (5 - i)) & 1);
2271
                    if(i & 4 || blk_intra[i] || val) {
2272
                        if(i < 4 && blk_intra[i])
2273
                            status = vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2274
                        else
2275
                            status = vc1_decode_p_block(v, block[i], i, mquant, ttmb, 0);
2276
                    }
2277
                }
2278
            }
2279
            return status;
2280
        }
2281
        else //Skipped MB
2282
        {
2283
            /* XXX: Skipped => cbp=0 and mquant doesn't matter ? */
2284
            for (i=0; i<4; i++)
2285
            {
2286
                if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2287
                    hybrid_pred = get_bits(gb, 1);
2288
            }
2289
            /* TODO: blah */
2290
            return 0;
2291
        }
2292
    }
2293

    
2294
    /* Should never happen */
2295
    return -1;
2296
}
2297

    
2298
/** Decode blocks of I-frame
2299
 */
2300
static void vc1_decode_i_blocks(VC1Context *v)
2301
{
2302
    int k;
2303
    MpegEncContext *s = &v->s;
2304
    int cbp, val;
2305
    uint8_t *coded_val;
2306
    int mb_pos;
2307

    
2308
    /* select codingmode used for VLC tables selection */
2309
    switch(v->y_ac_table_index){
2310
    case 0:
2311
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2312
        break;
2313
    case 1:
2314
        v->codingset = CS_HIGH_MOT_INTRA;
2315
        break;
2316
    case 2:
2317
        v->codingset = CS_MID_RATE_INTRA;
2318
        break;
2319
    }
2320

    
2321
    switch(v->c_ac_table_index){
2322
    case 0:
2323
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2324
        break;
2325
    case 1:
2326
        v->codingset2 = CS_HIGH_MOT_INTER;
2327
        break;
2328
    case 2:
2329
        v->codingset2 = CS_MID_RATE_INTER;
2330
        break;
2331
    }
2332

    
2333
    /* Set DC scale - y and c use the same */
2334
    s->y_dc_scale = s->y_dc_scale_table[v->pq];
2335
    s->c_dc_scale = s->c_dc_scale_table[v->pq];
2336

    
2337
    //do frame decode
2338
    s->mb_x = s->mb_y = 0;
2339
    s->mb_intra = 1;
2340
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2341
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2342
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2343
            ff_init_block_index(s);
2344
            ff_update_block_index(s);
2345
            s->dsp.clear_blocks(s->block[0]);
2346
            mb_pos = s->mb_x + s->mb_y * s->mb_width;
2347
            s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2348
            s->current_picture.qscale_table[mb_pos] = v->pq;
2349

    
2350
            // do actual MB decoding and displaying
2351
            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2352
            v->s.ac_pred = get_bits(&v->s.gb, 1);
2353

    
2354
            for(k = 0; k < 6; k++) {
2355
                val = ((cbp >> (5 - k)) & 1);
2356

    
2357
                if (k < 4) {
2358
                    int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2359
                    val = val ^ pred;
2360
                    *coded_val = val;
2361
                }
2362
                cbp |= val << (5 - k);
2363

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

    
2366
                vc1_inv_trans(s->block[k], 8, 8);
2367
                if(v->pq >= 9 && v->overlap) {
2368
                    vc1_overlap_block(s, s->block[k], k, (s->mb_y || k>1), (s->mb_x || (k != 0 && k != 2)));
2369
                }
2370
            }
2371

    
2372
            vc1_put_block(v, s->block);
2373
            if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
2374
                if(s->mb_y) {
2375
                    s->dsp.h263_v_loop_filter(s->dest[0], s->linesize, s->y_dc_scale);
2376
                    s->dsp.h263_v_loop_filter(s->dest[0] + 8, s->linesize, s->y_dc_scale);
2377
                    s->dsp.h263_v_loop_filter(s->dest[1], s->uvlinesize, s->y_dc_scale);
2378
                    s->dsp.h263_v_loop_filter(s->dest[2], s->uvlinesize, s->y_dc_scale);
2379
                }
2380
                s->dsp.h263_v_loop_filter(s->dest[0] + 8 * s->linesize, s->linesize, s->y_dc_scale);
2381
                s->dsp.h263_v_loop_filter(s->dest[0] + 8 * s->linesize + 8, s->linesize, s->y_dc_scale);
2382
                if(s->mb_x) {
2383
                    s->dsp.h263_h_loop_filter(s->dest[0], s->linesize, s->y_dc_scale);
2384
                    s->dsp.h263_h_loop_filter(s->dest[0] + 8 * s->linesize, s->linesize, s->y_dc_scale);
2385
                    s->dsp.h263_h_loop_filter(s->dest[1], s->uvlinesize, s->y_dc_scale);
2386
                    s->dsp.h263_h_loop_filter(s->dest[2], s->uvlinesize, s->y_dc_scale);
2387
                }
2388
                s->dsp.h263_h_loop_filter(s->dest[0] + 8, s->linesize, s->y_dc_scale);
2389
                s->dsp.h263_h_loop_filter(s->dest[0] + 8 * s->linesize + 8, s->linesize, s->y_dc_scale);
2390
            }
2391

    
2392
            if(get_bits_count(&s->gb) > v->bits) {
2393
                av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
2394
                return;
2395
            }
2396
        }
2397
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
2398
    }
2399
}
2400

    
2401
static void vc1_decode_p_blocks(VC1Context *v)
2402
{
2403
    MpegEncContext *s = &v->s;
2404

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

    
2418
    switch(v->c_ac_table_index){
2419
    case 0:
2420
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2421
        break;
2422
    case 1:
2423
        v->codingset2 = CS_HIGH_MOT_INTER;
2424
        break;
2425
    case 2:
2426
        v->codingset2 = CS_MID_RATE_INTER;
2427
        break;
2428
    }
2429

    
2430
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2431
    s->first_slice_line = 1;
2432
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2433
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2434
            ff_init_block_index(s);
2435
            ff_update_block_index(s);
2436
            s->dsp.clear_blocks(s->block[0]);
2437

    
2438
            vc1_decode_p_mb(v, s->block);
2439
            if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
2440
                av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
2441
                return;
2442
            }
2443
        }
2444
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
2445
        s->first_slice_line = 0;
2446
    }
2447
}
2448

    
2449
static void vc1_decode_blocks(VC1Context *v)
2450
{
2451

    
2452
    v->s.esc3_level_length = 0;
2453

    
2454
    switch(v->s.pict_type) {
2455
    case I_TYPE:
2456
        vc1_decode_i_blocks(v);
2457
        break;
2458
    case P_TYPE:
2459
        vc1_decode_p_blocks(v);
2460
        break;
2461
    }
2462
}
2463

    
2464

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

    
2475
    if (!avctx->extradata_size || !avctx->extradata) return -1;
2476
    avctx->pix_fmt = PIX_FMT_YUV420P;
2477
    v->s.avctx = avctx;
2478
    avctx->flags |= CODEC_FLAG_EMU_EDGE;
2479
    v->s.flags |= CODEC_FLAG_EMU_EDGE;
2480

    
2481
    if(ff_h263_decode_init(avctx) < 0)
2482
        return -1;
2483
    if (vc1_init_common(v) < 0) return -1;
2484

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

    
2488
    avctx->coded_width = avctx->width;
2489
    avctx->coded_height = avctx->height;
2490
    if (avctx->codec_id == CODEC_ID_WMV3)
2491
    {
2492
        int count = 0;
2493

    
2494
        // looks like WMV3 has a sequence header stored in the extradata
2495
        // advanced sequence header may be before the first frame
2496
        // the last byte of the extradata is a version number, 1 for the
2497
        // samples we can decode
2498

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

    
2501
        if (decode_sequence_header(avctx, &gb) < 0)
2502
          return -1;
2503

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

    
2517
    s->mb_width = (avctx->coded_width+15)>>4;
2518
    s->mb_height = (avctx->coded_height+15)>>4;
2519

    
2520
    /* Allocate mb bitplanes */
2521
    v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
2522
    v->skip_mb_plane = av_malloc(s->mb_stride * s->mb_height);
2523

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

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

    
2537
    return 0;
2538
}
2539

    
2540

    
2541
/** Decode a VC1/WMV3 frame
2542
 * @todo TODO: Handle 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
    av_freep(&v->mv_type_mb_plane);
2649
    av_freep(&v->skip_mb_plane);
2650
    return 0;
2651
}
2652

    
2653

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

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