Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vc1.c @ e148c6e1

History | View | Annotate | Download (96.4 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
static const int ttfrm_to_tt[4] = { TT_8X8, TT_8X4, TT_4X8, TT_4X4 };
141

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

    
152
/** One more frame type */
153
#define BI_TYPE 7
154

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

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

    
198
static VLC vc1_ac_coeff_table[8];
199
//@}
200

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

    
212
/** The VC1 Context
213
 * @fixme Change size wherever another size is more efficient
214
 * Many members are only used for Advanced Profile
215
 */
216
typedef struct VC1Context{
217
    MpegEncContext s;
218

    
219
    int bits;
220

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

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

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

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

    
298

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

    
324
    /** Frame decoding info for S/M profiles only */
325
    //@{
326
    uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
327
    uint8_t interpfrm;
328
    //@}
329

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

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

    
370
    for(i = 0; i < len && get_bits1(gb) != stop; i++);
371
    return i;
372
/*  int i = 0, tmp = !stop;
373

374
  while (i != len && tmp != stop)
375
  {
376
    tmp = get_bits(gb, 1);
377
    i++;
378
  }
379
  if (i == len && tmp != stop) return len+1;
380
  return i;*/
381
#else
382
  unsigned int buf;
383
  int log;
384

    
385
  OPEN_READER(re, gb);
386
  UPDATE_CACHE(re, gb);
387
  buf=GET_CACHE(re, gb); //Still not sure
388
  if (stop) buf = ~buf;
389

    
390
  log= av_log2(-buf); //FIXME: -?
391
  if (log < limit){
392
    LAST_SKIP_BITS(re, gb, log+1);
393
    CLOSE_READER(re, gb);
394
    return log;
395
  }
396

    
397
  LAST_SKIP_BITS(re, gb, limit);
398
  CLOSE_READER(re, gb);
399
  return limit;
400
#endif
401
}
402

    
403
static inline int decode210(GetBitContext *gb){
404
    int n;
405
    n = get_bits1(gb);
406
    if (n == 1)
407
        return 0;
408
    else
409
        return 2 - get_bits1(gb);
410
}
411

    
412
/**
413
 * Init VC-1 specific tables and VC1Context members
414
 * @param v The VC1Context to initialize
415
 * @return Status
416
 */
417
static int vc1_init_common(VC1Context *v)
418
{
419
    static int done = 0;
420
    int i = 0;
421

    
422
    v->hrd_rate = v->hrd_buffer = NULL;
423

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

    
473
    /* Other defaults */
474
    v->pq = -1;
475
    v->mvrange = 0; /* 7.1.1.18, p80 */
476

    
477
    return 0;
478
}
479

    
480
/***********************************************************************/
481
/**
482
 * @defgroup bitplane VC9 Bitplane decoding
483
 * @see 8.7, p56
484
 * @{
485
 */
486

    
487
/** @addtogroup bitplane
488
 * Imode types
489
 * @{
490
 */
491
enum Imode {
492
    IMODE_RAW,
493
    IMODE_NORM2,
494
    IMODE_DIFF2,
495
    IMODE_NORM6,
496
    IMODE_DIFF6,
497
    IMODE_ROWSKIP,
498
    IMODE_COLSKIP
499
};
500
/** @} */ //imode defines
501

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

    
511
    for (y=0; y<height; y++){
512
        if (!get_bits(gb, 1)) //rowskip
513
            memset(plane, 0, width);
514
        else
515
            for (x=0; x<width; x++)
516
                plane[x] = get_bits(gb, 1);
517
        plane += stride;
518
    }
519
}
520

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

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

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

    
553
    int imode, x, y, code, offset;
554
    uint8_t invert, *planep = data;
555
    int width, height, stride;
556

    
557
    width = v->s.mb_width;
558
    height = v->s.mb_height;
559
    stride = v->s.mb_stride;
560
    invert = get_bits(gb, 1);
561
    imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
562

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

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

    
673
/** @} */ //Bitplane group
674

    
675
/***********************************************************************/
676
/** VOP Dquant decoding
677
 * @param v VC-1 Context
678
 */
679
static int vop_dquant_decoding(VC1Context *v)
680
{
681
    GetBitContext *gb = &v->s.gb;
682
    int pqdiff;
683

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

    
718

    
719
/** Do inverse transform
720
 */
721
static void vc1_inv_trans(DCTELEM block[64], int M, int N)
722
{
723
    int i;
724
    register int t1,t2,t3,t4,t5,t6,t7,t8;
725
    DCTELEM *src, *dst;
726

    
727
    src = block;
728
    dst = block;
729
    if(M==4){
730
        for(i = 0; i < N; i++){
731
            t1 = 17 * (src[0] + src[2]);
732
            t2 = 17 * (src[0] - src[2]);
733
            t3 = 22 * src[1];
734
            t4 = 22 * src[3];
735
            t5 = 10 * src[1];
736
            t6 = 10 * src[3];
737

    
738
            dst[0] = (t1 + t3 + t6 + 4) >> 3;
739
            dst[1] = (t2 - t4 + t5 + 4) >> 3;
740
            dst[2] = (t2 + t4 - t5 + 4) >> 3;
741
            dst[3] = (t1 - t3 - t6 + 4) >> 3;
742

    
743
            src += 8;
744
            dst += 8;
745
        }
746
    }else{
747
        for(i = 0; i < N; i++){
748
            t1 = 12 * (src[0] + src[4]);
749
            t2 = 12 * (src[0] - src[4]);
750
            t3 = 16 * src[2] +  6 * src[6];
751
            t4 =  6 * src[2] - 16 * src[6];
752

    
753
            t5 = t1 + t3;
754
            t6 = t2 + t4;
755
            t7 = t2 - t4;
756
            t8 = t1 - t3;
757

    
758
            t1 = 16 * src[1] + 15 * src[3] +  9 * src[5] +  4 * src[7];
759
            t2 = 15 * src[1] -  4 * src[3] - 16 * src[5] -  9 * src[7];
760
            t3 =  9 * src[1] - 16 * src[3] +  4 * src[5] + 15 * src[7];
761
            t4 =  4 * src[1] -  9 * src[3] + 15 * src[5] - 16 * src[7];
762

    
763
            dst[0] = (t5 + t1 + 4) >> 3;
764
            dst[1] = (t6 + t2 + 4) >> 3;
765
            dst[2] = (t7 + t3 + 4) >> 3;
766
            dst[3] = (t8 + t4 + 4) >> 3;
767
            dst[4] = (t8 - t4 + 4) >> 3;
768
            dst[5] = (t7 - t3 + 4) >> 3;
769
            dst[6] = (t6 - t2 + 4) >> 3;
770
            dst[7] = (t5 - t1 + 4) >> 3;
771

    
772
            src += 8;
773
            dst += 8;
774
        }
775
    }
776

    
777
    src = block;
778
    dst = block;
779
    if(N==4){
780
        for(i = 0; i < M; i++){
781
            t1 = 17 * (src[ 0] + src[16]);
782
            t2 = 17 * (src[ 0] - src[16]);
783
            t3 = 22 * src[ 8];
784
            t4 = 22 * src[24];
785
            t5 = 10 * src[ 8];
786
            t6 = 10 * src[24];
787

    
788
            dst[ 0] = (t1 + t3 + t6 + 64) >> 7;
789
            dst[ 8] = (t2 - t4 + t5 + 64) >> 7;
790
            dst[16] = (t2 + t4 - t5 + 64) >> 7;
791
            dst[24] = (t1 - t3 - t6 + 64) >> 7;
792

    
793
            src ++;
794
            dst ++;
795
        }
796
    }else{
797
        for(i = 0; i < M; i++){
798
            t1 = 12 * (src[ 0] + src[32]);
799
            t2 = 12 * (src[ 0] - src[32]);
800
            t3 = 16 * src[16] +  6 * src[48];
801
            t4 =  6 * src[16] - 16 * src[48];
802

    
803
            t5 = t1 + t3;
804
            t6 = t2 + t4;
805
            t7 = t2 - t4;
806
            t8 = t1 - t3;
807

    
808
            t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
809
            t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
810
            t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
811
            t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
812

    
813
            dst[ 0] = (t5 + t1 + 64) >> 7;
814
            dst[ 8] = (t6 + t2 + 64) >> 7;
815
            dst[16] = (t7 + t3 + 64) >> 7;
816
            dst[24] = (t8 + t4 + 64) >> 7;
817
            dst[32] = (t8 - t4 + 64 + 1) >> 7;
818
            dst[40] = (t7 - t3 + 64 + 1) >> 7;
819
            dst[48] = (t6 - t2 + 64 + 1) >> 7;
820
            dst[56] = (t5 - t1 + 64 + 1) >> 7;
821

    
822
            src++;
823
            dst++;
824
        }
825
    }
826
}
827

    
828
/** Apply overlap transform to vertical edge
829
 * @todo optimize
830
 * @todo move to DSPContext
831
 */
832
static void vc1_v_overlap(uint8_t* src, int stride)
833
{
834
    int i;
835
    int a, b, c, d;
836
    for(i = 0; i < 8; i++) {
837
        a = src[-2*stride];
838
        b = src[-stride];
839
        c = src[0];
840
        d = src[stride];
841

    
842
        src[-2*stride] = clip_uint8((7*a + d + 3) >> 3);
843
        src[-stride] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
844
        src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
845
        src[stride] = clip_uint8((a + 7*d + 3) >> 3);
846
        src++;
847
    }
848
}
849

    
850
/** Apply overlap transform to horizontal edge
851
 * @todo optimize
852
 * @todo move to DSPContext
853
 */
854
static void vc1_h_overlap(uint8_t* src, int stride)
855
{
856
    int i;
857
    int a, b, c, d;
858
    for(i = 0; i < 8; i++) {
859
        a = src[-2];
860
        b = src[-1];
861
        c = src[0];
862
        d = src[1];
863

    
864
        src[-2] = clip_uint8((7*a + d + 3) >> 3);
865
        src[-1] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
866
        src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
867
        src[1] = clip_uint8((a + 7*d + 3) >> 3);
868
        src += stride;
869
    }
870
}
871

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

    
881
    ys = v->s.current_picture.linesize[0];
882
    us = v->s.current_picture.linesize[1];
883
    vs = v->s.current_picture.linesize[2];
884
    Y = v->s.dest[0];
885

    
886
    dsp->put_pixels_clamped(block[0], Y, ys);
887
    dsp->put_pixels_clamped(block[1], Y + 8, ys);
888
    Y += ys * 8;
889
    dsp->put_pixels_clamped(block[2], Y, ys);
890
    dsp->put_pixels_clamped(block[3], Y + 8, ys);
891

    
892
    dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
893
    dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
894
}
895

    
896
/* clip motion vector as specified in 8.3.6.5 */
897
#define CLIP_RANGE(mv, src, lim, bs)      \
898
    if(mv < -bs) mv = -bs - src * bs; \
899
    if(mv > lim) mv = lim - src * bs;
900

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

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

    
913
    mx = s->mv[0][0][0];
914
    my = s->mv[0][0][1];
915
    uvmx = (mx + ((mx & 3) == 3)) >> 1;
916
    uvmy = (my + ((my & 3) == 3)) >> 1;
917
    srcY = s->last_picture.data[0];
918
    srcU = s->last_picture.data[1];
919
    srcV = s->last_picture.data[2];
920

    
921
    src_x = s->mb_x * 16 + (mx >> 2);
922
    src_y = s->mb_y * 16 + (my >> 2);
923
    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
924
    uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
925

    
926
    CLIP_RANGE(  src_x, s->mb_x, s->mb_width  * 16, 16);
927
    CLIP_RANGE(  src_y, s->mb_y, s->mb_height * 16, 16);
928
    CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width  *  8,  8);
929
    CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height *  8,  8);
930

    
931
    srcY += src_y * s->linesize + src_x;
932
    srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
933
    srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
934

    
935
    if((v->mv_mode == MV_PMODE_INTENSITY_COMP)
936
       || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
937
       || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
938
        uint8_t *uvbuf= s->edge_emu_buffer + 18 * s->linesize;
939

    
940
        ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
941
                            src_x, src_y, s->h_edge_pos, s->v_edge_pos);
942
        srcY = s->edge_emu_buffer;
943
        ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
944
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
945
        ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
946
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
947
        srcU = uvbuf;
948
        srcV = uvbuf + 16;
949
        /* if we deal with intensity compensation we need to scale source blocks */
950
        if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
951
            int i, j;
952
            uint8_t *src, *src2;
953

    
954
            src = srcY;
955
            for(j = 0; j < 17; j++) {
956
                for(i = 0; i < 17; i++) src[i] = v->luty[src[i]];
957
                src += s->linesize;
958
            }
959
            src = srcU; src2 = srcV;
960
            for(j = 0; j < 9; j++) {
961
                for(i = 0; i < 9; i++) {
962
                    src[i] = v->lutuv[src[i]];
963
                    src2[i] = v->lutuv[src2[i]];
964
                }
965
                src += s->uvlinesize;
966
                src2 += s->uvlinesize;
967
            }
968
        }
969
    }
970

    
971
    if(v->fastuvmc) {
972
        uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
973
        uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
974
    }
975

    
976
    if(!s->quarter_sample) { // hpel mc
977
        mx >>= 1;
978
        my >>= 1;
979
        dxy = ((my & 1) << 1) | (mx & 1);
980

    
981
        dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
982
    } else {
983
        dxy = ((my & 3) << 2) | (mx & 3);
984

    
985
        dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
986
    }
987
    uvmx >>= 1;
988
    uvmy >>= 1;
989
    uvdxy = ((uvmy & 1) << 1) | (uvmx & 1);
990
    dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize, 8);
991
    dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize, 8);
992
//    dsp->put_mspel_pixels_tab[uvdxy](s->dest[1], srcU, s->uvlinesize);
993
//    dsp->put_mspel_pixels_tab[uvdxy](s->dest[2], srcV, s->uvlinesize);
994
}
995

    
996
/** Do motion compensation for 4-MV macroblock - luminance block
997
 */
998
static void vc1_mc_4mv_luma(VC1Context *v, int n)
999
{
1000
    MpegEncContext *s = &v->s;
1001
    DSPContext *dsp = &v->s.dsp;
1002
    uint8_t *srcY;
1003
    int dxy, mx, my, src_x, src_y;
1004
    int off;
1005

    
1006
    if(!v->s.last_picture.data[0])return;
1007
    mx = s->mv[0][n][0];
1008
    my = s->mv[0][n][1];
1009
    srcY = s->last_picture.data[0];
1010

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

    
1013
    src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
1014
    src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
1015

    
1016
    CLIP_RANGE(src_x, s->mb_x, s->mb_width  * 16, 16);
1017
    CLIP_RANGE(src_y, s->mb_y, s->mb_height * 16, 16);
1018

    
1019
    srcY += src_y * s->linesize + src_x;
1020

    
1021
    if((unsigned)src_x > s->h_edge_pos - (mx&3) - 16
1022
       || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
1023
        ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
1024
                            src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1025
        srcY = s->edge_emu_buffer;
1026
    }
1027

    
1028
    if(!s->quarter_sample) { // hpel mc
1029
        mx >>= 1;
1030
        my >>= 1;
1031
        dxy = ((my & 1) << 1) | (mx & 1);
1032

    
1033
        dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1034
    } else {
1035
        dxy = ((my & 3) << 2) | (mx & 3);
1036

    
1037
        dsp->put_no_rnd_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
1038
    }
1039
}
1040

    
1041
static inline int median4(int a, int b, int c, int d)
1042
{
1043
    if(a < b) {
1044
        if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
1045
        else      return (FFMIN(b, c) + FFMAX(a, d)) / 2;
1046
    } else {
1047
        if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
1048
        else      return (FFMIN(a, c) + FFMAX(b, d)) / 2;
1049
    }
1050
}
1051

    
1052

    
1053
/** Do motion compensation for 4-MV macroblock - both chroma blocks
1054
 */
1055
static void vc1_mc_4mv_chroma(VC1Context *v)
1056
{
1057
    MpegEncContext *s = &v->s;
1058
    DSPContext *dsp = &v->s.dsp;
1059
    uint8_t *srcU, *srcV;
1060
    int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1061
    int i, idx, tx = 0, ty = 0;
1062
    int mvx[4], mvy[4], intra[4];
1063
    static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1064

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

    
1067
    for(i = 0; i < 4; i++) {
1068
        mvx[i] = s->mv[0][i][0];
1069
        mvy[i] = s->mv[0][i][1];
1070
        intra[i] = v->mb_type[0][s->block_index[i]];
1071
    }
1072

    
1073
    /* calculate chroma MV vector from four luma MVs */
1074
    idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1075
    if(!idx) { // all blocks are inter
1076
        tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1077
        ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1078
    } else if(count[idx] == 1) { // 3 inter blocks
1079
        switch(idx) {
1080
        case 0x1:
1081
            tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1082
            ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1083
            break;
1084
        case 0x2:
1085
            tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1086
            ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1087
            break;
1088
        case 0x4:
1089
            tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1090
            ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1091
            break;
1092
        case 0x8:
1093
            tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1094
            ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1095
            break;
1096
        }
1097
    } else if(count[idx] == 2) {
1098
        int t1 = 0, t2 = 0;
1099
        for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1100
        for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1101
        tx = (mvx[t1] + mvx[t2]) / 2;
1102
        ty = (mvy[t1] + mvy[t2]) / 2;
1103
    } else
1104
        return; //no need to do MC for inter blocks
1105

    
1106
    uvmx = (tx + ((tx&3) == 3)) >> 1;
1107
    uvmy = (ty + ((ty&3) == 3)) >> 1;
1108

    
1109
    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1110
    uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1111

    
1112
    CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width  *  8,  8);
1113
    CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height *  8,  8);
1114
    srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1115
    srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1116
    if((unsigned)uvsrc_x > (s->h_edge_pos >> 1) - ((uvmx >> 1)&1) - 8
1117
       || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - ((uvmy >> 1)&1) - 8){
1118
        ff_emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize, 8+1, 8+1,
1119
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1120
        ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1121
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1122
        srcU = s->edge_emu_buffer;
1123
        srcV = s->edge_emu_buffer + 16;
1124
    }
1125

    
1126
    if(v->fastuvmc) {
1127
        uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1128
        uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1129
    }
1130

    
1131
    uvmx >>= 1;
1132
    uvmy >>= 1;
1133
    uvdxy = ((uvmy & 1) << 1) | (uvmx & 1);
1134
    dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize, 8);
1135
    dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize, 8);
1136
}
1137

    
1138
/**
1139
 * Decode Simple/Main Profiles sequence header
1140
 * @see Figure 7-8, p16-17
1141
 * @param avctx Codec context
1142
 * @param gb GetBit context initialized from Codec context extra_data
1143
 * @return Status
1144
 */
1145
static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1146
{
1147
    VC1Context *v = avctx->priv_data;
1148

    
1149
    av_log(avctx, AV_LOG_INFO, "Header: %0X\n", show_bits(gb, 32));
1150
    v->profile = get_bits(gb, 2);
1151
    if (v->profile == 2)
1152
    {
1153
        av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1154
        return -1;
1155
    }
1156

    
1157
    if (v->profile == PROFILE_ADVANCED)
1158
    {
1159
        v->level = get_bits(gb, 3);
1160
        if(v->level >= 5)
1161
        {
1162
            av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1163
        }
1164
        v->chromaformat = get_bits(gb, 2);
1165
        if (v->chromaformat != 1)
1166
        {
1167
            av_log(avctx, AV_LOG_ERROR,
1168
                   "Only 4:2:0 chroma format supported\n");
1169
            return -1;
1170
        }
1171
    }
1172
    else
1173
    {
1174
        v->res_sm = get_bits(gb, 2); //reserved
1175
        if (v->res_sm)
1176
        {
1177
            av_log(avctx, AV_LOG_ERROR,
1178
                   "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1179
            return -1;
1180
        }
1181
    }
1182

    
1183
    // (fps-2)/4 (->30)
1184
    v->frmrtq_postproc = get_bits(gb, 3); //common
1185
    // (bitrate-32kbps)/64kbps
1186
    v->bitrtq_postproc = get_bits(gb, 5); //common
1187
    v->s.loop_filter = get_bits(gb, 1); //common
1188
    if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1189
    {
1190
        av_log(avctx, AV_LOG_ERROR,
1191
               "LOOPFILTER shell not be enabled in simple profile\n");
1192
    }
1193

    
1194
    if (v->profile < PROFILE_ADVANCED)
1195
    {
1196
        v->res_x8 = get_bits(gb, 1); //reserved
1197
        if (v->res_x8)
1198
        {
1199
            av_log(avctx, AV_LOG_ERROR,
1200
                   "1 for reserved RES_X8 is forbidden\n");
1201
            //return -1;
1202
        }
1203
        v->multires = get_bits(gb, 1);
1204
        v->res_fasttx = get_bits(gb, 1);
1205
        if (!v->res_fasttx)
1206
        {
1207
            av_log(avctx, AV_LOG_ERROR,
1208
                   "0 for reserved RES_FASTTX is forbidden\n");
1209
            //return -1;
1210
        }
1211
    }
1212

    
1213
    v->fastuvmc =  get_bits(gb, 1); //common
1214
    if (!v->profile && !v->fastuvmc)
1215
    {
1216
        av_log(avctx, AV_LOG_ERROR,
1217
               "FASTUVMC unavailable in Simple Profile\n");
1218
        return -1;
1219
    }
1220
    v->extended_mv =  get_bits(gb, 1); //common
1221
    if (!v->profile && v->extended_mv)
1222
    {
1223
        av_log(avctx, AV_LOG_ERROR,
1224
               "Extended MVs unavailable in Simple Profile\n");
1225
        return -1;
1226
    }
1227
    v->dquant =  get_bits(gb, 2); //common
1228
    v->vstransform =  get_bits(gb, 1); //common
1229

    
1230
    if (v->profile < PROFILE_ADVANCED)
1231
    {
1232
        v->res_transtab = get_bits(gb, 1);
1233
        if (v->res_transtab)
1234
        {
1235
            av_log(avctx, AV_LOG_ERROR,
1236
                   "1 for reserved RES_TRANSTAB is forbidden\n");
1237
            return -1;
1238
        }
1239
    }
1240

    
1241
    v->overlap = get_bits(gb, 1); //common
1242

    
1243
    if (v->profile < PROFILE_ADVANCED)
1244
    {
1245
        v->s.resync_marker = get_bits(gb, 1);
1246
        v->rangered = get_bits(gb, 1);
1247
        if (v->rangered && v->profile == PROFILE_SIMPLE)
1248
        {
1249
            av_log(avctx, AV_LOG_INFO,
1250
                   "RANGERED should be set to 0 in simple profile\n");
1251
        }
1252
    }
1253

    
1254
    v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1255
    v->quantizer_mode = get_bits(gb, 2); //common
1256

    
1257
    if (v->profile < PROFILE_ADVANCED)
1258
    {
1259
        v->finterpflag = get_bits(gb, 1); //common
1260
        v->res_rtm_flag = get_bits(gb, 1); //reserved
1261
        if (!v->res_rtm_flag)
1262
        {
1263
            av_log(avctx, AV_LOG_ERROR,
1264
                   "0 for reserved RES_RTM_FLAG is forbidden\n");
1265
            //return -1;
1266
        }
1267
        av_log(avctx, AV_LOG_DEBUG,
1268
               "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1269
               "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1270
               "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1271
               "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1272
               v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1273
               v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1274
               v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1275
               v->dquant, v->quantizer_mode, avctx->max_b_frames
1276
               );
1277
        return 0;
1278
    }
1279
    return -1;
1280
}
1281

    
1282

    
1283
static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1284
{
1285
    int pqindex, lowquant, status;
1286

    
1287
    if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1288
    skip_bits(gb, 2); //framecnt unused
1289
    v->rangeredfrm = 0;
1290
    if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1291
    v->s.pict_type = get_bits(gb, 1);
1292
    if (v->s.avctx->max_b_frames) {
1293
        if (!v->s.pict_type) {
1294
            if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1295
            else v->s.pict_type = B_TYPE;
1296
        } else v->s.pict_type = P_TYPE;
1297
    } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1298

    
1299
    if(v->s.pict_type == I_TYPE)
1300
        get_bits(gb, 7); // skip buffer fullness
1301

    
1302
    /* Quantizer stuff */
1303
    pqindex = get_bits(gb, 5);
1304
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1305
        v->pq = pquant_table[0][pqindex];
1306
    else
1307
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1308

    
1309
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1310
        v->pquantizer = pqindex < 9;
1311
    if (v->quantizer_mode == QUANT_UNIFORM || v->quantizer_mode == QUANT_NON_UNIFORM)
1312
        v->pquantizer = v->quantizer_mode == QUANT_UNIFORM;
1313
    v->pqindex = pqindex;
1314
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1315
    else v->halfpq = 0;
1316
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1317
        v->pquantizer = get_bits(gb, 1);
1318
    v->dquantfrm = 0;
1319
    if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1320
    v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1321
    v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1322
    v->range_x = 1 << (v->k_x - 1);
1323
    v->range_y = 1 << (v->k_y - 1);
1324
    if (v->profile == PROFILE_ADVANCED)
1325
    {
1326
        if (v->postprocflag) v->postproc = get_bits(gb, 1);
1327
    }
1328
    else
1329
        if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1330

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

    
1334
    //TODO: complete parsing for P/B/BI frames
1335
    switch(v->s.pict_type) {
1336
    case P_TYPE:
1337
        if (v->pq < 5) v->tt_index = 0;
1338
        else if(v->pq < 13) v->tt_index = 1;
1339
        else v->tt_index = 2;
1340

    
1341
        lowquant = (v->pq > 12) ? 0 : 1;
1342
        v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1343
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1344
        {
1345
            int scale, shift, i;
1346
            v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1347
            v->lumscale = get_bits(gb, 6);
1348
            v->lumshift = get_bits(gb, 6);
1349
            /* fill lookup tables for intensity compensation */
1350
            if(!v->lumscale) {
1351
                scale = -64;
1352
                shift = (255 - v->lumshift * 2) << 6;
1353
                if(v->lumshift > 31)
1354
                    shift += 128 << 6;
1355
            } else {
1356
                scale = v->lumscale + 32;
1357
                if(v->lumshift > 31)
1358
                    shift = (v->lumshift - 64) << 6;
1359
                else
1360
                    shift = v->lumshift << 6;
1361
            }
1362
            for(i = 0; i < 256; i++) {
1363
                v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1364
                v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1365
            }
1366
        }
1367
        if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1368
            v->s.quarter_sample = 0;
1369
        else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1370
            if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1371
                v->s.quarter_sample = 0;
1372
            else
1373
                v->s.quarter_sample = 1;
1374
        } else
1375
            v->s.quarter_sample = 1;
1376

    
1377
        if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1378
                 v->mv_mode2 == MV_PMODE_MIXED_MV)
1379
                || v->mv_mode == MV_PMODE_MIXED_MV)
1380
        {
1381
            status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1382
            if (status < 0) return -1;
1383
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1384
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1385
        } else {
1386
            v->mv_type_is_raw = 0;
1387
            memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1388
        }
1389
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1390
        if (status < 0) return -1;
1391
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1392
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1393

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

    
1398
        if (v->dquant)
1399
        {
1400
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1401
            vop_dquant_decoding(v);
1402
        }
1403

    
1404
        v->ttfrm = 0; //FIXME Is that so ?
1405
        if (v->vstransform)
1406
        {
1407
            v->ttmbf = get_bits(gb, 1);
1408
            if (v->ttmbf)
1409
            {
1410
                v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1411
            }
1412
        }
1413
        break;
1414
    case B_TYPE:
1415
        break;
1416
    }
1417

    
1418
    /* AC Syntax */
1419
    v->c_ac_table_index = decode012(gb);
1420
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1421
    {
1422
        v->y_ac_table_index = decode012(gb);
1423
    }
1424
    /* DC Syntax */
1425
    v->s.dc_table_index = get_bits(gb, 1);
1426

    
1427
    return 0;
1428
}
1429

    
1430
/***********************************************************************/
1431
/**
1432
 * @defgroup block VC-1 Block-level functions
1433
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1434
 * @todo TODO: Integrate to MpegEncContext facilities
1435
 * @{
1436
 */
1437

    
1438
/**
1439
 * @def GET_MQUANT
1440
 * @brief Get macroblock-level quantizer scale
1441
 * @warning XXX: qdiff to the frame quant, not previous quant ?
1442
 * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1443
 */
1444
#define GET_MQUANT()                                           \
1445
  if (v->dquantfrm)                                            \
1446
  {                                                            \
1447
    int edges = 0;                                             \
1448
    if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1449
    {                                                          \
1450
      if (v->dqbilevel)                                        \
1451
      {                                                        \
1452
        mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
1453
      }                                                        \
1454
      else                                                     \
1455
      {                                                        \
1456
        mqdiff = get_bits(gb, 3);                              \
1457
        if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1458
        else mquant = get_bits(gb, 5);                         \
1459
      }                                                        \
1460
    }                                                          \
1461
    if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
1462
        edges = 1 << v->dqsbedge;                              \
1463
    else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1464
        edges = (3 << v->dqsbedge) % 15;                       \
1465
    else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1466
        edges = 15;                                            \
1467
    if((edges&1) && !s->mb_x)                                  \
1468
        mquant = v->altpq;                                     \
1469
    if((edges&2) && s->first_slice_line)                       \
1470
        mquant = v->altpq;                                     \
1471
    if((edges&4) && s->mb_x == (s->mb_width - 1))              \
1472
        mquant = v->altpq;                                     \
1473
    if((edges&8) && s->mb_y == (s->mb_height - 1))             \
1474
        mquant = v->altpq;                                     \
1475
  }
1476

    
1477
/**
1478
 * @def GET_MVDATA(_dmv_x, _dmv_y)
1479
 * @brief Get MV differentials
1480
 * @see MVDATA decoding from 8.3.5.2, p(1)20
1481
 * @param _dmv_x Horizontal differential for decoded MV
1482
 * @param _dmv_y Vertical differential for decoded MV
1483
 * @todo TODO: Use MpegEncContext arrays to store them
1484
 */
1485
#define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1486
  index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1487
                       VC1_MV_DIFF_VLC_BITS, 2);                    \
1488
  if (index > 36)                                                   \
1489
  {                                                                 \
1490
    mb_has_coeffs = 1;                                              \
1491
    index -= 37;                                                    \
1492
  }                                                                 \
1493
  else mb_has_coeffs = 0;                                           \
1494
  s->mb_intra = 0;                                                  \
1495
  if (!index) { _dmv_x = _dmv_y = 0; }                              \
1496
  else if (index == 35)                                             \
1497
  {                                                                 \
1498
    _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1499
    _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1500
  }                                                                 \
1501
  else if (index == 36)                                             \
1502
  {                                                                 \
1503
    _dmv_x = 0;                                                     \
1504
    _dmv_y = 0;                                                     \
1505
    s->mb_intra = 1;                                                \
1506
  }                                                                 \
1507
  else                                                              \
1508
  {                                                                 \
1509
    index1 = index%6;                                               \
1510
    if (!s->quarter_sample && index1 == 5) val = 1;                 \
1511
    else                                   val = 0;                 \
1512
    if(size_table[index1] - val > 0)                                \
1513
        val = get_bits(gb, size_table[index1] - val);               \
1514
    else                                   val = 0;                 \
1515
    sign = 0 - (val&1);                                             \
1516
    _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1517
                                                                    \
1518
    index1 = index/6;                                               \
1519
    if (!s->quarter_sample && index1 == 5) val = 1;                 \
1520
    else                                   val = 0;                 \
1521
    if(size_table[index1] - val > 0)                                \
1522
        val = get_bits(gb, size_table[index1] - val);               \
1523
    else                                   val = 0;                 \
1524
    sign = 0 - (val&1);                                             \
1525
    _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1526
  }
1527

    
1528
/** Predict and set motion vector
1529
 */
1530
static inline void vc1_pred_mv(MpegEncContext *s, int n, int dmv_x, int dmv_y, int mv1, int r_x, int r_y, uint8_t* is_intra)
1531
{
1532
    int xy, wrap, off = 0;
1533
    int16_t *A, *B, *C;
1534
    int px, py;
1535
    int sum;
1536

    
1537
    /* scale MV difference to be quad-pel */
1538
    dmv_x <<= 1 - s->quarter_sample;
1539
    dmv_y <<= 1 - s->quarter_sample;
1540

    
1541
    wrap = s->b8_stride;
1542
    xy = s->block_index[n];
1543

    
1544
    if(s->mb_intra){
1545
        s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1546
        s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1547
        if(mv1) { /* duplicate motion data for 1-MV block */
1548
            s->current_picture.motion_val[0][xy + 1][0] = 0;
1549
            s->current_picture.motion_val[0][xy + 1][1] = 0;
1550
            s->current_picture.motion_val[0][xy + wrap][0] = 0;
1551
            s->current_picture.motion_val[0][xy + wrap][1] = 0;
1552
            s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1553
            s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1554
        }
1555
        return;
1556
    }
1557

    
1558
    C = s->current_picture.motion_val[0][xy - 1];
1559
    A = s->current_picture.motion_val[0][xy - wrap];
1560
    if(mv1)
1561
        off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1562
    else {
1563
        //in 4-MV mode different blocks have different B predictor position
1564
        switch(n){
1565
        case 0:
1566
            off = (s->mb_x > 0) ? -1 : 1;
1567
            break;
1568
        case 1:
1569
            off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1570
            break;
1571
        case 2:
1572
            off = 1;
1573
            break;
1574
        case 3:
1575
            off = -1;
1576
        }
1577
    }
1578
    B = s->current_picture.motion_val[0][xy - wrap + off];
1579

    
1580
    if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
1581
        if(s->mb_width == 1) {
1582
            px = A[0];
1583
            py = A[1];
1584
        } else {
1585
            px = mid_pred(A[0], B[0], C[0]);
1586
            py = mid_pred(A[1], B[1], C[1]);
1587
        }
1588
    } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
1589
        px = C[0];
1590
        py = C[1];
1591
    } else {
1592
        px = py = 0;
1593
    }
1594
    /* Pullback MV as specified in 8.3.5.3.4 */
1595
    {
1596
        int qx, qy, X, Y;
1597
        qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
1598
        qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
1599
        X = (s->mb_width << 6) - 4;
1600
        Y = (s->mb_height << 6) - 4;
1601
        if(mv1) {
1602
            if(qx + px < -60) px = -60 - qx;
1603
            if(qy + py < -60) py = -60 - qy;
1604
        } else {
1605
            if(qx + px < -28) px = -28 - qx;
1606
            if(qy + py < -28) py = -28 - qy;
1607
        }
1608
        if(qx + px > X) px = X - qx;
1609
        if(qy + py > Y) py = Y - qy;
1610
    }
1611
    /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1612
    if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
1613
        if(is_intra[xy - wrap])
1614
            sum = ABS(px) + ABS(py);
1615
        else
1616
            sum = ABS(px - A[0]) + ABS(py - A[1]);
1617
        if(sum > 32) {
1618
            if(get_bits1(&s->gb)) {
1619
                px = A[0];
1620
                py = A[1];
1621
            } else {
1622
                px = C[0];
1623
                py = C[1];
1624
            }
1625
        } else {
1626
            if(is_intra[xy - 1])
1627
                sum = ABS(px) + ABS(py);
1628
            else
1629
                sum = ABS(px - C[0]) + ABS(py - C[1]);
1630
            if(sum > 32) {
1631
                if(get_bits1(&s->gb)) {
1632
                    px = A[0];
1633
                    py = A[1];
1634
                } else {
1635
                    px = C[0];
1636
                    py = C[1];
1637
                }
1638
            }
1639
        }
1640
    }
1641
    /* store MV using signed modulus of MV range defined in 4.11 */
1642
    s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1643
    s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1644
    if(mv1) { /* duplicate motion data for 1-MV block */
1645
        s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
1646
        s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
1647
        s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
1648
        s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
1649
        s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
1650
        s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
1651
    }
1652
}
1653

    
1654
/** Get predicted DC value for I-frames only
1655
 * prediction dir: left=0, top=1
1656
 * @param s MpegEncContext
1657
 * @param[in] n block index in the current MB
1658
 * @param dc_val_ptr Pointer to DC predictor
1659
 * @param dir_ptr Prediction direction for use in AC prediction
1660
 */
1661
static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1662
                              int16_t **dc_val_ptr, int *dir_ptr)
1663
{
1664
    int a, b, c, wrap, pred, scale;
1665
    int16_t *dc_val;
1666
    static const uint16_t dcpred[32] = {
1667
    -1, 1024,  512,  341,  256,  205,  171,  146,  128,
1668
         114,  102,   93,   85,   79,   73,   68,   64,
1669
          60,   57,   54,   51,   49,   47,   45,   43,
1670
          41,   39,   38,   37,   35,   34,   33
1671
    };
1672

    
1673
    /* find prediction - wmv3_dc_scale always used here in fact */
1674
    if (n < 4)     scale = s->y_dc_scale;
1675
    else           scale = s->c_dc_scale;
1676

    
1677
    wrap = s->block_wrap[n];
1678
    dc_val= s->dc_val[0] + s->block_index[n];
1679

    
1680
    /* B A
1681
     * C X
1682
     */
1683
    c = dc_val[ - 1];
1684
    b = dc_val[ - 1 - wrap];
1685
    a = dc_val[ - wrap];
1686

    
1687
    if (pq < 9 || !overlap)
1688
    {
1689
        /* Set outer values */
1690
        if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
1691
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1692
    }
1693
    else
1694
    {
1695
        /* Set outer values */
1696
        if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
1697
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1698
    }
1699

    
1700
    if (abs(a - b) <= abs(b - c)) {
1701
        pred = c;
1702
        *dir_ptr = 1;//left
1703
    } else {
1704
        pred = a;
1705
        *dir_ptr = 0;//top
1706
    }
1707

    
1708
    /* update predictor */
1709
    *dc_val_ptr = &dc_val[0];
1710
    return pred;
1711
}
1712

    
1713

    
1714
/** Get predicted DC value
1715
 * prediction dir: left=0, top=1
1716
 * @param s MpegEncContext
1717
 * @param[in] n block index in the current MB
1718
 * @param dc_val_ptr Pointer to DC predictor
1719
 * @param dir_ptr Prediction direction for use in AC prediction
1720
 */
1721
static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1722
                              int a_avail, int c_avail,
1723
                              int16_t **dc_val_ptr, int *dir_ptr)
1724
{
1725
    int a, b, c, wrap, pred, scale;
1726
    int16_t *dc_val;
1727
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1728
    int q1, q2 = 0;
1729

    
1730
    /* find prediction - wmv3_dc_scale always used here in fact */
1731
    if (n < 4)     scale = s->y_dc_scale;
1732
    else           scale = s->c_dc_scale;
1733

    
1734
    wrap = s->block_wrap[n];
1735
    dc_val= s->dc_val[0] + s->block_index[n];
1736

    
1737
    /* B A
1738
     * C X
1739
     */
1740
    c = dc_val[ - 1];
1741
    b = dc_val[ - 1 - wrap];
1742
    a = dc_val[ - wrap];
1743

    
1744
    if(a_avail && c_avail) {
1745
        if(abs(a - b) <= abs(b - c)) {
1746
            pred = c;
1747
            *dir_ptr = 1;//left
1748
            q2 = s->current_picture.qscale_table[mb_pos - 1];
1749
        } else {
1750
            pred = a;
1751
            *dir_ptr = 0;//top
1752
            q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
1753
        }
1754
    } else if(a_avail) {
1755
        pred = a;
1756
        *dir_ptr = 0;//top
1757
        q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
1758
    } else if(c_avail) {
1759
        pred = c;
1760
        *dir_ptr = 1;//left
1761
        q2 = s->current_picture.qscale_table[mb_pos - 1];
1762
    } else {
1763
        pred = 0;
1764
        *dir_ptr = 1;//left
1765
    }
1766

    
1767
    /* scale coeffs if needed */
1768
    q1 = s->current_picture.qscale_table[mb_pos];
1769
    if(n && n<4) q2=q1;
1770

    
1771
    if(q2 && q1!=q2) {
1772
        pred = (pred * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1773
    }
1774

    
1775
    /* update predictor */
1776
    *dc_val_ptr = &dc_val[0];
1777
    return pred;
1778
}
1779

    
1780

    
1781
/**
1782
 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
1783
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1784
 * @todo TODO: Integrate to MpegEncContext facilities
1785
 * @{
1786
 */
1787

    
1788
static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1789
{
1790
    int xy, wrap, pred, a, b, c;
1791

    
1792
    xy = s->block_index[n];
1793
    wrap = s->b8_stride;
1794

    
1795
    /* B C
1796
     * A X
1797
     */
1798
    a = s->coded_block[xy - 1       ];
1799
    b = s->coded_block[xy - 1 - wrap];
1800
    c = s->coded_block[xy     - wrap];
1801

    
1802
    if (b == c) {
1803
        pred = a;
1804
    } else {
1805
        pred = c;
1806
    }
1807

    
1808
    /* store value */
1809
    *coded_block_ptr = &s->coded_block[xy];
1810

    
1811
    return pred;
1812
}
1813

    
1814
/**
1815
 * Decode one AC coefficient
1816
 * @param v The VC1 context
1817
 * @param last Last coefficient
1818
 * @param skip How much zero coefficients to skip
1819
 * @param value Decoded AC coefficient value
1820
 * @see 8.1.3.4
1821
 */
1822
static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
1823
{
1824
    GetBitContext *gb = &v->s.gb;
1825
    int index, escape, run = 0, level = 0, lst = 0;
1826

    
1827
    index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1828
    if (index != vc1_ac_sizes[codingset] - 1) {
1829
        run = vc1_index_decode_table[codingset][index][0];
1830
        level = vc1_index_decode_table[codingset][index][1];
1831
        lst = index >= vc1_last_decode_table[codingset];
1832
        if(get_bits(gb, 1))
1833
            level = -level;
1834
    } else {
1835
        escape = decode210(gb);
1836
        if (escape != 2) {
1837
            index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1838
            run = vc1_index_decode_table[codingset][index][0];
1839
            level = vc1_index_decode_table[codingset][index][1];
1840
            lst = index >= vc1_last_decode_table[codingset];
1841
            if(escape == 0) {
1842
                if(lst)
1843
                    level += vc1_last_delta_level_table[codingset][run];
1844
                else
1845
                    level += vc1_delta_level_table[codingset][run];
1846
            } else {
1847
                if(lst)
1848
                    run += vc1_last_delta_run_table[codingset][level] + 1;
1849
                else
1850
                    run += vc1_delta_run_table[codingset][level] + 1;
1851
            }
1852
            if(get_bits(gb, 1))
1853
                level = -level;
1854
        } else {
1855
            int sign;
1856
            lst = get_bits(gb, 1);
1857
            if(v->s.esc3_level_length == 0) {
1858
                if(v->pq < 8 || v->dquantfrm) { // table 59
1859
                    v->s.esc3_level_length = get_bits(gb, 3);
1860
                    if(!v->s.esc3_level_length)
1861
                        v->s.esc3_level_length = get_bits(gb, 2) + 8;
1862
                } else { //table 60
1863
                    v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
1864
                }
1865
                v->s.esc3_run_length = 3 + get_bits(gb, 2);
1866
            }
1867
            run = get_bits(gb, v->s.esc3_run_length);
1868
            sign = get_bits(gb, 1);
1869
            level = get_bits(gb, v->s.esc3_level_length);
1870
            if(sign)
1871
                level = -level;
1872
        }
1873
    }
1874

    
1875
    *last = lst;
1876
    *skip = run;
1877
    *value = level;
1878
}
1879

    
1880
/** Decode intra block in intra frames - should be faster than decode_intra_block
1881
 * @param v VC1Context
1882
 * @param block block to decode
1883
 * @param coded are AC coeffs present or not
1884
 * @param codingset set of VLC to decode data
1885
 */
1886
static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
1887
{
1888
    GetBitContext *gb = &v->s.gb;
1889
    MpegEncContext *s = &v->s;
1890
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
1891
    int run_diff, i;
1892
    int16_t *dc_val;
1893
    int16_t *ac_val, *ac_val2;
1894
    int dcdiff;
1895

    
1896
    /* Get DC differential */
1897
    if (n < 4) {
1898
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1899
    } else {
1900
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1901
    }
1902
    if (dcdiff < 0){
1903
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1904
        return -1;
1905
    }
1906
    if (dcdiff)
1907
    {
1908
        if (dcdiff == 119 /* ESC index value */)
1909
        {
1910
            /* TODO: Optimize */
1911
            if (v->pq == 1) dcdiff = get_bits(gb, 10);
1912
            else if (v->pq == 2) dcdiff = get_bits(gb, 9);
1913
            else dcdiff = get_bits(gb, 8);
1914
        }
1915
        else
1916
        {
1917
            if (v->pq == 1)
1918
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1919
            else if (v->pq == 2)
1920
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1921
        }
1922
        if (get_bits(gb, 1))
1923
            dcdiff = -dcdiff;
1924
    }
1925

    
1926
    /* Prediction */
1927
    dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
1928
    *dc_val = dcdiff;
1929

    
1930
    /* Store the quantized DC coeff, used for prediction */
1931
    if (n < 4) {
1932
        block[0] = dcdiff * s->y_dc_scale;
1933
    } else {
1934
        block[0] = dcdiff * s->c_dc_scale;
1935
    }
1936
    /* Skip ? */
1937
    run_diff = 0;
1938
    i = 0;
1939
    if (!coded) {
1940
        goto not_coded;
1941
    }
1942

    
1943
    //AC Decoding
1944
    i = 1;
1945

    
1946
    {
1947
        int last = 0, skip, value;
1948
        const int8_t *zz_table;
1949
        int scale;
1950
        int k;
1951

    
1952
        scale = v->pq * 2 + v->halfpq;
1953

    
1954
        if(v->s.ac_pred) {
1955
            if(!dc_pred_dir)
1956
                zz_table = vc1_horizontal_zz;
1957
            else
1958
                zz_table = vc1_vertical_zz;
1959
        } else
1960
            zz_table = vc1_normal_zz;
1961

    
1962
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1963
        ac_val2 = ac_val;
1964
        if(dc_pred_dir) //left
1965
            ac_val -= 16;
1966
        else //top
1967
            ac_val -= 16 * s->block_wrap[n];
1968

    
1969
        while (!last) {
1970
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
1971
            i += skip;
1972
            if(i > 63)
1973
                break;
1974
            block[zz_table[i++]] = value;
1975
        }
1976

    
1977
        /* apply AC prediction if needed */
1978
        if(s->ac_pred) {
1979
            if(dc_pred_dir) { //left
1980
                for(k = 1; k < 8; k++)
1981
                    block[k << 3] += ac_val[k];
1982
            } else { //top
1983
                for(k = 1; k < 8; k++)
1984
                    block[k] += ac_val[k + 8];
1985
            }
1986
        }
1987
        /* save AC coeffs for further prediction */
1988
        for(k = 1; k < 8; k++) {
1989
            ac_val2[k] = block[k << 3];
1990
            ac_val2[k + 8] = block[k];
1991
        }
1992

    
1993
        /* scale AC coeffs */
1994
        for(k = 1; k < 64; k++)
1995
            if(block[k]) {
1996
                block[k] *= scale;
1997
                if(!v->pquantizer)
1998
                    block[k] += (block[k] < 0) ? -v->pq : v->pq;
1999
            }
2000

    
2001
        if(s->ac_pred) i = 63;
2002
    }
2003

    
2004
not_coded:
2005
    if(!coded) {
2006
        int k, scale;
2007
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2008
        ac_val2 = ac_val;
2009

    
2010
        scale = v->pq * 2 + v->halfpq;
2011
        memset(ac_val2, 0, 16 * 2);
2012
        if(dc_pred_dir) {//left
2013
            ac_val -= 16;
2014
            if(s->ac_pred)
2015
                memcpy(ac_val2, ac_val, 8 * 2);
2016
        } else {//top
2017
            ac_val -= 16 * s->block_wrap[n];
2018
            if(s->ac_pred)
2019
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2020
        }
2021

    
2022
        /* apply AC prediction if needed */
2023
        if(s->ac_pred) {
2024
            if(dc_pred_dir) { //left
2025
                for(k = 1; k < 8; k++) {
2026
                    block[k << 3] = ac_val[k] * scale;
2027
                    if(!v->pquantizer)
2028
                        block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2029
                }
2030
            } else { //top
2031
                for(k = 1; k < 8; k++) {
2032
                    block[k] = ac_val[k + 8] * scale;
2033
                    if(!v->pquantizer)
2034
                        block[k] += (block[k] < 0) ? -v->pq : v->pq;
2035
                }
2036
            }
2037
            i = 63;
2038
        }
2039
    }
2040
    s->block_last_index[n] = i;
2041

    
2042
    return 0;
2043
}
2044

    
2045
/** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2046
 * @param v VC1Context
2047
 * @param block block to decode
2048
 * @param coded are AC coeffs present or not
2049
 * @param mquant block quantizer
2050
 * @param codingset set of VLC to decode data
2051
 */
2052
static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
2053
{
2054
    GetBitContext *gb = &v->s.gb;
2055
    MpegEncContext *s = &v->s;
2056
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
2057
    int run_diff, i;
2058
    int16_t *dc_val;
2059
    int16_t *ac_val, *ac_val2;
2060
    int dcdiff;
2061
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2062
    int a_avail = v->a_avail, c_avail = v->c_avail;
2063
    int use_pred = s->ac_pred;
2064
    int scale;
2065
    int q1, q2 = 0;
2066

    
2067
    /* XXX: Guard against dumb values of mquant */
2068
    mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
2069

    
2070
    /* Set DC scale - y and c use the same */
2071
    s->y_dc_scale = s->y_dc_scale_table[mquant];
2072
    s->c_dc_scale = s->c_dc_scale_table[mquant];
2073

    
2074
    /* Get DC differential */
2075
    if (n < 4) {
2076
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2077
    } else {
2078
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2079
    }
2080
    if (dcdiff < 0){
2081
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2082
        return -1;
2083
    }
2084
    if (dcdiff)
2085
    {
2086
        if (dcdiff == 119 /* ESC index value */)
2087
        {
2088
            /* TODO: Optimize */
2089
            if (mquant == 1) dcdiff = get_bits(gb, 10);
2090
            else if (mquant == 2) dcdiff = get_bits(gb, 9);
2091
            else dcdiff = get_bits(gb, 8);
2092
        }
2093
        else
2094
        {
2095
            if (mquant == 1)
2096
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2097
            else if (mquant == 2)
2098
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2099
        }
2100
        if (get_bits(gb, 1))
2101
            dcdiff = -dcdiff;
2102
    }
2103

    
2104
    /* Prediction */
2105
    dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2106
    *dc_val = dcdiff;
2107

    
2108
    /* Store the quantized DC coeff, used for prediction */
2109

    
2110
    if (n < 4) {
2111
        block[0] = dcdiff * s->y_dc_scale;
2112
    } else {
2113
        block[0] = dcdiff * s->c_dc_scale;
2114
    }
2115
    /* Skip ? */
2116
    run_diff = 0;
2117
    i = 0;
2118

    
2119
    //AC Decoding
2120
    i = 1;
2121

    
2122
    /* check if AC is needed at all and adjust direction if needed */
2123
    if(!a_avail) dc_pred_dir = 1;
2124
    if(!c_avail) dc_pred_dir = 0;
2125
    if(!a_avail && !c_avail) use_pred = 0;
2126
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2127
    ac_val2 = ac_val;
2128

    
2129
    scale = mquant * 2;
2130

    
2131
    if(dc_pred_dir) //left
2132
        ac_val -= 16;
2133
    else //top
2134
        ac_val -= 16 * s->block_wrap[n];
2135

    
2136
    q1 = s->current_picture.qscale_table[mb_pos];
2137
    if(dc_pred_dir && c_avail) q2 = s->current_picture.qscale_table[mb_pos - 1];
2138
    if(!dc_pred_dir && a_avail) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2139
    if(n && n<4) q2 = q1;
2140

    
2141
    if(coded) {
2142
        int last = 0, skip, value;
2143
        const int8_t *zz_table;
2144
        int k;
2145

    
2146
        zz_table = vc1_simple_progressive_8x8_zz;
2147

    
2148
        while (!last) {
2149
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2150
            i += skip;
2151
            if(i > 63)
2152
                break;
2153
            block[zz_table[i++]] = value;
2154
        }
2155

    
2156
        /* apply AC prediction if needed */
2157
        if(use_pred) {
2158
            /* scale predictors if needed*/
2159
            if(q2 && q1!=q2) {
2160
                q1 = q1 * 2 - 1;
2161
                q2 = q2 * 2 - 1;
2162

    
2163
                if(dc_pred_dir) { //left
2164
                    for(k = 1; k < 8; k++)
2165
                        block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2166
                } else { //top
2167
                    for(k = 1; k < 8; k++)
2168
                        block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2169
                }
2170
            } else {
2171
                if(dc_pred_dir) { //left
2172
                    for(k = 1; k < 8; k++)
2173
                        block[k << 3] += ac_val[k];
2174
                } else { //top
2175
                    for(k = 1; k < 8; k++)
2176
                        block[k] += ac_val[k + 8];
2177
                }
2178
            }
2179
        }
2180
        /* save AC coeffs for further prediction */
2181
        for(k = 1; k < 8; k++) {
2182
            ac_val2[k] = block[k << 3];
2183
            ac_val2[k + 8] = block[k];
2184
        }
2185

    
2186
        /* scale AC coeffs */
2187
        for(k = 1; k < 64; k++)
2188
            if(block[k]) {
2189
                block[k] *= scale;
2190
                if(!v->pquantizer)
2191
                    block[k] += (block[k] < 0) ? -mquant : mquant;
2192
            }
2193

    
2194
        if(use_pred) i = 63;
2195
    } else { // no AC coeffs
2196
        int k;
2197

    
2198
        memset(ac_val2, 0, 16 * 2);
2199
        if(dc_pred_dir) {//left
2200
            if(use_pred) {
2201
                memcpy(ac_val2, ac_val, 8 * 2);
2202
                if(q2 && q1!=q2) {
2203
                    q1 = q1 * 2 - 1;
2204
                    q2 = q2 * 2 - 1;
2205
                    for(k = 1; k < 8; k++)
2206
                        ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2207
                }
2208
            }
2209
        } else {//top
2210
            if(use_pred) {
2211
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2212
                if(q2 && q1!=q2) {
2213
                    q1 = q1 * 2 - 1;
2214
                    q2 = q2 * 2 - 1;
2215
                    for(k = 1; k < 8; k++)
2216
                        ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2217
                }
2218
            }
2219
        }
2220

    
2221
        /* apply AC prediction if needed */
2222
        if(use_pred) {
2223
            if(dc_pred_dir) { //left
2224
                for(k = 1; k < 8; k++) {
2225
                    block[k << 3] = ac_val2[k] * scale;
2226
                    if(!v->pquantizer)
2227
                        block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2228
                }
2229
            } else { //top
2230
                for(k = 1; k < 8; k++) {
2231
                    block[k] = ac_val2[k + 8] * scale;
2232
                    if(!v->pquantizer)
2233
                        block[k] += (block[k] < 0) ? -mquant : mquant;
2234
                }
2235
            }
2236
            i = 63;
2237
        }
2238
    }
2239
    s->block_last_index[n] = i;
2240

    
2241
    return 0;
2242
}
2243

    
2244
/** Decode P block
2245
 */
2246
static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
2247
{
2248
    MpegEncContext *s = &v->s;
2249
    GetBitContext *gb = &s->gb;
2250
    int i, j;
2251
    int subblkpat = 0;
2252
    int scale, off, idx, last, skip, value;
2253
    int ttblk = ttmb & 7;
2254

    
2255
    if(ttmb == -1) {
2256
        ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
2257
    }
2258
    if(ttblk == TT_4X4) {
2259
        subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
2260
    }
2261
    if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
2262
        subblkpat = decode012(gb);
2263
        if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
2264
        if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
2265
        if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
2266
    }
2267
    scale = 2 * mquant;
2268

    
2269
    // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2270
    if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
2271
        subblkpat = 2 - (ttblk == TT_8X4_TOP);
2272
        ttblk = TT_8X4;
2273
    }
2274
    if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
2275
        subblkpat = 2 - (ttblk == TT_4X8_LEFT);
2276
        ttblk = TT_4X8;
2277
    }
2278
    switch(ttblk) {
2279
    case TT_8X8:
2280
        i = 0;
2281
        last = 0;
2282
        while (!last) {
2283
            vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2284
            i += skip;
2285
            if(i > 63)
2286
                break;
2287
            idx = vc1_simple_progressive_8x8_zz[i++];
2288
            block[idx] = value * scale;
2289
        }
2290
        vc1_inv_trans(block, 8, 8);
2291
        break;
2292
    case TT_4X4:
2293
        for(j = 0; j < 4; j++) {
2294
            last = subblkpat & (1 << (3 - j));
2295
            i = 0;
2296
            off = (j & 1) * 4 + (j & 2) * 16;
2297
            while (!last) {
2298
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2299
                i += skip;
2300
                if(i > 15)
2301
                    break;
2302
                idx = vc1_simple_progressive_4x4_zz[i++];
2303
                block[idx + off] = value * scale;
2304
            }
2305
            if(!(subblkpat & (1 << (3 - j))))
2306
                vc1_inv_trans(block + off, 4, 4);
2307
        }
2308
        break;
2309
    case TT_8X4:
2310
        for(j = 0; j < 2; j++) {
2311
            last = subblkpat & (1 << (1 - j));
2312
            i = 0;
2313
            off = j * 32;
2314
            while (!last) {
2315
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2316
                i += skip;
2317
                if(i > 31)
2318
                    break;
2319
                idx = vc1_simple_progressive_8x4_zz[i++];
2320
                block[idx + off] = value * scale;
2321
            }
2322
            if(!(subblkpat & (1 << (1 - j))))
2323
                vc1_inv_trans(block + off, 8, 4);
2324
        }
2325
        break;
2326
    case TT_4X8:
2327
        for(j = 0; j < 2; j++) {
2328
            last = subblkpat & (1 << (1 - j));
2329
            i = 0;
2330
            off = j * 4;
2331
            while (!last) {
2332
                vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2333
                i += skip;
2334
                if(i > 31)
2335
                    break;
2336
                idx = vc1_simple_progressive_4x8_zz[i++];
2337
                block[idx + off] = value * scale;
2338
            }
2339
            if(!(subblkpat & (1 << (1 - j))))
2340
                vc1_inv_trans(block + off, 4, 8);
2341
        }
2342
        break;
2343
    }
2344
    return 0;
2345
}
2346

    
2347

    
2348
/** Decode one P-frame MB (in Simple/Main profile)
2349
 * @todo TODO: Extend to AP
2350
 * @fixme FIXME: DC value for inter blocks not set
2351
 */
2352
static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64])
2353
{
2354
    MpegEncContext *s = &v->s;
2355
    GetBitContext *gb = &s->gb;
2356
    int i, j;
2357
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2358
    int cbp; /* cbp decoding stuff */
2359
    int mqdiff, mquant; /* MB quantization */
2360
    int ttmb = v->ttfrm; /* MB Transform type */
2361
    int status;
2362

    
2363
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2364
      offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2365
    int mb_has_coeffs = 1; /* last_flag */
2366
    int dmv_x, dmv_y; /* Differential MV components */
2367
    int index, index1; /* LUT indices */
2368
    int val, sign; /* temp values */
2369
    int first_block = 1;
2370
    int dst_idx, off;
2371
    int skipped, fourmv;
2372

    
2373
    mquant = v->pq; /* Loosy initialization */
2374

    
2375
    if (v->mv_type_is_raw)
2376
        fourmv = get_bits1(gb);
2377
    else
2378
        fourmv = v->mv_type_mb_plane[mb_pos];
2379
    if (v->skip_is_raw)
2380
        skipped = get_bits1(gb);
2381
    else
2382
        skipped = v->s.mbskip_table[mb_pos];
2383

    
2384
    s->dsp.clear_blocks(s->block[0]);
2385

    
2386
    if (!fourmv) /* 1MV mode */
2387
    {
2388
        if (!skipped)
2389
        {
2390
            GET_MVDATA(dmv_x, dmv_y);
2391

    
2392
            s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
2393
            vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
2394

    
2395
            /* FIXME Set DC val for inter block ? */
2396
            if (s->mb_intra && !mb_has_coeffs)
2397
            {
2398
                GET_MQUANT();
2399
                s->ac_pred = get_bits(gb, 1);
2400
                cbp = 0;
2401
            }
2402
            else if (mb_has_coeffs)
2403
            {
2404
                if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2405
                cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2406
                GET_MQUANT();
2407
            }
2408
            else
2409
            {
2410
                mquant = v->pq;
2411
                cbp = 0;
2412
            }
2413
            s->current_picture.qscale_table[mb_pos] = mquant;
2414

    
2415
            if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2416
                ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2417
                                VC1_TTMB_VLC_BITS, 2);
2418
            if(!s->mb_intra) vc1_mc_1mv(v);
2419
            dst_idx = 0;
2420
            for (i=0; i<6; i++)
2421
            {
2422
                s->dc_val[0][s->block_index[i]] = 0;
2423
                dst_idx += i >> 2;
2424
                val = ((cbp >> (5 - i)) & 1);
2425
                off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2426
                v->mb_type[0][s->block_index[i]] = s->mb_intra;
2427
                if(s->mb_intra) {
2428
                    /* check if prediction blocks A and C are available */
2429
                    v->a_avail = v->c_avail = 0;
2430
                    if(i == 2 || i == 3 || !s->first_slice_line)
2431
                        v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2432
                    if(i == 1 || i == 3 || s->mb_x)
2433
                        v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2434

    
2435
                    vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2436
                    vc1_inv_trans(block[i], 8, 8);
2437
                    for(j = 0; j < 64; j++) block[i][j] += 128;
2438
                    s->dsp.put_pixels_clamped(block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2439
                    /* TODO: proper loop filtering */
2440
                    if(v->pq >= 9 && v->overlap) {
2441
                        if(v->a_avail)
2442
                            vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2443
                        if(v->c_avail)
2444
                            vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2445
                    }
2446
                } else if(val) {
2447
                    vc1_decode_p_block(v, block[i], i, mquant, ttmb, first_block);
2448
                    if(!v->ttmbf && ttmb < 8) ttmb = -1;
2449
                    first_block = 0;
2450
                    s->dsp.add_pixels_clamped(block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2451
                }
2452
            }
2453
        }
2454
        else //Skipped
2455
        {
2456
            s->mb_intra = 0;
2457
            for(i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
2458
            s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
2459
            s->current_picture.qscale_table[mb_pos] = 0;
2460
            vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
2461
            vc1_mc_1mv(v);
2462
            return 0;
2463
        }
2464
    } //1MV mode
2465
    else //4MV mode
2466
    {
2467
        if (!skipped /* unskipped MB */)
2468
        {
2469
            int intra_count = 0, coded_inter = 0;
2470
            int is_intra[6], is_coded[6];
2471
            /* Get CBPCY */
2472
            cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2473
            for (i=0; i<6; i++)
2474
            {
2475
                val = ((cbp >> (5 - i)) & 1);
2476
                s->dc_val[0][s->block_index[i]] = 0;
2477
                s->mb_intra = 0;
2478
                if(i < 4) {
2479
                    dmv_x = dmv_y = 0;
2480
                    s->mb_intra = 0;
2481
                    mb_has_coeffs = 0;
2482
                    if(val) {
2483
                        GET_MVDATA(dmv_x, dmv_y);
2484
                    }
2485
                    vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
2486
                    if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
2487
                    intra_count += s->mb_intra;
2488
                    is_intra[i] = s->mb_intra;
2489
                    is_coded[i] = mb_has_coeffs;
2490
                }
2491
                if(i&4){
2492
                    is_intra[i] = (intra_count >= 3);
2493
                    is_coded[i] = val;
2494
                }
2495
                if(i == 4) vc1_mc_4mv_chroma(v);
2496
                v->mb_type[0][s->block_index[i]] = is_intra[i];
2497
                if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
2498
            }
2499
            // if there are no coded blocks then don't do anything more
2500
            if(!intra_count && !coded_inter) return 0;
2501
            dst_idx = 0;
2502
            GET_MQUANT();
2503
            s->current_picture.qscale_table[mb_pos] = mquant;
2504
            /* test if block is intra and has pred */
2505
            {
2506
                int intrapred = 0;
2507
                for(i=0; i<6; i++)
2508
                    if(is_intra[i]) {
2509
                        if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
2510
                            || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
2511
                            intrapred = 1;
2512
                            break;
2513
                        }
2514
                    }
2515
                if(intrapred)s->ac_pred = get_bits(gb, 1);
2516
                else s->ac_pred = 0;
2517
            }
2518
            if (!v->ttmbf && coded_inter)
2519
                ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 12);
2520
            for (i=0; i<6; i++)
2521
            {
2522
                dst_idx += i >> 2;
2523
                off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2524
                s->mb_intra = is_intra[i];
2525
                if (is_intra[i]) {
2526
                    /* check if prediction blocks A and C are available */
2527
                    v->a_avail = v->c_avail = 0;
2528
                    if(i == 2 || i == 3 || !s->first_slice_line)
2529
                        v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2530
                    if(i == 1 || i == 3 || s->mb_x)
2531
                        v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2532

    
2533
                    vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
2534
                    vc1_inv_trans(block[i], 8, 8);
2535
                    for(j = 0; j < 64; j++) block[i][j] += 128;
2536
                    s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2537
                    /* TODO: proper loop filtering */
2538
                    if(v->pq >= 9 && v->overlap) {
2539
                        if(v->a_avail)
2540
                            vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2541
                        if(v->c_avail)
2542
                            vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2543
                    }
2544
                } else if(is_coded[i]) {
2545
                    status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2546
                    if(!v->ttmbf && ttmb < 8) ttmb = -1;
2547
                    first_block = 0;
2548
                    s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2549
                }
2550
            }
2551
            return status;
2552
        }
2553
        else //Skipped MB
2554
        {
2555
            s->mb_intra = 0;
2556
            for (i=0; i<6; i++) v->mb_type[0][s->block_index[i]] = 0;
2557
            for (i=0; i<4; i++)
2558
            {
2559
                vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
2560
                vc1_mc_4mv_luma(v, i);
2561
            }
2562
            vc1_mc_4mv_chroma(v);
2563
            s->current_picture.qscale_table[mb_pos] = 0;
2564
            return 0;
2565
        }
2566
    }
2567

    
2568
    /* Should never happen */
2569
    return -1;
2570
}
2571

    
2572
/** Decode blocks of I-frame
2573
 */
2574
static void vc1_decode_i_blocks(VC1Context *v)
2575
{
2576
    int k, j;
2577
    MpegEncContext *s = &v->s;
2578
    int cbp, val;
2579
    uint8_t *coded_val;
2580
    int mb_pos;
2581

    
2582
    /* select codingmode used for VLC tables selection */
2583
    switch(v->y_ac_table_index){
2584
    case 0:
2585
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2586
        break;
2587
    case 1:
2588
        v->codingset = CS_HIGH_MOT_INTRA;
2589
        break;
2590
    case 2:
2591
        v->codingset = CS_MID_RATE_INTRA;
2592
        break;
2593
    }
2594

    
2595
    switch(v->c_ac_table_index){
2596
    case 0:
2597
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2598
        break;
2599
    case 1:
2600
        v->codingset2 = CS_HIGH_MOT_INTER;
2601
        break;
2602
    case 2:
2603
        v->codingset2 = CS_MID_RATE_INTER;
2604
        break;
2605
    }
2606

    
2607
    /* Set DC scale - y and c use the same */
2608
    s->y_dc_scale = s->y_dc_scale_table[v->pq];
2609
    s->c_dc_scale = s->c_dc_scale_table[v->pq];
2610

    
2611
    //do frame decode
2612
    s->mb_x = s->mb_y = 0;
2613
    s->mb_intra = 1;
2614
    s->first_slice_line = 1;
2615
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2616
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2617
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2618
            ff_init_block_index(s);
2619
            ff_update_block_index(s);
2620
            s->dsp.clear_blocks(s->block[0]);
2621
            mb_pos = s->mb_x + s->mb_y * s->mb_width;
2622
            s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2623
            s->current_picture.qscale_table[mb_pos] = v->pq;
2624

    
2625
            // do actual MB decoding and displaying
2626
            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2627
            v->s.ac_pred = get_bits(&v->s.gb, 1);
2628

    
2629
            for(k = 0; k < 6; k++) {
2630
                val = ((cbp >> (5 - k)) & 1);
2631

    
2632
                if (k < 4) {
2633
                    int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2634
                    val = val ^ pred;
2635
                    *coded_val = val;
2636
                }
2637
                cbp |= val << (5 - k);
2638

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

    
2641
                vc1_inv_trans(s->block[k], 8, 8);
2642
                if(v->pq >= 9 && v->overlap) {
2643
                    for(j = 0; j < 64; j++) s->block[k][j] += 128;
2644
                }
2645
            }
2646

    
2647
            vc1_put_block(v, s->block);
2648
            if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
2649
                if(!s->first_slice_line) {
2650
                    vc1_v_overlap(s->dest[0], s->linesize);
2651
                    vc1_v_overlap(s->dest[0] + 8, s->linesize);
2652
                    vc1_v_overlap(s->dest[1], s->uvlinesize);
2653
                    vc1_v_overlap(s->dest[2], s->uvlinesize);
2654
                }
2655
                vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2656
                vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2657
                if(s->mb_x) {
2658
                    vc1_h_overlap(s->dest[0], s->linesize);
2659
                    vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2660
                    vc1_h_overlap(s->dest[1], s->uvlinesize);
2661
                    vc1_h_overlap(s->dest[2], s->uvlinesize);
2662
                }
2663
                vc1_h_overlap(s->dest[0] + 8, s->linesize);
2664
                vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2665
            }
2666

    
2667
            if(get_bits_count(&s->gb) > v->bits) {
2668
                av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
2669
                return;
2670
            }
2671
        }
2672
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
2673
        s->first_slice_line = 0;
2674
    }
2675
}
2676

    
2677
static void vc1_decode_p_blocks(VC1Context *v)
2678
{
2679
    MpegEncContext *s = &v->s;
2680

    
2681
    /* select codingmode used for VLC tables selection */
2682
    switch(v->c_ac_table_index){
2683
    case 0:
2684
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2685
        break;
2686
    case 1:
2687
        v->codingset = CS_HIGH_MOT_INTRA;
2688
        break;
2689
    case 2:
2690
        v->codingset = CS_MID_RATE_INTRA;
2691
        break;
2692
    }
2693

    
2694
    switch(v->c_ac_table_index){
2695
    case 0:
2696
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2697
        break;
2698
    case 1:
2699
        v->codingset2 = CS_HIGH_MOT_INTER;
2700
        break;
2701
    case 2:
2702
        v->codingset2 = CS_MID_RATE_INTER;
2703
        break;
2704
    }
2705

    
2706
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2707
    s->first_slice_line = 1;
2708
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2709
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2710
            ff_init_block_index(s);
2711
            ff_update_block_index(s);
2712
            s->dsp.clear_blocks(s->block[0]);
2713

    
2714
            vc1_decode_p_mb(v, s->block);
2715
            if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
2716
                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);
2717
                return;
2718
            }
2719
        }
2720
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
2721
        s->first_slice_line = 0;
2722
    }
2723
}
2724

    
2725
static void vc1_decode_blocks(VC1Context *v)
2726
{
2727

    
2728
    v->s.esc3_level_length = 0;
2729

    
2730
    switch(v->s.pict_type) {
2731
    case I_TYPE:
2732
        vc1_decode_i_blocks(v);
2733
        break;
2734
    case P_TYPE:
2735
        vc1_decode_p_blocks(v);
2736
        break;
2737
    }
2738
}
2739

    
2740

    
2741
/** Initialize a VC1/WMV3 decoder
2742
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2743
 * @todo TODO: Decypher remaining bits in extra_data
2744
 */
2745
static int vc1_decode_init(AVCodecContext *avctx)
2746
{
2747
    VC1Context *v = avctx->priv_data;
2748
    MpegEncContext *s = &v->s;
2749
    GetBitContext gb;
2750

    
2751
    if (!avctx->extradata_size || !avctx->extradata) return -1;
2752
    avctx->pix_fmt = PIX_FMT_YUV420P;
2753
    v->s.avctx = avctx;
2754
    avctx->flags |= CODEC_FLAG_EMU_EDGE;
2755
    v->s.flags |= CODEC_FLAG_EMU_EDGE;
2756

    
2757
    if(ff_h263_decode_init(avctx) < 0)
2758
        return -1;
2759
    if (vc1_init_common(v) < 0) return -1;
2760

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

    
2764
    avctx->coded_width = avctx->width;
2765
    avctx->coded_height = avctx->height;
2766
    if (avctx->codec_id == CODEC_ID_WMV3)
2767
    {
2768
        int count = 0;
2769

    
2770
        // looks like WMV3 has a sequence header stored in the extradata
2771
        // advanced sequence header may be before the first frame
2772
        // the last byte of the extradata is a version number, 1 for the
2773
        // samples we can decode
2774

    
2775
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2776

    
2777
        if (decode_sequence_header(avctx, &gb) < 0)
2778
          return -1;
2779

    
2780
        count = avctx->extradata_size*8 - get_bits_count(&gb);
2781
        if (count>0)
2782
        {
2783
            av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2784
                   count, get_bits(&gb, count));
2785
        }
2786
        else if (count < 0)
2787
        {
2788
            av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2789
        }
2790
    }
2791
    avctx->has_b_frames= !!(avctx->max_b_frames);
2792

    
2793
    s->mb_width = (avctx->coded_width+15)>>4;
2794
    s->mb_height = (avctx->coded_height+15)>>4;
2795

    
2796
    /* Allocate mb bitplanes */
2797
    v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
2798

    
2799
    /* allocate block type info in that way so it could be used with s->block_index[] */
2800
    v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
2801
    v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
2802
    v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
2803
    v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
2804

    
2805
    /* Init coded blocks info */
2806
    if (v->profile == PROFILE_ADVANCED)
2807
    {
2808
//        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2809
//            return -1;
2810
//        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2811
//            return -1;
2812
    }
2813

    
2814
    return 0;
2815
}
2816

    
2817

    
2818
/** Decode a VC1/WMV3 frame
2819
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2820
 * @warning Initial try at using MpegEncContext stuff
2821
 */
2822
static int vc1_decode_frame(AVCodecContext *avctx,
2823
                            void *data, int *data_size,
2824
                            uint8_t *buf, int buf_size)
2825
{
2826
    VC1Context *v = avctx->priv_data;
2827
    MpegEncContext *s = &v->s;
2828
    AVFrame *pict = data;
2829

    
2830
    /* no supplementary picture */
2831
    if (buf_size == 0) {
2832
        /* special case for last picture */
2833
        if (s->low_delay==0 && s->next_picture_ptr) {
2834
            *pict= *(AVFrame*)s->next_picture_ptr;
2835
            s->next_picture_ptr= NULL;
2836

    
2837
            *data_size = sizeof(AVFrame);
2838
        }
2839

    
2840
        return 0;
2841
    }
2842

    
2843
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2844
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2845
        int i= ff_find_unused_picture(s, 0);
2846
        s->current_picture_ptr= &s->picture[i];
2847
    }
2848

    
2849
    avctx->has_b_frames= !s->low_delay;
2850

    
2851
    init_get_bits(&s->gb, buf, buf_size*8);
2852
    // do parse frame header
2853
    if(vc1_parse_frame_header(v, &s->gb) == -1)
2854
        return -1;
2855

    
2856
    if(s->pict_type != I_TYPE && s->pict_type != P_TYPE)return -1;
2857

    
2858
    // for hurry_up==5
2859
    s->current_picture.pict_type= s->pict_type;
2860
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2861

    
2862
    /* skip B-frames if we don't have reference frames */
2863
    if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return -1;//buf_size;
2864
    /* skip b frames if we are in a hurry */
2865
    if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
2866
    if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
2867
       || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
2868
       ||  avctx->skip_frame >= AVDISCARD_ALL)
2869
        return buf_size;
2870
    /* skip everything if we are in a hurry>=5 */
2871
    if(avctx->hurry_up>=5) return -1;//buf_size;
2872

    
2873
    if(s->next_p_frame_damaged){
2874
        if(s->pict_type==B_TYPE)
2875
            return buf_size;
2876
        else
2877
            s->next_p_frame_damaged=0;
2878
    }
2879

    
2880
    if(MPV_frame_start(s, avctx) < 0)
2881
        return -1;
2882

    
2883
    ff_er_frame_start(s);
2884

    
2885
    v->bits = buf_size * 8;
2886
    vc1_decode_blocks(v);
2887
//av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
2888
//  if(get_bits_count(&s->gb) > buf_size * 8)
2889
//      return -1;
2890
    ff_er_frame_end(s);
2891

    
2892
    MPV_frame_end(s);
2893

    
2894
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2895
assert(s->current_picture.pict_type == s->pict_type);
2896
    if (s->pict_type == B_TYPE || s->low_delay) {
2897
        *pict= *(AVFrame*)s->current_picture_ptr;
2898
    } else if (s->last_picture_ptr != NULL) {
2899
        *pict= *(AVFrame*)s->last_picture_ptr;
2900
    }
2901

    
2902
    if(s->last_picture_ptr || s->low_delay){
2903
        *data_size = sizeof(AVFrame);
2904
        ff_print_debug_info(s, pict);
2905
    }
2906

    
2907
    /* Return the Picture timestamp as the frame number */
2908
    /* we substract 1 because it is added on utils.c    */
2909
    avctx->frame_number = s->picture_number - 1;
2910

    
2911
    return buf_size;
2912
}
2913

    
2914

    
2915
/** Close a VC1/WMV3 decoder
2916
 * @warning Initial try at using MpegEncContext stuff
2917
 */
2918
static int vc1_decode_end(AVCodecContext *avctx)
2919
{
2920
    VC1Context *v = avctx->priv_data;
2921

    
2922
    av_freep(&v->hrd_rate);
2923
    av_freep(&v->hrd_buffer);
2924
    MPV_common_end(&v->s);
2925
    av_freep(&v->mv_type_mb_plane);
2926
    av_freep(&v->mb_type_base);
2927
    return 0;
2928
}
2929

    
2930

    
2931
AVCodec vc1_decoder = {
2932
    "vc1",
2933
    CODEC_TYPE_VIDEO,
2934
    CODEC_ID_VC1,
2935
    sizeof(VC1Context),
2936
    vc1_decode_init,
2937
    NULL,
2938
    vc1_decode_end,
2939
    vc1_decode_frame,
2940
    CODEC_CAP_DELAY,
2941
    NULL
2942
};
2943

    
2944
AVCodec wmv3_decoder = {
2945
    "wmv3",
2946
    CODEC_TYPE_VIDEO,
2947
    CODEC_ID_WMV3,
2948
    sizeof(VC1Context),
2949
    vc1_decode_init,
2950
    NULL,
2951
    vc1_decode_end,
2952
    vc1_decode_frame,
2953
    CODEC_CAP_DELAY,
2954
    NULL
2955
};