Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vc1.c @ ad78c0f3

History | View | Annotate | Download (96.8 KB)

1
/*
2
 * VC-1 and WMV3 decoder
3
 * Copyright (c) 2006 Konstantin Shishkov
4
 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 *
20
 */
21

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

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

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

    
47

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
206
/** The VC1 Context
207
 * @fixme Change size wherever another size is more efficient
208
 * Many members are only used for Advanced Profile
209
 */
210
typedef struct VC1Context{
211
    MpegEncContext s;
212

    
213
    int bits;
214

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

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

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

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

    
293

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
471
    return 0;
472
}
473

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

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

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

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

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

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

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

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

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

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

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

    
666
/** @} */ //Bitplane group
667

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

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

    
711

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
838

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
977
/** Do motion compensation for 4-MV macroblock - luminance block
978
 */
979
static void vc1_mc_4mv_luma(VC1Context *v, int n)
980
{
981
    MpegEncContext *s = &v->s;
982
    DSPContext *dsp = &v->s.dsp;
983
    uint8_t *srcY;
984
    int dxy, mx, my, src_x, src_y;
985
    int off;
986

    
987
    if(!v->s.last_picture.data[0])return;
988
    mx = s->mv[0][n][0];
989
    my = s->mv[0][n][1];
990
    srcY = s->last_picture.data[0];
991

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

    
994
    src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
995
    src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
996

    
997
    CLIP_RANGE(src_x, s->mb_x, s->mb_width  * 16, 16);
998
    CLIP_RANGE(src_y, s->mb_y, s->mb_height * 16, 16);
999

    
1000
    srcY += src_y * s->linesize + src_x;
1001

    
1002
    if((unsigned)src_x > s->h_edge_pos - (mx&3) - 16
1003
       || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
1004
        ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
1005
                            src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1006
        srcY = s->edge_emu_buffer;
1007
    }
1008

    
1009
    if(!s->quarter_sample) { // hpel mc
1010
        mx >>= 1;
1011
        my >>= 1;
1012
        dxy = ((my & 1) << 1) | (mx & 1);
1013

    
1014
        dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1015
    } else {
1016
        dxy = ((my & 3) << 2) | (mx & 3);
1017

    
1018
        dsp->put_no_rnd_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
1019
    }
1020
}
1021

    
1022
#define SETMAXMIN(var)     \
1023
    if(var > ma) ma = var; \
1024
    if(var < mi) mi = var;
1025

    
1026
static inline int median4(int a, int b, int c, int d)
1027
{
1028
    int ma, mi;
1029

    
1030
    ma = mi = a;
1031
    SETMAXMIN(b);
1032
    SETMAXMIN(c);
1033
    SETMAXMIN(d);
1034

    
1035
    return (a + b + c + d - ma - mi) >> 1;
1036
}
1037

    
1038

    
1039
/** Do motion compensation for 4-MV macroblock - both chroma blocks
1040
 */
1041
static void vc1_mc_4mv_chroma(VC1Context *v)
1042
{
1043
    MpegEncContext *s = &v->s;
1044
    DSPContext *dsp = &v->s.dsp;
1045
    uint8_t *srcU, *srcV;
1046
    int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1047
    int i, idx, tx = 0, ty = 0;
1048
    int mvx[4], mvy[4], intra[4];
1049
    static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1050

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

    
1053
    for(i = 0; i < 4; i++) {
1054
        mvx[i] = s->mv[0][i][0];
1055
        mvy[i] = s->mv[0][i][1];
1056
        intra[i] = v->mb_type[0][s->block_index[i]];
1057
    }
1058

    
1059
    /* calculate chroma MV vector from four luma MVs */
1060
    idx = (intra[0] << 3) | (intra[1] << 2) | (intra[2] << 1) | intra[3];
1061
    if(!idx) { // all blocks are inter
1062
        tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1063
        ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1064
    } else if(count[idx] == 1) { // 3 inter blocks
1065
        switch(idx) {
1066
        case 0x1:
1067
            tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1068
            tx = mid_pred(mvy[1], mvy[2], mvy[3]);
1069
            break;
1070
        case 0x2:
1071
            tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1072
            tx = mid_pred(mvy[0], mvy[2], mvy[3]);
1073
            break;
1074
        case 0x4:
1075
            tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1076
            tx = mid_pred(mvy[0], mvy[1], mvy[3]);
1077
            break;
1078
        case 0x8:
1079
            tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1080
            tx = mid_pred(mvy[0], mvy[1], mvy[2]);
1081
            break;
1082
        }
1083
    } else if(count[idx] == 2) {
1084
        int t1 = 0, t2 = 0;
1085
        for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1086
        for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1087
        tx = (mvx[t1] + mvx[t2]) >> 1;
1088
        ty = (mvy[t1] + mvy[t2]) >> 1;
1089
    } else
1090
        return; //no need to do MC for inter blocks
1091

    
1092
    uvmx = (tx + ((tx&3) == 3)) >> 1;
1093
    uvmy = (ty + ((ty&3) == 3)) >> 1;
1094

    
1095
    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1096
    uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1097

    
1098
    CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width  *  8,  8);
1099
    CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height *  8,  8);
1100
    srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1101
    srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1102
    if((unsigned)uvsrc_x > (s->h_edge_pos >> 1) - ((uvmx >> 1)&1) - 8
1103
       || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - ((uvmy >> 1)&1) - 8){
1104
        ff_emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize, 8+1, 8+1,
1105
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1106
        ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1107
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1108
        srcU = s->edge_emu_buffer;
1109
        srcV = s->edge_emu_buffer + 16;
1110
    }
1111

    
1112
    if(!s->quarter_sample) // hpel mc
1113
        uvdxy = 0;
1114
    else
1115
        uvdxy = ((uvmy & 1) << 1) | (uvmx & 1);
1116
    dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize, 8);
1117
    dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize, 8);
1118
}
1119

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

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

    
1139
    if (v->profile == PROFILE_ADVANCED)
1140
    {
1141
        v->level = get_bits(gb, 3);
1142
        if(v->level >= 5)
1143
        {
1144
            av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1145
        }
1146
        v->chromaformat = get_bits(gb, 2);
1147
        if (v->chromaformat != 1)
1148
        {
1149
            av_log(avctx, AV_LOG_ERROR,
1150
                   "Only 4:2:0 chroma format supported\n");
1151
            return -1;
1152
        }
1153
    }
1154
    else
1155
    {
1156
        v->res_sm = get_bits(gb, 2); //reserved
1157
        if (v->res_sm)
1158
        {
1159
            av_log(avctx, AV_LOG_ERROR,
1160
                   "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1161
            return -1;
1162
        }
1163
    }
1164

    
1165
    // (fps-2)/4 (->30)
1166
    v->frmrtq_postproc = get_bits(gb, 3); //common
1167
    // (bitrate-32kbps)/64kbps
1168
    v->bitrtq_postproc = get_bits(gb, 5); //common
1169
    v->s.loop_filter = get_bits(gb, 1); //common
1170
    if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1171
    {
1172
        av_log(avctx, AV_LOG_ERROR,
1173
               "LOOPFILTER shell not be enabled in simple profile\n");
1174
    }
1175

    
1176
    if (v->profile < PROFILE_ADVANCED)
1177
    {
1178
        v->res_x8 = get_bits(gb, 1); //reserved
1179
        if (v->res_x8)
1180
        {
1181
            av_log(avctx, AV_LOG_ERROR,
1182
                   "1 for reserved RES_X8 is forbidden\n");
1183
            //return -1;
1184
        }
1185
        v->multires = get_bits(gb, 1);
1186
        v->res_fasttx = get_bits(gb, 1);
1187
        if (!v->res_fasttx)
1188
        {
1189
            av_log(avctx, AV_LOG_ERROR,
1190
                   "0 for reserved RES_FASTTX is forbidden\n");
1191
            //return -1;
1192
        }
1193
    }
1194

    
1195
    v->fastuvmc =  get_bits(gb, 1); //common
1196
    if (!v->profile && !v->fastuvmc)
1197
    {
1198
        av_log(avctx, AV_LOG_ERROR,
1199
               "FASTUVMC unavailable in Simple Profile\n");
1200
        return -1;
1201
    }
1202
    v->extended_mv =  get_bits(gb, 1); //common
1203
    if (!v->profile && v->extended_mv)
1204
    {
1205
        av_log(avctx, AV_LOG_ERROR,
1206
               "Extended MVs unavailable in Simple Profile\n");
1207
        return -1;
1208
    }
1209
    v->dquant =  get_bits(gb, 2); //common
1210
    v->vstransform =  get_bits(gb, 1); //common
1211

    
1212
    if (v->profile < PROFILE_ADVANCED)
1213
    {
1214
        v->res_transtab = get_bits(gb, 1);
1215
        if (v->res_transtab)
1216
        {
1217
            av_log(avctx, AV_LOG_ERROR,
1218
                   "1 for reserved RES_TRANSTAB is forbidden\n");
1219
            return -1;
1220
        }
1221
    }
1222

    
1223
    v->overlap = get_bits(gb, 1); //common
1224

    
1225
    if (v->profile < PROFILE_ADVANCED)
1226
    {
1227
        v->s.resync_marker = get_bits(gb, 1);
1228
        v->rangered = get_bits(gb, 1);
1229
        if (v->rangered && v->profile == PROFILE_SIMPLE)
1230
        {
1231
            av_log(avctx, AV_LOG_INFO,
1232
                   "RANGERED should be set to 0 in simple profile\n");
1233
        }
1234
    }
1235

    
1236
    v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1237
    v->quantizer_mode = get_bits(gb, 2); //common
1238

    
1239
    if (v->profile < PROFILE_ADVANCED)
1240
    {
1241
        v->finterpflag = get_bits(gb, 1); //common
1242
        v->res_rtm_flag = get_bits(gb, 1); //reserved
1243
        if (!v->res_rtm_flag)
1244
        {
1245
            av_log(avctx, AV_LOG_ERROR,
1246
                   "0 for reserved RES_RTM_FLAG is forbidden\n");
1247
            //return -1;
1248
        }
1249
        av_log(avctx, AV_LOG_DEBUG,
1250
               "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1251
               "LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"
1252
               "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1253
               "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1254
               v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1255
               v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1256
               v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1257
               v->dquant, v->quantizer_mode, avctx->max_b_frames
1258
               );
1259
        return 0;
1260
    }
1261
    return -1;
1262
}
1263

    
1264

    
1265
static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1266
{
1267
    int pqindex, lowquant, status;
1268

    
1269
    if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1270
    skip_bits(gb, 2); //framecnt unused
1271
    v->rangeredfrm = 0;
1272
    if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1273
    v->s.pict_type = get_bits(gb, 1);
1274
    if (v->s.avctx->max_b_frames) {
1275
        if (!v->s.pict_type) {
1276
            if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1277
            else v->s.pict_type = B_TYPE;
1278
        } else v->s.pict_type = P_TYPE;
1279
    } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1280

    
1281
    if(v->s.pict_type == I_TYPE)
1282
        get_bits(gb, 7); // skip buffer fullness
1283

    
1284
    /* Quantizer stuff */
1285
    pqindex = get_bits(gb, 5);
1286
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1287
        v->pq = pquant_table[0][pqindex];
1288
    else
1289
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1290

    
1291
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1292
        v->pquantizer = pqindex < 9;
1293
    if (v->quantizer_mode == QUANT_UNIFORM || v->quantizer_mode == QUANT_NON_UNIFORM)
1294
        v->pquantizer = v->quantizer_mode == QUANT_UNIFORM;
1295
    v->pqindex = pqindex;
1296
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1297
    else v->halfpq = 0;
1298
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1299
        v->pquantizer = get_bits(gb, 1);
1300
    v->dquantfrm = 0;
1301

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

    
1305
    //TODO: complete parsing for P/B/BI frames
1306
    switch(v->s.pict_type) {
1307
    case P_TYPE:
1308
        if (v->pq < 5) v->tt_index = 0;
1309
        else if(v->pq < 13) v->tt_index = 1;
1310
        else v->tt_index = 2;
1311

    
1312
        if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1313
        v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1314
        v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1315
        v->range_x = 1 << (v->k_x - 1);
1316
        v->range_y = 1 << (v->k_y - 1);
1317
        if (v->profile == PROFILE_ADVANCED)
1318
        {
1319
            if (v->postprocflag) v->postproc = get_bits(gb, 1);
1320
        }
1321
        else
1322
            if (v->multires) v->respic = get_bits(gb, 2);
1323
        lowquant = (v->pq > 12) ? 0 : 1;
1324
        v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1325
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1326
        {
1327
            v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];
1328
            v->lumscale = get_bits(gb, 6);
1329
            v->lumshift = get_bits(gb, 6);
1330
        }
1331
        if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1332
            v->s.quarter_sample = 0;
1333
        else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1334
            if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1335
                v->s.quarter_sample = 0;
1336
            else
1337
                v->s.quarter_sample = 1;
1338
        } else
1339
            v->s.quarter_sample = 1;
1340

    
1341
        if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1342
                 v->mv_mode2 == MV_PMODE_MIXED_MV)
1343
                || v->mv_mode == MV_PMODE_MIXED_MV)
1344
        {
1345
            status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1346
            if (status < 0) return -1;
1347
            av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1348
                   "Imode: %i, Invert: %i\n", status>>1, status&1);
1349
        } else {
1350
            v->mv_type_is_raw = 0;
1351
            memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1352
        }
1353
        status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1354
        if (status < 0) return -1;
1355
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1356
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1357

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

    
1362
        if (v->dquant)
1363
        {
1364
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1365
            vop_dquant_decoding(v);
1366
        }
1367

    
1368
        v->ttfrm = 0; //FIXME Is that so ?
1369
        if (v->vstransform)
1370
        {
1371
            v->ttmbf = get_bits(gb, 1);
1372
            if (v->ttmbf)
1373
            {
1374
                v->ttfrm = get_bits(gb, 2);
1375
            }
1376
        }
1377
        break;
1378
    case B_TYPE:
1379
        break;
1380
    }
1381

    
1382
    /* AC Syntax */
1383
    v->c_ac_table_index = decode012(gb);
1384
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1385
    {
1386
        v->y_ac_table_index = decode012(gb);
1387
    }
1388
    /* DC Syntax */
1389
    v->s.dc_table_index = get_bits(gb, 1);
1390

    
1391
    return 0;
1392
}
1393

    
1394
/***********************************************************************/
1395
/**
1396
 * @defgroup block VC-1 Block-level functions
1397
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1398
 * @todo TODO: Integrate to MpegEncContext facilities
1399
 * @{
1400
 */
1401

    
1402
/**
1403
 * @def GET_MQUANT
1404
 * @brief Get macroblock-level quantizer scale
1405
 * @warning XXX: qdiff to the frame quant, not previous quant ?
1406
 * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1407
 */
1408
#define GET_MQUANT()                                           \
1409
  if (v->dquantfrm)                                            \
1410
  {                                                            \
1411
    if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1412
    {                                                          \
1413
      if (v->dqbilevel)                                        \
1414
      {                                                        \
1415
        mquant = (get_bits(gb, 1)) ? v->pq : v->altpq;         \
1416
      }                                                        \
1417
      else                                                     \
1418
      {                                                        \
1419
        mqdiff = get_bits(gb, 3);                              \
1420
        if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1421
        else mquant = get_bits(gb, 5);                         \
1422
      }                                                        \
1423
    }                                                          \
1424
    else if(v->dqprofile == DQPROFILE_SINGLE_EDGE)             \
1425
    {                                                          \
1426
        switch(v->dqsbedge){                                   \
1427
        case 0: /* left */                                     \
1428
            mquant = (s->mb_x) ? v->pq : v->altpq;             \
1429
            break;                                             \
1430
        case 1: /* top */                                      \
1431
            mquant = (s->mb_y) ? v->pq : v->altpq;             \
1432
            break;                                             \
1433
        case 2: /* right */                                    \
1434
            mquant = (s->mb_x != (s->mb_width - 1)) ? v->pq : v->altpq; \
1435
            break;                                             \
1436
        case 3: /* bottom */                                   \
1437
            mquant = (s->mb_y != (s->mb_height-1)) ? v->pq : v->altpq; \
1438
            break;                                             \
1439
        default:                                               \
1440
            mquant = v->pq;                                    \
1441
        }                                                      \
1442
    }                                                          \
1443
    else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1444
    {                                                          \
1445
        switch(v->dqsbedge){                                   \
1446
        case 0: /* left and top */                             \
1447
            mquant = (s->mb_x && s->mb_y) ? v->pq : v->altpq;  \
1448
            break;                                             \
1449
        case 1: /* top and right */                            \
1450
            mquant = (s->mb_y && s->mb_x != (s->mb_width - 1)) ? v->pq : v->altpq; \
1451
            break;                                             \
1452
        case 2: /* right and bottom */                         \
1453
            mquant = (s->mb_x != (s->mb_width - 1) && s->mb_y != (s->mb_height-1)) ? v->pq : v->altpq; \
1454
            break;                                             \
1455
        case 3: /* bottom and left */                          \
1456
            mquant = (s->mb_x && s->mb_y != (s->mb_height-1)) ? v->pq : v->altpq; \
1457
            break;                                             \
1458
        default:                                               \
1459
            mquant = v->pq;                                    \
1460
        }                                                      \
1461
    }                                                          \
1462
    else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1463
    {                                                          \
1464
        mquant = (s->mb_x && s->mb_y && s->mb_x != (s->mb_width - 1) && s->mb_y != (s->mb_height-1)) ? v->pq : v->altpq; \
1465
    }                                                          \
1466
    else mquant = v->pq;                                       \
1467
  }
1468

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

    
1520
/** Predict and set motion vector
1521
 */
1522
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)
1523
{
1524
    int xy, wrap, off = 0;
1525
    int16_t *A, *B, *C;
1526
    int px, py;
1527
    int sum;
1528

    
1529
    /* scale MV difference to be quad-pel */
1530
    dmv_x <<= 1 - s->quarter_sample;
1531
    dmv_y <<= 1 - s->quarter_sample;
1532

    
1533
    wrap = s->b8_stride;
1534
    xy = s->block_index[n];
1535

    
1536
    if(s->mb_intra){
1537
        s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1538
        s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1539
        if(mv1) { /* duplicate motion data for 1-MV block */
1540
            s->current_picture.motion_val[0][xy + 1][0] = 0;
1541
            s->current_picture.motion_val[0][xy + 1][1] = 0;
1542
            s->current_picture.motion_val[0][xy + wrap][0] = 0;
1543
            s->current_picture.motion_val[0][xy + wrap][1] = 0;
1544
            s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1545
            s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1546
        }
1547
        return;
1548
    }
1549

    
1550
    C = s->current_picture.motion_val[0][xy - 1];
1551
    A = s->current_picture.motion_val[0][xy - wrap];
1552
    if(mv1)
1553
        off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1554
    else {
1555
        //in 4-MV mode different blocks have different B predictor position
1556
        switch(n){
1557
        case 0:
1558
            off = (s->mb_x > 0) ? -1 : 1;
1559
            break;
1560
        case 1:
1561
            off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1562
            break;
1563
        case 2:
1564
            off = 1;
1565
            break;
1566
        case 3:
1567
            off = -1;
1568
        }
1569
    }
1570
    B = s->current_picture.motion_val[0][xy - wrap + off];
1571

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

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

    
1665
    /* find prediction - wmv3_dc_scale always used here in fact */
1666
    if (n < 4)     scale = s->y_dc_scale;
1667
    else           scale = s->c_dc_scale;
1668

    
1669
    wrap = s->block_wrap[n];
1670
    dc_val= s->dc_val[0] + s->block_index[n];
1671

    
1672
    /* B A
1673
     * C X
1674
     */
1675
    c = dc_val[ - 1];
1676
    b = dc_val[ - 1 - wrap];
1677
    a = dc_val[ - wrap];
1678

    
1679
    if (pq < 9 || !overlap)
1680
    {
1681
        /* Set outer values */
1682
        if (!s->mb_y && (n!=2 && n!=3)) b=a=dcpred[scale];
1683
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1684
    }
1685
    else
1686
    {
1687
        /* Set outer values */
1688
        if (!s->mb_y && (n!=2 && n!=3)) b=a=0;
1689
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1690
    }
1691

    
1692
    if (abs(a - b) <= abs(b - c)) {
1693
        pred = c;
1694
        *dir_ptr = 1;//left
1695
    } else {
1696
        pred = a;
1697
        *dir_ptr = 0;//top
1698
    }
1699

    
1700
    /* update predictor */
1701
    *dc_val_ptr = &dc_val[0];
1702
    return pred;
1703
}
1704

    
1705

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

    
1722
    /* find prediction - wmv3_dc_scale always used here in fact */
1723
    if (n < 4)     scale = s->y_dc_scale;
1724
    else           scale = s->c_dc_scale;
1725

    
1726
    wrap = s->block_wrap[n];
1727
    dc_val= s->dc_val[0] + s->block_index[n];
1728

    
1729
    /* B A
1730
     * C X
1731
     */
1732
    c = dc_val[ - 1];
1733
    b = dc_val[ - 1 - wrap];
1734
    a = dc_val[ - wrap];
1735

    
1736
    if(a_avail && c_avail) {
1737
        if(abs(a - b) <= abs(b - c)) {
1738
            pred = c;
1739
            *dir_ptr = 1;//left
1740
        } else {
1741
            pred = a;
1742
            *dir_ptr = 0;//top
1743
        }
1744
    } else if(a_avail) {
1745
        pred = a;
1746
        *dir_ptr = 0;//top
1747
    } else if(c_avail) {
1748
        pred = c;
1749
        *dir_ptr = 1;//left
1750
    } else {
1751
        pred = 0;
1752
        *dir_ptr = 1;//left
1753
    }
1754

    
1755
    /* scale coeffs if needed
1756
    mb_pos2 = mb_pos - *dir_ptr - (1 - *dir_ptr) * s->mb_stride;
1757
    q1 = s->y_dc_scale_table[s->current_picture.qscale_table[mb_pos]];
1758
    q2 = s->y_dc_scale_table[s->current_picture.qscale_table[mb_pos2]];
1759
    if(q2 && q1!=q2 && ((*dir_ptr && c_avail) || (!*dir_ptr && a_avail))) {
1760
        pred = (pred * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1761
    } */
1762

    
1763
    /* update predictor */
1764
    *dc_val_ptr = &dc_val[0];
1765
    return pred;
1766
}
1767

    
1768

    
1769
/**
1770
 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
1771
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1772
 * @todo TODO: Integrate to MpegEncContext facilities
1773
 * @{
1774
 */
1775

    
1776
static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1777
{
1778
    int xy, wrap, pred, a, b, c;
1779

    
1780
    xy = s->block_index[n];
1781
    wrap = s->b8_stride;
1782

    
1783
    /* B C
1784
     * A X
1785
     */
1786
    a = s->coded_block[xy - 1       ];
1787
    b = s->coded_block[xy - 1 - wrap];
1788
    c = s->coded_block[xy     - wrap];
1789

    
1790
    if (b == c) {
1791
        pred = a;
1792
    } else {
1793
        pred = c;
1794
    }
1795

    
1796
    /* store value */
1797
    *coded_block_ptr = &s->coded_block[xy];
1798

    
1799
    return pred;
1800
}
1801

    
1802
/**
1803
 * Decode one AC coefficient
1804
 * @param v The VC1 context
1805
 * @param last Last coefficient
1806
 * @param skip How much zero coefficients to skip
1807
 * @param value Decoded AC coefficient value
1808
 * @see 8.1.3.4
1809
 */
1810
static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
1811
{
1812
    GetBitContext *gb = &v->s.gb;
1813
    int index, escape, run = 0, level = 0, lst = 0;
1814

    
1815
    index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1816
    if (index != vc1_ac_sizes[codingset] - 1) {
1817
        run = vc1_index_decode_table[codingset][index][0];
1818
        level = vc1_index_decode_table[codingset][index][1];
1819
        lst = index >= vc1_last_decode_table[codingset];
1820
        if(get_bits(gb, 1))
1821
            level = -level;
1822
    } else {
1823
        escape = decode210(gb);
1824
        if (escape != 2) {
1825
            index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1826
            run = vc1_index_decode_table[codingset][index][0];
1827
            level = vc1_index_decode_table[codingset][index][1];
1828
            lst = index >= vc1_last_decode_table[codingset];
1829
            if(escape == 0) {
1830
                if(lst)
1831
                    level += vc1_last_delta_level_table[codingset][run];
1832
                else
1833
                    level += vc1_delta_level_table[codingset][run];
1834
            } else {
1835
                if(lst)
1836
                    run += vc1_last_delta_run_table[codingset][level] + 1;
1837
                else
1838
                    run += vc1_delta_run_table[codingset][level] + 1;
1839
            }
1840
            if(get_bits(gb, 1))
1841
                level = -level;
1842
        } else {
1843
            int sign;
1844
            lst = get_bits(gb, 1);
1845
            if(v->s.esc3_level_length == 0) {
1846
                if(v->pq < 8 || v->dquantfrm) { // table 59
1847
                    v->s.esc3_level_length = get_bits(gb, 3);
1848
                    if(!v->s.esc3_level_length)
1849
                        v->s.esc3_level_length = get_bits(gb, 2) + 8;
1850
                } else { //table 60
1851
                    v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
1852
                }
1853
                v->s.esc3_run_length = 3 + get_bits(gb, 2);
1854
            }
1855
            run = get_bits(gb, v->s.esc3_run_length);
1856
            sign = get_bits(gb, 1);
1857
            level = get_bits(gb, v->s.esc3_level_length);
1858
            if(sign)
1859
                level = -level;
1860
        }
1861
    }
1862

    
1863
    *last = lst;
1864
    *skip = run;
1865
    *value = level;
1866
}
1867

    
1868
/** Decode intra block in intra frames - should be faster than decode_intra_block
1869
 * @param v VC1Context
1870
 * @param block block to decode
1871
 * @param coded are AC coeffs present or not
1872
 * @param codingset set of VLC to decode data
1873
 */
1874
static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
1875
{
1876
    GetBitContext *gb = &v->s.gb;
1877
    MpegEncContext *s = &v->s;
1878
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
1879
    int run_diff, i;
1880
    int16_t *dc_val;
1881
    int16_t *ac_val, *ac_val2;
1882
    int dcdiff;
1883

    
1884
    /* Get DC differential */
1885
    if (n < 4) {
1886
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1887
    } else {
1888
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1889
    }
1890
    if (dcdiff < 0){
1891
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1892
        return -1;
1893
    }
1894
    if (dcdiff)
1895
    {
1896
        if (dcdiff == 119 /* ESC index value */)
1897
        {
1898
            /* TODO: Optimize */
1899
            if (v->pq == 1) dcdiff = get_bits(gb, 10);
1900
            else if (v->pq == 2) dcdiff = get_bits(gb, 9);
1901
            else dcdiff = get_bits(gb, 8);
1902
        }
1903
        else
1904
        {
1905
            if (v->pq == 1)
1906
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1907
            else if (v->pq == 2)
1908
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1909
        }
1910
        if (get_bits(gb, 1))
1911
            dcdiff = -dcdiff;
1912
    }
1913

    
1914
    /* Prediction */
1915
    dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
1916
    *dc_val = dcdiff;
1917

    
1918
    /* Store the quantized DC coeff, used for prediction */
1919
    if (n < 4) {
1920
        block[0] = dcdiff * s->y_dc_scale;
1921
    } else {
1922
        block[0] = dcdiff * s->c_dc_scale;
1923
    }
1924
    /* Skip ? */
1925
    run_diff = 0;
1926
    i = 0;
1927
    if (!coded) {
1928
        goto not_coded;
1929
    }
1930

    
1931
    //AC Decoding
1932
    i = 1;
1933

    
1934
    {
1935
        int last = 0, skip, value;
1936
        const int8_t *zz_table;
1937
        int scale;
1938
        int k;
1939

    
1940
        scale = v->pq * 2 + v->halfpq;
1941

    
1942
        if(v->s.ac_pred) {
1943
            if(!dc_pred_dir)
1944
                zz_table = vc1_horizontal_zz;
1945
            else
1946
                zz_table = vc1_vertical_zz;
1947
        } else
1948
            zz_table = vc1_normal_zz;
1949

    
1950
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1951
        ac_val2 = ac_val;
1952
        if(dc_pred_dir) //left
1953
            ac_val -= 16;
1954
        else //top
1955
            ac_val -= 16 * s->block_wrap[n];
1956

    
1957
        while (!last) {
1958
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
1959
            i += skip;
1960
            if(i > 63)
1961
                break;
1962
            block[zz_table[i++]] = value;
1963
        }
1964

    
1965
        /* apply AC prediction if needed */
1966
        if(s->ac_pred) {
1967
            if(dc_pred_dir) { //left
1968
                for(k = 1; k < 8; k++)
1969
                    block[k << 3] += ac_val[k];
1970
            } else { //top
1971
                for(k = 1; k < 8; k++)
1972
                    block[k] += ac_val[k + 8];
1973
            }
1974
        }
1975
        /* save AC coeffs for further prediction */
1976
        for(k = 1; k < 8; k++) {
1977
            ac_val2[k] = block[k << 3];
1978
            ac_val2[k + 8] = block[k];
1979
        }
1980

    
1981
        /* scale AC coeffs */
1982
        for(k = 1; k < 64; k++)
1983
            if(block[k]) {
1984
                block[k] *= scale;
1985
                if(!v->pquantizer)
1986
                    block[k] += (block[k] < 0) ? -v->pq : v->pq;
1987
            }
1988

    
1989
        if(s->ac_pred) i = 63;
1990
    }
1991

    
1992
not_coded:
1993
    if(!coded) {
1994
        int k, scale;
1995
        ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1996
        ac_val2 = ac_val;
1997

    
1998
        scale = v->pq * 2 + v->halfpq;
1999
        memset(ac_val2, 0, 16 * 2);
2000
        if(dc_pred_dir) {//left
2001
            ac_val -= 16;
2002
            if(s->ac_pred)
2003
                memcpy(ac_val2, ac_val, 8 * 2);
2004
        } else {//top
2005
            ac_val -= 16 * s->block_wrap[n];
2006
            if(s->ac_pred)
2007
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2008
        }
2009

    
2010
        /* apply AC prediction if needed */
2011
        if(s->ac_pred) {
2012
            if(dc_pred_dir) { //left
2013
                for(k = 1; k < 8; k++) {
2014
                    block[k << 3] = ac_val[k] * scale;
2015
                    if(!v->pquantizer)
2016
                        block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2017
                }
2018
            } else { //top
2019
                for(k = 1; k < 8; k++) {
2020
                    block[k] = ac_val[k + 8] * scale;
2021
                    if(!v->pquantizer)
2022
                        block[k] += (block[k] < 0) ? -v->pq : v->pq;
2023
                }
2024
            }
2025
            i = 63;
2026
        }
2027
    }
2028
    s->block_last_index[n] = i;
2029

    
2030
    return 0;
2031
}
2032

    
2033
/** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2034
 * @param v VC1Context
2035
 * @param block block to decode
2036
 * @param coded are AC coeffs present or not
2037
 * @param mquant block quantizer
2038
 * @param codingset set of VLC to decode data
2039
 */
2040
static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
2041
{
2042
    GetBitContext *gb = &v->s.gb;
2043
    MpegEncContext *s = &v->s;
2044
    int dc_pred_dir = 0; /* Direction of the DC prediction used */
2045
    int run_diff, i;
2046
    int16_t *dc_val;
2047
    int16_t *ac_val, *ac_val2;
2048
    int dcdiff;
2049
    int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2050
    int a_avail = v->a_avail, c_avail = v->c_avail;
2051
    int use_pred = s->ac_pred;
2052
    int scale;
2053

    
2054
    /* XXX: Guard against dumb values of mquant */
2055
    mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
2056

    
2057
    /* Set DC scale - y and c use the same */
2058
    s->y_dc_scale = s->y_dc_scale_table[mquant];
2059
    s->c_dc_scale = s->c_dc_scale_table[mquant];
2060

    
2061
    /* Get DC differential */
2062
    if (n < 4) {
2063
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2064
    } else {
2065
        dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2066
    }
2067
    if (dcdiff < 0){
2068
        av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2069
        return -1;
2070
    }
2071
    if (dcdiff)
2072
    {
2073
        if (dcdiff == 119 /* ESC index value */)
2074
        {
2075
            /* TODO: Optimize */
2076
            if (mquant == 1) dcdiff = get_bits(gb, 10);
2077
            else if (mquant == 2) dcdiff = get_bits(gb, 9);
2078
            else dcdiff = get_bits(gb, 8);
2079
        }
2080
        else
2081
        {
2082
            if (mquant == 1)
2083
                dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2084
            else if (mquant == 2)
2085
                dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2086
        }
2087
        if (get_bits(gb, 1))
2088
            dcdiff = -dcdiff;
2089
    }
2090

    
2091
    /* Prediction */
2092
    dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2093
    *dc_val = dcdiff;
2094

    
2095
    /* Store the quantized DC coeff, used for prediction */
2096

    
2097
    if (n < 4) {
2098
        block[0] = dcdiff * s->y_dc_scale;
2099
    } else {
2100
        block[0] = dcdiff * s->c_dc_scale;
2101
    }
2102
    /* Skip ? */
2103
    run_diff = 0;
2104
    i = 0;
2105

    
2106
    //AC Decoding
2107
    i = 1;
2108

    
2109
    /* check if AC is needed at all and adjust direction if needed */
2110
    if(!a_avail) dc_pred_dir = 1;
2111
    if(!c_avail) dc_pred_dir = 0;
2112
    if(!a_avail && !c_avail) use_pred = 0;
2113
    ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2114
    ac_val2 = ac_val;
2115

    
2116
    scale = mquant * 2;
2117

    
2118
    if(dc_pred_dir) //left
2119
        ac_val -= 16;
2120
    else //top
2121
        ac_val -= 16 * s->block_wrap[n];
2122

    
2123
    if(coded) {
2124
        int last = 0, skip, value;
2125
        const int8_t *zz_table;
2126
        int k;
2127

    
2128
        zz_table = vc1_simple_progressive_8x8_zz;
2129

    
2130
        while (!last) {
2131
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2132
            i += skip;
2133
            if(i > 63)
2134
                break;
2135
            block[zz_table[i++]] = value;
2136
        }
2137

    
2138
        /* apply AC prediction if needed */
2139
        if(use_pred) {
2140
            /* scale predictors if needed*/
2141
            int mb_pos2, q1, q2;
2142

    
2143
            mb_pos2 = mb_pos - dc_pred_dir - (1 - dc_pred_dir) * s->mb_stride;
2144
            q1 = s->current_picture.qscale_table[mb_pos];
2145
            q2 = s->current_picture.qscale_table[mb_pos2];
2146

    
2147
            if(0 && q2 && q1!=q2 && ((dc_pred_dir && c_avail) || (!dc_pred_dir && a_avail))) {
2148
                q1 = q1 * 2 - 1;
2149
                q2 = q2 * 2 - 1;
2150

    
2151
                if(dc_pred_dir) { //left
2152
                    for(k = 1; k < 8; k++)
2153
                        block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2154
                } else { //top
2155
                    for(k = 1; k < 8; k++)
2156
                        block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2157
                }
2158
            } else {
2159
                if(dc_pred_dir) { //left
2160
                    for(k = 1; k < 8; k++)
2161
                        block[k << 3] += ac_val[k];
2162
                } else { //top
2163
                    for(k = 1; k < 8; k++)
2164
                        block[k] += ac_val[k + 8];
2165
                }
2166
            }
2167
        }
2168
        /* save AC coeffs for further prediction */
2169
        for(k = 1; k < 8; k++) {
2170
            ac_val2[k] = block[k << 3];
2171
            ac_val2[k + 8] = block[k];
2172
        }
2173

    
2174
        /* scale AC coeffs */
2175
        for(k = 1; k < 64; k++)
2176
            if(block[k]) {
2177
                block[k] *= scale;
2178
                if(!v->pquantizer)
2179
                    block[k] += (block[k] < 0) ? -mquant : mquant;
2180
            }
2181

    
2182
        if(use_pred) i = 63;
2183
    } else { // no AC coeffs
2184
        int k;
2185
        int mb_pos2, q1, q2;
2186

    
2187
        mb_pos2 = mb_pos - dc_pred_dir - (1 - dc_pred_dir) * s->mb_stride;
2188
        q1 = s->current_picture.qscale_table[mb_pos];
2189
        q2 = s->current_picture.qscale_table[mb_pos2];
2190

    
2191
        memset(ac_val2, 0, 16 * 2);
2192
        if(dc_pred_dir) {//left
2193
            if(use_pred) {
2194
                memcpy(ac_val2, ac_val, 8 * 2);
2195
                if(0 && q2 && q1!=q2 && c_avail) {
2196
                    q1 = q1 * 2 - 1;
2197
                    q2 = q2 * 2 - 1;
2198
                    for(k = 1; k < 8; k++)
2199
                        ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2200
                }
2201
            }
2202
        } else {//top
2203
            if(use_pred) {
2204
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2205
                if(0 && q2 && q1!=q2 && a_avail) {
2206
                    q1 = q1 * 2 - 1;
2207
                    q2 = q2 * 2 - 1;
2208
                    for(k = 1; k < 8; k++)
2209
                        ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2210
                }
2211
            }
2212
        }
2213

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

    
2234
    return 0;
2235
}
2236

    
2237
/** Decode P block
2238
 */
2239
static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
2240
{
2241
    MpegEncContext *s = &v->s;
2242
    GetBitContext *gb = &s->gb;
2243
    int i, j;
2244
    int subblkpat = 0;
2245
    int scale, off, idx, last, skip, value;
2246
    int ttblk = ttmb & 7;
2247

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

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

    
2340

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

    
2356
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2357
      offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2358
    int mb_has_coeffs = 1; /* last_flag */
2359
    int dmv_x, dmv_y; /* Differential MV components */
2360
    int index, index1; /* LUT indices */
2361
    int val, sign; /* temp values */
2362
    int first_block = 1;
2363
    int dst_idx, off;
2364
    int skipped, fourmv;
2365

    
2366
    mquant = v->pq; /* Loosy initialization */
2367

    
2368
    if (v->mv_type_is_raw)
2369
        fourmv = get_bits1(gb);
2370
    else
2371
        fourmv = v->mv_type_mb_plane[mb_pos];
2372
    if (v->skip_is_raw)
2373
        skipped = get_bits1(gb);
2374
    else
2375
        skipped = v->s.mbskip_table[mb_pos];
2376

    
2377
    s->dsp.clear_blocks(s->block[0]);
2378

    
2379
    if (!fourmv) /* 1MV mode */
2380
    {
2381
        if (!skipped)
2382
        {
2383
            GET_MVDATA(dmv_x, dmv_y);
2384

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

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

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

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

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

    
2558
    /* Should never happen */
2559
    return -1;
2560
}
2561

    
2562
/** Decode blocks of I-frame
2563
 */
2564
static void vc1_decode_i_blocks(VC1Context *v)
2565
{
2566
    int k;
2567
    MpegEncContext *s = &v->s;
2568
    int cbp, val;
2569
    uint8_t *coded_val;
2570
    int mb_pos;
2571

    
2572
    /* select codingmode used for VLC tables selection */
2573
    switch(v->y_ac_table_index){
2574
    case 0:
2575
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2576
        break;
2577
    case 1:
2578
        v->codingset = CS_HIGH_MOT_INTRA;
2579
        break;
2580
    case 2:
2581
        v->codingset = CS_MID_RATE_INTRA;
2582
        break;
2583
    }
2584

    
2585
    switch(v->c_ac_table_index){
2586
    case 0:
2587
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2588
        break;
2589
    case 1:
2590
        v->codingset2 = CS_HIGH_MOT_INTER;
2591
        break;
2592
    case 2:
2593
        v->codingset2 = CS_MID_RATE_INTER;
2594
        break;
2595
    }
2596

    
2597
    /* Set DC scale - y and c use the same */
2598
    s->y_dc_scale = s->y_dc_scale_table[v->pq];
2599
    s->c_dc_scale = s->c_dc_scale_table[v->pq];
2600

    
2601
    //do frame decode
2602
    s->mb_x = s->mb_y = 0;
2603
    s->mb_intra = 1;
2604
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2605
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2606
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2607
            ff_init_block_index(s);
2608
            ff_update_block_index(s);
2609
            s->dsp.clear_blocks(s->block[0]);
2610
            mb_pos = s->mb_x + s->mb_y * s->mb_width;
2611
            s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2612
            s->current_picture.qscale_table[mb_pos] = v->pq;
2613

    
2614
            // do actual MB decoding and displaying
2615
            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2616
            v->s.ac_pred = get_bits(&v->s.gb, 1);
2617

    
2618
            for(k = 0; k < 6; k++) {
2619
                val = ((cbp >> (5 - k)) & 1);
2620

    
2621
                if (k < 4) {
2622
                    int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2623
                    val = val ^ pred;
2624
                    *coded_val = val;
2625
                }
2626
                cbp |= val << (5 - k);
2627

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

    
2630
                vc1_inv_trans(s->block[k], 8, 8);
2631
                if(v->pq >= 9 && v->overlap) {
2632
                    vc1_overlap_block(s, s->block[k], k, (s->mb_y || k>1), (s->mb_x || (k != 0 && k != 2)));
2633
                }
2634
            }
2635

    
2636
            vc1_put_block(v, s->block);
2637
            if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
2638
                if(s->mb_y) {
2639
                    s->dsp.h263_v_loop_filter(s->dest[0], s->linesize, s->y_dc_scale);
2640
                    s->dsp.h263_v_loop_filter(s->dest[0] + 8, s->linesize, s->y_dc_scale);
2641
                    s->dsp.h263_v_loop_filter(s->dest[1], s->uvlinesize, s->y_dc_scale);
2642
                    s->dsp.h263_v_loop_filter(s->dest[2], s->uvlinesize, s->y_dc_scale);
2643
                }
2644
                s->dsp.h263_v_loop_filter(s->dest[0] + 8 * s->linesize, s->linesize, s->y_dc_scale);
2645
                s->dsp.h263_v_loop_filter(s->dest[0] + 8 * s->linesize + 8, s->linesize, s->y_dc_scale);
2646
                if(s->mb_x) {
2647
                    s->dsp.h263_h_loop_filter(s->dest[0], s->linesize, s->y_dc_scale);
2648
                    s->dsp.h263_h_loop_filter(s->dest[0] + 8 * s->linesize, s->linesize, s->y_dc_scale);
2649
                    s->dsp.h263_h_loop_filter(s->dest[1], s->uvlinesize, s->y_dc_scale);
2650
                    s->dsp.h263_h_loop_filter(s->dest[2], s->uvlinesize, s->y_dc_scale);
2651
                }
2652
                s->dsp.h263_h_loop_filter(s->dest[0] + 8, s->linesize, s->y_dc_scale);
2653
                s->dsp.h263_h_loop_filter(s->dest[0] + 8 * s->linesize + 8, s->linesize, s->y_dc_scale);
2654
            }
2655

    
2656
            if(get_bits_count(&s->gb) > v->bits) {
2657
                av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
2658
                return;
2659
            }
2660
        }
2661
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
2662
    }
2663
}
2664

    
2665
static void vc1_decode_p_blocks(VC1Context *v)
2666
{
2667
    MpegEncContext *s = &v->s;
2668

    
2669
    /* select codingmode used for VLC tables selection */
2670
    switch(v->c_ac_table_index){
2671
    case 0:
2672
        v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2673
        break;
2674
    case 1:
2675
        v->codingset = CS_HIGH_MOT_INTRA;
2676
        break;
2677
    case 2:
2678
        v->codingset = CS_MID_RATE_INTRA;
2679
        break;
2680
    }
2681

    
2682
    switch(v->c_ac_table_index){
2683
    case 0:
2684
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2685
        break;
2686
    case 1:
2687
        v->codingset2 = CS_HIGH_MOT_INTER;
2688
        break;
2689
    case 2:
2690
        v->codingset2 = CS_MID_RATE_INTER;
2691
        break;
2692
    }
2693

    
2694
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2695
    s->first_slice_line = 1;
2696
    for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2697
        for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2698
            ff_init_block_index(s);
2699
            ff_update_block_index(s);
2700
            s->dsp.clear_blocks(s->block[0]);
2701

    
2702
            vc1_decode_p_mb(v, s->block);
2703
            if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
2704
                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);
2705
                return;
2706
            }
2707
        }
2708
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
2709
        s->first_slice_line = 0;
2710
    }
2711
}
2712

    
2713
static void vc1_decode_blocks(VC1Context *v)
2714
{
2715

    
2716
    v->s.esc3_level_length = 0;
2717

    
2718
    switch(v->s.pict_type) {
2719
    case I_TYPE:
2720
        vc1_decode_i_blocks(v);
2721
        break;
2722
    case P_TYPE:
2723
        vc1_decode_p_blocks(v);
2724
        break;
2725
    }
2726
}
2727

    
2728

    
2729
/** Initialize a VC1/WMV3 decoder
2730
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2731
 * @todo TODO: Decypher remaining bits in extra_data
2732
 */
2733
static int vc1_decode_init(AVCodecContext *avctx)
2734
{
2735
    VC1Context *v = avctx->priv_data;
2736
    MpegEncContext *s = &v->s;
2737
    GetBitContext gb;
2738

    
2739
    if (!avctx->extradata_size || !avctx->extradata) return -1;
2740
    avctx->pix_fmt = PIX_FMT_YUV420P;
2741
    v->s.avctx = avctx;
2742
    avctx->flags |= CODEC_FLAG_EMU_EDGE;
2743
    v->s.flags |= CODEC_FLAG_EMU_EDGE;
2744

    
2745
    if(ff_h263_decode_init(avctx) < 0)
2746
        return -1;
2747
    if (vc1_init_common(v) < 0) return -1;
2748

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

    
2752
    avctx->coded_width = avctx->width;
2753
    avctx->coded_height = avctx->height;
2754
    if (avctx->codec_id == CODEC_ID_WMV3)
2755
    {
2756
        int count = 0;
2757

    
2758
        // looks like WMV3 has a sequence header stored in the extradata
2759
        // advanced sequence header may be before the first frame
2760
        // the last byte of the extradata is a version number, 1 for the
2761
        // samples we can decode
2762

    
2763
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2764

    
2765
        if (decode_sequence_header(avctx, &gb) < 0)
2766
          return -1;
2767

    
2768
        count = avctx->extradata_size*8 - get_bits_count(&gb);
2769
        if (count>0)
2770
        {
2771
            av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2772
                   count, get_bits(&gb, count));
2773
        }
2774
        else if (count < 0)
2775
        {
2776
            av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2777
        }
2778
    }
2779
    avctx->has_b_frames= !!(avctx->max_b_frames);
2780

    
2781
    s->mb_width = (avctx->coded_width+15)>>4;
2782
    s->mb_height = (avctx->coded_height+15)>>4;
2783

    
2784
    /* Allocate mb bitplanes */
2785
    v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
2786

    
2787
    /* allocate block type info in that way so it could be used with s->block_index[] */
2788
    v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
2789
    v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
2790
    v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
2791
    v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
2792

    
2793
    /* Init coded blocks info */
2794
    if (v->profile == PROFILE_ADVANCED)
2795
    {
2796
//        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2797
//            return -1;
2798
//        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2799
//            return -1;
2800
    }
2801

    
2802
    return 0;
2803
}
2804

    
2805

    
2806
/** Decode a VC1/WMV3 frame
2807
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2808
 * @warning Initial try at using MpegEncContext stuff
2809
 */
2810
static int vc1_decode_frame(AVCodecContext *avctx,
2811
                            void *data, int *data_size,
2812
                            uint8_t *buf, int buf_size)
2813
{
2814
    VC1Context *v = avctx->priv_data;
2815
    MpegEncContext *s = &v->s;
2816
    AVFrame *pict = data;
2817

    
2818
    /* no supplementary picture */
2819
    if (buf_size == 0) {
2820
        /* special case for last picture */
2821
        if (s->low_delay==0 && s->next_picture_ptr) {
2822
            *pict= *(AVFrame*)s->next_picture_ptr;
2823
            s->next_picture_ptr= NULL;
2824

    
2825
            *data_size = sizeof(AVFrame);
2826
        }
2827

    
2828
        return 0;
2829
    }
2830

    
2831
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2832
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2833
        int i= ff_find_unused_picture(s, 0);
2834
        s->current_picture_ptr= &s->picture[i];
2835
    }
2836

    
2837
    avctx->has_b_frames= !s->low_delay;
2838

    
2839
    init_get_bits(&s->gb, buf, buf_size*8);
2840
    // do parse frame header
2841
    if(vc1_parse_frame_header(v, &s->gb) == -1)
2842
        return -1;
2843

    
2844
    if(s->pict_type != I_TYPE && s->pict_type != P_TYPE)return -1;
2845

    
2846
    // for hurry_up==5
2847
    s->current_picture.pict_type= s->pict_type;
2848
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2849

    
2850
    /* skip B-frames if we don't have reference frames */
2851
    if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return -1;//buf_size;
2852
    /* skip b frames if we are in a hurry */
2853
    if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
2854
    if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
2855
       || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
2856
       ||  avctx->skip_frame >= AVDISCARD_ALL)
2857
        return buf_size;
2858
    /* skip everything if we are in a hurry>=5 */
2859
    if(avctx->hurry_up>=5) return -1;//buf_size;
2860

    
2861
    if(s->next_p_frame_damaged){
2862
        if(s->pict_type==B_TYPE)
2863
            return buf_size;
2864
        else
2865
            s->next_p_frame_damaged=0;
2866
    }
2867

    
2868
    if(MPV_frame_start(s, avctx) < 0)
2869
        return -1;
2870

    
2871
    ff_er_frame_start(s);
2872

    
2873
    v->bits = buf_size * 8;
2874
    vc1_decode_blocks(v);
2875
//av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
2876
//  if(get_bits_count(&s->gb) > buf_size * 8)
2877
//      return -1;
2878
    ff_er_frame_end(s);
2879

    
2880
    MPV_frame_end(s);
2881

    
2882
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2883
assert(s->current_picture.pict_type == s->pict_type);
2884
    if (s->pict_type == B_TYPE || s->low_delay) {
2885
        *pict= *(AVFrame*)s->current_picture_ptr;
2886
    } else if (s->last_picture_ptr != NULL) {
2887
        *pict= *(AVFrame*)s->last_picture_ptr;
2888
    }
2889

    
2890
    if(s->last_picture_ptr || s->low_delay){
2891
        *data_size = sizeof(AVFrame);
2892
        ff_print_debug_info(s, pict);
2893
    }
2894

    
2895
    /* Return the Picture timestamp as the frame number */
2896
    /* we substract 1 because it is added on utils.c    */
2897
    avctx->frame_number = s->picture_number - 1;
2898

    
2899
    return buf_size;
2900
}
2901

    
2902

    
2903
/** Close a VC1/WMV3 decoder
2904
 * @warning Initial try at using MpegEncContext stuff
2905
 */
2906
static int vc1_decode_end(AVCodecContext *avctx)
2907
{
2908
    VC1Context *v = avctx->priv_data;
2909

    
2910
    av_freep(&v->hrd_rate);
2911
    av_freep(&v->hrd_buffer);
2912
    MPV_common_end(&v->s);
2913
    av_freep(&v->mv_type_mb_plane);
2914
    av_freep(&v->mb_type_base);
2915
    return 0;
2916
}
2917

    
2918

    
2919
AVCodec vc1_decoder = {
2920
    "vc1",
2921
    CODEC_TYPE_VIDEO,
2922
    CODEC_ID_VC1,
2923
    sizeof(VC1Context),
2924
    vc1_decode_init,
2925
    NULL,
2926
    vc1_decode_end,
2927
    vc1_decode_frame,
2928
    CODEC_CAP_DELAY,
2929
    NULL
2930
};
2931

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