Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vc1.c @ 928dc49d

History | View | Annotate | Download (96.9 KB)

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

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

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

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

    
47

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

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

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

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

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

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

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

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

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

    
140
static const int ttfrm_to_tt[4] = { TT_8X8, TT_8X4, TT_4X8, TT_4X4 };
141

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

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

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

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

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

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

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

    
219
    int bits;
220

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

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

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

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

    
298

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
477
    return 0;
478
}
479

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
718

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
828
/** Apply overlap transform
829
 * @todo optimize
830
 * @todo move to DSPContext
831
 */
832
static void vc1_overlap_block(MpegEncContext *s, DCTELEM block[64], int n, int do_hor, int do_vert)
833
{
834
    int i;
835

    
836
    if(do_hor) { //TODO
837
    }
838
    if(do_vert) { //TODO
839
    }
840

    
841
    for(i = 0; i < 64; i++)
842
        block[i] += 128;
843
}
844

    
845

    
846
static void vc1_v_overlap(uint8_t* src, int stride)
847
{
848
    int i;
849
    int a, b, c, d;
850
    for(i = 0; i < 8; i++) {
851
        a = src[-2*stride];
852
        b = src[-stride];
853
        c = src[0];
854
        d = src[stride];
855

    
856
        src[-2*stride] = clip_uint8((7*a + d + 3) >> 3);
857
        src[-stride] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
858
        src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
859
        src[stride] = clip_uint8((a + 7*d + 3) >> 3);
860
        src++;
861
    }
862
}
863

    
864
static void vc1_h_overlap(uint8_t* src, int stride)
865
{
866
    int i;
867
    int a, b, c, d;
868
    for(i = 0; i < 8; i++) {
869
        a = src[-2];
870
        b = src[-1];
871
        c = src[0];
872
        d = src[1];
873

    
874
        src[-2] = clip_uint8((7*a + d + 3) >> 3);
875
        src[-1] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
876
        src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
877
        src[1] = clip_uint8((a + 7*d + 3) >> 3);
878
        src += stride;
879
    }
880
}
881

    
882
/** Put block onto picture
883
 * @todo move to DSPContext
884
 */
885
static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
886
{
887
    uint8_t *Y;
888
    int ys, us, vs;
889
    DSPContext *dsp = &v->s.dsp;
890

    
891
    ys = v->s.current_picture.linesize[0];
892
    us = v->s.current_picture.linesize[1];
893
    vs = v->s.current_picture.linesize[2];
894
    Y = v->s.dest[0];
895

    
896
    dsp->put_pixels_clamped(block[0], Y, ys);
897
    dsp->put_pixels_clamped(block[1], Y + 8, ys);
898
    Y += ys * 8;
899
    dsp->put_pixels_clamped(block[2], Y, ys);
900
    dsp->put_pixels_clamped(block[3], Y + 8, ys);
901

    
902
    dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
903
    dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
904
}
905

    
906
/* clip motion vector as specified in 8.3.6.5 */
907
#define CLIP_RANGE(mv, src, lim, bs)      \
908
    if(mv < -bs) mv = -bs - src * bs; \
909
    if(mv > lim) mv = lim - src * bs;
910

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

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

    
923
    mx = s->mv[0][0][0];
924
    my = s->mv[0][0][1];
925
    uvmx = (mx + ((mx & 3) == 3)) >> 1;
926
    uvmy = (my + ((my & 3) == 3)) >> 1;
927
    srcY = s->last_picture.data[0];
928
    srcU = s->last_picture.data[1];
929
    srcV = s->last_picture.data[2];
930

    
931
    if(v->fastuvmc) { // XXX: 8.3.5.4.5 specifies something different
932
        uvmx = (uvmx + 1) & ~1;
933
        uvmy = (uvmy + 1) & ~1;
934
    }
935

    
936
    src_x = s->mb_x * 16 + (mx >> 2);
937
    src_y = s->mb_y * 16 + (my >> 2);
938
    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
939
    uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
940

    
941
    CLIP_RANGE(  src_x, s->mb_x, s->mb_width  * 16, 16);
942
    CLIP_RANGE(  src_y, s->mb_y, s->mb_height * 16, 16);
943
    CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width  *  8,  8);
944
    CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height *  8,  8);
945

    
946
    srcY += src_y * s->linesize + src_x;
947
    srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
948
    srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
949

    
950
    if((v->mv_mode == MV_PMODE_INTENSITY_COMP)
951
       || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
952
       || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
953
        uint8_t *uvbuf= s->edge_emu_buffer + 18 * s->linesize;
954

    
955
        ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
956
                            src_x, src_y, s->h_edge_pos, s->v_edge_pos);
957
        srcY = s->edge_emu_buffer;
958
        ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
959
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
960
        ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
961
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
962
        srcU = uvbuf;
963
        srcV = uvbuf + 16;
964
        /* if we deal with intensity compensation we need to scale source blocks */
965
        if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
966
            int i, j;
967
            uint8_t *src, *src2;
968

    
969
            src = srcY;
970
            for(j = 0; j < 17; j++) {
971
                for(i = 0; i < 17; i++) src[i] = v->luty[src[i]];
972
                src += s->linesize;
973
            }
974
            src = srcU; src2 = srcV;
975
            for(j = 0; j < 9; j++) {
976
                for(i = 0; i < 9; i++) {
977
                    src[i] = v->lutuv[src[i]];
978
                    src2[i] = v->lutuv[src2[i]];
979
                }
980
                src += s->uvlinesize;
981
                src2 += s->uvlinesize;
982
            }
983
        }
984
    }
985

    
986
    if(!s->quarter_sample) { // hpel mc
987
        mx >>= 1;
988
        my >>= 1;
989
        dxy = ((my & 1) << 1) | (mx & 1);
990
        uvdxy = 0;
991

    
992
        dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
993
    } else {
994
        dxy = ((my & 3) << 2) | (mx & 3);
995
        uvdxy = ((uvmy & 1) << 1) | (uvmx & 1);
996

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

    
1005
/** Do motion compensation for 4-MV macroblock - luminance block
1006
 */
1007
static void vc1_mc_4mv_luma(VC1Context *v, int n)
1008
{
1009
    MpegEncContext *s = &v->s;
1010
    DSPContext *dsp = &v->s.dsp;
1011
    uint8_t *srcY;
1012
    int dxy, mx, my, src_x, src_y;
1013
    int off;
1014

    
1015
    if(!v->s.last_picture.data[0])return;
1016
    mx = s->mv[0][n][0];
1017
    my = s->mv[0][n][1];
1018
    srcY = s->last_picture.data[0];
1019

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

    
1022
    src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
1023
    src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
1024

    
1025
    CLIP_RANGE(src_x, s->mb_x, s->mb_width  * 16, 16);
1026
    CLIP_RANGE(src_y, s->mb_y, s->mb_height * 16, 16);
1027

    
1028
    srcY += src_y * s->linesize + src_x;
1029

    
1030
    if((unsigned)src_x > s->h_edge_pos - (mx&3) - 16
1031
       || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
1032
        ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
1033
                            src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1034
        srcY = s->edge_emu_buffer;
1035
    }
1036

    
1037
    if(!s->quarter_sample) { // hpel mc
1038
        mx >>= 1;
1039
        my >>= 1;
1040
        dxy = ((my & 1) << 1) | (mx & 1);
1041

    
1042
        dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1043
    } else {
1044
        dxy = ((my & 3) << 2) | (mx & 3);
1045

    
1046
        dsp->put_no_rnd_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
1047
    }
1048
}
1049

    
1050
static inline int median4(int a, int b, int c, int d)
1051
{
1052
    if(a < b) {
1053
        if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) >> 1;
1054
        else      return (FFMIN(b, c) + FFMAX(a, d)) >> 1;
1055
    } else {
1056
        if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) >> 1;
1057
        else      return (FFMIN(a, c) + FFMAX(b, d)) >> 1;
1058
    }
1059
}
1060

    
1061

    
1062
/** Do motion compensation for 4-MV macroblock - both chroma blocks
1063
 */
1064
static void vc1_mc_4mv_chroma(VC1Context *v)
1065
{
1066
    MpegEncContext *s = &v->s;
1067
    DSPContext *dsp = &v->s.dsp;
1068
    uint8_t *srcU, *srcV;
1069
    int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1070
    int i, idx, tx = 0, ty = 0;
1071
    int mvx[4], mvy[4], intra[4];
1072
    static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1073

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

    
1076
    for(i = 0; i < 4; i++) {
1077
        mvx[i] = s->mv[0][i][0];
1078
        mvy[i] = s->mv[0][i][1];
1079
        intra[i] = v->mb_type[0][s->block_index[i]];
1080
    }
1081

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

    
1115
    uvmx = (tx + ((tx&3) == 3)) >> 1;
1116
    uvmy = (ty + ((ty&3) == 3)) >> 1;
1117

    
1118
    uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1119
    uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1120

    
1121
    CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width  *  8,  8);
1122
    CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height *  8,  8);
1123
    srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1124
    srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1125
    if((unsigned)uvsrc_x > (s->h_edge_pos >> 1) - ((uvmx >> 1)&1) - 8
1126
       || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - ((uvmy >> 1)&1) - 8){
1127
        ff_emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize, 8+1, 8+1,
1128
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1129
        ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1130
                            uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1131
        srcU = s->edge_emu_buffer;
1132
        srcV = s->edge_emu_buffer + 16;
1133
    }
1134

    
1135
    if(!s->quarter_sample) // hpel mc
1136
        uvdxy = 0;
1137
    else
1138
        uvdxy = ((uvmy & 1) << 1) | (uvmx & 1);
1139
    dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize, 8);
1140
    dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize, 8);
1141
}
1142

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

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

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

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

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

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

    
1235
    if (v->profile < PROFILE_ADVANCED)
1236
    {
1237
        v->res_transtab = get_bits(gb, 1);
1238
        if (v->res_transtab)
1239
        {
1240
            av_log(avctx, AV_LOG_ERROR,
1241
                   "1 for reserved RES_TRANSTAB is forbidden\n");
1242
            return -1;
1243
        }
1244
    }
1245

    
1246
    v->overlap = get_bits(gb, 1); //common
1247

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

    
1259
    v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1260
    v->quantizer_mode = get_bits(gb, 2); //common
1261

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

    
1287

    
1288
static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1289
{
1290
    int pqindex, lowquant, status;
1291

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

    
1304
    if(v->s.pict_type == I_TYPE)
1305
        get_bits(gb, 7); // skip buffer fullness
1306

    
1307
    /* Quantizer stuff */
1308
    pqindex = get_bits(gb, 5);
1309
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1310
        v->pq = pquant_table[0][pqindex];
1311
    else
1312
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1313

    
1314
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1315
        v->pquantizer = pqindex < 9;
1316
    if (v->quantizer_mode == QUANT_UNIFORM || v->quantizer_mode == QUANT_NON_UNIFORM)
1317
        v->pquantizer = v->quantizer_mode == QUANT_UNIFORM;
1318
    v->pqindex = pqindex;
1319
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1320
    else v->halfpq = 0;
1321
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1322
        v->pquantizer = get_bits(gb, 1);
1323
    v->dquantfrm = 0;
1324

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

    
1328
    //TODO: complete parsing for P/B/BI frames
1329
    switch(v->s.pict_type) {
1330
    case P_TYPE:
1331
        if (v->pq < 5) v->tt_index = 0;
1332
        else if(v->pq < 13) v->tt_index = 1;
1333
        else v->tt_index = 2;
1334

    
1335
        if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1336
        v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1337
        v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1338
        v->range_x = 1 << (v->k_x - 1);
1339
        v->range_y = 1 << (v->k_y - 1);
1340
        if (v->profile == PROFILE_ADVANCED)
1341
        {
1342
            if (v->postprocflag) v->postproc = get_bits(gb, 1);
1343
        }
1344
        else
1345
            if (v->multires) v->respic = get_bits(gb, 2);
1346
        lowquant = (v->pq > 12) ? 0 : 1;
1347
        v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1348
        if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1349
        {
1350
            int scale, shift, i;
1351
            v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1352
            v->lumscale = get_bits(gb, 6);
1353
            v->lumshift = get_bits(gb, 6);
1354
            /* fill lookup tables for intensity compensation */
1355
            if(!v->lumscale) {
1356
                scale = -64;
1357
                shift = (255 - v->lumshift * 2) << 6;
1358
                if(v->lumshift > 31)
1359
                    shift += 128 << 6;
1360
            } else {
1361
                scale = v->lumscale + 32;
1362
                if(v->lumshift > 31)
1363
                    shift = (v->lumshift - 64) << 6;
1364
                else
1365
                    shift = v->lumshift << 6;
1366
            }
1367
            for(i = 0; i < 256; i++) {
1368
                v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1369
                v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1370
            }
1371
        }
1372
        if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1373
            v->s.quarter_sample = 0;
1374
        else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1375
            if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1376
                v->s.quarter_sample = 0;
1377
            else
1378
                v->s.quarter_sample = 1;
1379
        } else
1380
            v->s.quarter_sample = 1;
1381

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

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

    
1403
        if (v->dquant)
1404
        {
1405
            av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1406
            vop_dquant_decoding(v);
1407
        }
1408

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

    
1423
    /* AC Syntax */
1424
    v->c_ac_table_index = decode012(gb);
1425
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1426
    {
1427
        v->y_ac_table_index = decode012(gb);
1428
    }
1429
    /* DC Syntax */
1430
    v->s.dc_table_index = get_bits(gb, 1);
1431

    
1432
    return 0;
1433
}
1434

    
1435
/***********************************************************************/
1436
/**
1437
 * @defgroup block VC-1 Block-level functions
1438
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1439
 * @todo TODO: Integrate to MpegEncContext facilities
1440
 * @{
1441
 */
1442

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

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

    
1534
/** Predict and set motion vector
1535
 */
1536
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)
1537
{
1538
    int xy, wrap, off = 0;
1539
    int16_t *A, *B, *C;
1540
    int px, py;
1541
    int sum;
1542

    
1543
    /* scale MV difference to be quad-pel */
1544
    dmv_x <<= 1 - s->quarter_sample;
1545
    dmv_y <<= 1 - s->quarter_sample;
1546

    
1547
    wrap = s->b8_stride;
1548
    xy = s->block_index[n];
1549

    
1550
    if(s->mb_intra){
1551
        s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1552
        s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1553
        if(mv1) { /* duplicate motion data for 1-MV block */
1554
            s->current_picture.motion_val[0][xy + 1][0] = 0;
1555
            s->current_picture.motion_val[0][xy + 1][1] = 0;
1556
            s->current_picture.motion_val[0][xy + wrap][0] = 0;
1557
            s->current_picture.motion_val[0][xy + wrap][1] = 0;
1558
            s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1559
            s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1560
        }
1561
        return;
1562
    }
1563

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

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

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

    
1679
    /* find prediction - wmv3_dc_scale always used here in fact */
1680
    if (n < 4)     scale = s->y_dc_scale;
1681
    else           scale = s->c_dc_scale;
1682

    
1683
    wrap = s->block_wrap[n];
1684
    dc_val= s->dc_val[0] + s->block_index[n];
1685

    
1686
    /* B A
1687
     * C X
1688
     */
1689
    c = dc_val[ - 1];
1690
    b = dc_val[ - 1 - wrap];
1691
    a = dc_val[ - wrap];
1692

    
1693
    if (pq < 9 || !overlap)
1694
    {
1695
        /* Set outer values */
1696
        if (!s->mb_y && (n!=2 && n!=3)) b=a=dcpred[scale];
1697
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1698
    }
1699
    else
1700
    {
1701
        /* Set outer values */
1702
        if (!s->mb_y && (n!=2 && n!=3)) b=a=0;
1703
        if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1704
    }
1705

    
1706
    if (abs(a - b) <= abs(b - c)) {
1707
        pred = c;
1708
        *dir_ptr = 1;//left
1709
    } else {
1710
        pred = a;
1711
        *dir_ptr = 0;//top
1712
    }
1713

    
1714
    /* update predictor */
1715
    *dc_val_ptr = &dc_val[0];
1716
    return pred;
1717
}
1718

    
1719

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

    
1736
    /* find prediction - wmv3_dc_scale always used here in fact */
1737
    if (n < 4)     scale = s->y_dc_scale;
1738
    else           scale = s->c_dc_scale;
1739

    
1740
    wrap = s->block_wrap[n];
1741
    dc_val= s->dc_val[0] + s->block_index[n];
1742

    
1743
    /* B A
1744
     * C X
1745
     */
1746
    c = dc_val[ - 1];
1747
    b = dc_val[ - 1 - wrap];
1748
    a = dc_val[ - wrap];
1749

    
1750
    if(a_avail && c_avail) {
1751
        if(abs(a - b) <= abs(b - c)) {
1752
            pred = c;
1753
            *dir_ptr = 1;//left
1754
        } else {
1755
            pred = a;
1756
            *dir_ptr = 0;//top
1757
        }
1758
    } else if(a_avail) {
1759
        pred = a;
1760
        *dir_ptr = 0;//top
1761
    } else if(c_avail) {
1762
        pred = c;
1763
        *dir_ptr = 1;//left
1764
    } else {
1765
        pred = 0;
1766
        *dir_ptr = 1;//left
1767
    }
1768

    
1769
    /* scale coeffs if needed
1770
    mb_pos2 = mb_pos - *dir_ptr - (1 - *dir_ptr) * s->mb_stride;
1771
    q1 = s->y_dc_scale_table[s->current_picture.qscale_table[mb_pos]];
1772
    q2 = s->y_dc_scale_table[s->current_picture.qscale_table[mb_pos2]];
1773
    if(q2 && q1!=q2 && ((*dir_ptr && c_avail) || (!*dir_ptr && a_avail))) {
1774
        pred = (pred * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
1775
    } */
1776

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

    
1782

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

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

    
1794
    xy = s->block_index[n];
1795
    wrap = s->b8_stride;
1796

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

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

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

    
1813
    return pred;
1814
}
1815

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

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

    
1877
    *last = lst;
1878
    *skip = run;
1879
    *value = level;
1880
}
1881

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

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

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

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

    
1945
    //AC Decoding
1946
    i = 1;
1947

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

    
1954
        scale = v->pq * 2 + v->halfpq;
1955

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

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

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

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

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

    
2003
        if(s->ac_pred) i = 63;
2004
    }
2005

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

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

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

    
2044
    return 0;
2045
}
2046

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

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

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

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

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

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

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

    
2120
    //AC Decoding
2121
    i = 1;
2122

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

    
2130
    scale = mquant * 2;
2131

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

    
2137
    if(coded) {
2138
        int last = 0, skip, value;
2139
        const int8_t *zz_table;
2140
        int k;
2141

    
2142
        zz_table = vc1_simple_progressive_8x8_zz;
2143

    
2144
        while (!last) {
2145
            vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2146
            i += skip;
2147
            if(i > 63)
2148
                break;
2149
            block[zz_table[i++]] = value;
2150
        }
2151

    
2152
        /* apply AC prediction if needed */
2153
        if(use_pred) {
2154
            /* scale predictors if needed*/
2155
            int mb_pos2, q1, q2;
2156

    
2157
            mb_pos2 = mb_pos - dc_pred_dir - (1 - dc_pred_dir) * s->mb_stride;
2158
            q1 = s->current_picture.qscale_table[mb_pos];
2159
            q2 = s->current_picture.qscale_table[mb_pos2];
2160

    
2161
            if(0 && q2 && q1!=q2 && ((dc_pred_dir && c_avail) || (!dc_pred_dir && a_avail))) {
2162
                q1 = q1 * 2 - 1;
2163
                q2 = q2 * 2 - 1;
2164

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

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

    
2196
        if(use_pred) i = 63;
2197
    } else { // no AC coeffs
2198
        int k;
2199
        int mb_pos2, q1, q2;
2200

    
2201
        mb_pos2 = mb_pos - dc_pred_dir - (1 - dc_pred_dir) * s->mb_stride;
2202
        q1 = s->current_picture.qscale_table[mb_pos];
2203
        q2 = s->current_picture.qscale_table[mb_pos2];
2204

    
2205
        memset(ac_val2, 0, 16 * 2);
2206
        if(dc_pred_dir) {//left
2207
            if(use_pred) {
2208
                memcpy(ac_val2, ac_val, 8 * 2);
2209
                if(0 && q2 && q1!=q2 && c_avail) {
2210
                    q1 = q1 * 2 - 1;
2211
                    q2 = q2 * 2 - 1;
2212
                    for(k = 1; k < 8; k++)
2213
                        ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2214
                }
2215
            }
2216
        } else {//top
2217
            if(use_pred) {
2218
                memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2219
                if(0 && q2 && q1!=q2 && a_avail) {
2220
                    q1 = q1 * 2 - 1;
2221
                    q2 = q2 * 2 - 1;
2222
                    for(k = 1; k < 8; k++)
2223
                        ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2224
                }
2225
            }
2226
        }
2227

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

    
2248
    return 0;
2249
}
2250

    
2251
/** Decode P block
2252
 */
2253
static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
2254
{
2255
    MpegEncContext *s = &v->s;
2256
    GetBitContext *gb = &s->gb;
2257
    int i, j;
2258
    int subblkpat = 0;
2259
    int scale, off, idx, last, skip, value;
2260
    int ttblk = ttmb & 7;
2261

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

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

    
2354

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

    
2370
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2371
      offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2372
    int mb_has_coeffs = 1; /* last_flag */
2373
    int dmv_x, dmv_y; /* Differential MV components */
2374
    int index, index1; /* LUT indices */
2375
    int val, sign; /* temp values */
2376
    int first_block = 1;
2377
    int dst_idx, off;
2378
    int skipped, fourmv;
2379

    
2380
    mquant = v->pq; /* Loosy initialization */
2381

    
2382
    if (v->mv_type_is_raw)
2383
        fourmv = get_bits1(gb);
2384
    else
2385
        fourmv = v->mv_type_mb_plane[mb_pos];
2386
    if (v->skip_is_raw)
2387
        skipped = get_bits1(gb);
2388
    else
2389
        skipped = v->s.mbskip_table[mb_pos];
2390

    
2391
    s->dsp.clear_blocks(s->block[0]);
2392

    
2393
    if (!fourmv) /* 1MV mode */
2394
    {
2395
        if (!skipped)
2396
        {
2397
            GET_MVDATA(dmv_x, dmv_y);
2398

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

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

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

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

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

    
2573
    /* Should never happen */
2574
    return -1;
2575
}
2576

    
2577
/** Decode blocks of I-frame
2578
 */
2579
static void vc1_decode_i_blocks(VC1Context *v)
2580
{
2581
    int k;
2582
    MpegEncContext *s = &v->s;
2583
    int cbp, val;
2584
    uint8_t *coded_val;
2585
    int mb_pos;
2586

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

    
2600
    switch(v->c_ac_table_index){
2601
    case 0:
2602
        v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2603
        break;
2604
    case 1:
2605
        v->codingset2 = CS_HIGH_MOT_INTER;
2606
        break;
2607
    case 2:
2608
        v->codingset2 = CS_MID_RATE_INTER;
2609
        break;
2610
    }
2611

    
2612
    /* Set DC scale - y and c use the same */
2613
    s->y_dc_scale = s->y_dc_scale_table[v->pq];
2614
    s->c_dc_scale = s->c_dc_scale_table[v->pq];
2615

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

    
2629
            // do actual MB decoding and displaying
2630
            cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2631
            v->s.ac_pred = get_bits(&v->s.gb, 1);
2632

    
2633
            for(k = 0; k < 6; k++) {
2634
                val = ((cbp >> (5 - k)) & 1);
2635

    
2636
                if (k < 4) {
2637
                    int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2638
                    val = val ^ pred;
2639
                    *coded_val = val;
2640
                }
2641
                cbp |= val << (5 - k);
2642

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

    
2645
                vc1_inv_trans(s->block[k], 8, 8);
2646
                if(v->pq >= 9 && v->overlap) {
2647
                    vc1_overlap_block(s, s->block[k], k, (s->mb_y || k>1), (s->mb_x || (k != 0 && k != 2)));
2648
                }
2649
            }
2650

    
2651
            vc1_put_block(v, s->block);
2652
            if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
2653
                if(s->mb_y) {
2654
                    s->dsp.h263_v_loop_filter(s->dest[0], s->linesize, s->y_dc_scale);
2655
                    s->dsp.h263_v_loop_filter(s->dest[0] + 8, s->linesize, s->y_dc_scale);
2656
                    s->dsp.h263_v_loop_filter(s->dest[1], s->uvlinesize, s->y_dc_scale);
2657
                    s->dsp.h263_v_loop_filter(s->dest[2], s->uvlinesize, s->y_dc_scale);
2658
                }
2659
                s->dsp.h263_v_loop_filter(s->dest[0] + 8 * s->linesize, s->linesize, s->y_dc_scale);
2660
                s->dsp.h263_v_loop_filter(s->dest[0] + 8 * s->linesize + 8, s->linesize, s->y_dc_scale);
2661
                if(s->mb_x) {
2662
                    s->dsp.h263_h_loop_filter(s->dest[0], s->linesize, s->y_dc_scale);
2663
                    s->dsp.h263_h_loop_filter(s->dest[0] + 8 * s->linesize, s->linesize, s->y_dc_scale);
2664
                    s->dsp.h263_h_loop_filter(s->dest[1], s->uvlinesize, s->y_dc_scale);
2665
                    s->dsp.h263_h_loop_filter(s->dest[2], s->uvlinesize, s->y_dc_scale);
2666
                }
2667
                s->dsp.h263_h_loop_filter(s->dest[0] + 8, s->linesize, s->y_dc_scale);
2668
                s->dsp.h263_h_loop_filter(s->dest[0] + 8 * s->linesize + 8, s->linesize, s->y_dc_scale);
2669
            }
2670

    
2671
            if(get_bits_count(&s->gb) > v->bits) {
2672
                av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
2673
                return;
2674
            }
2675
        }
2676
        ff_draw_horiz_band(s, s->mb_y * 16, 16);
2677
    }
2678
}
2679

    
2680
static void vc1_decode_p_blocks(VC1Context *v)
2681
{
2682
    MpegEncContext *s = &v->s;
2683

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

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

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

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

    
2728
static void vc1_decode_blocks(VC1Context *v)
2729
{
2730

    
2731
    v->s.esc3_level_length = 0;
2732

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

    
2743

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

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

    
2760
    if(ff_h263_decode_init(avctx) < 0)
2761
        return -1;
2762
    if (vc1_init_common(v) < 0) return -1;
2763

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

    
2767
    avctx->coded_width = avctx->width;
2768
    avctx->coded_height = avctx->height;
2769
    if (avctx->codec_id == CODEC_ID_WMV3)
2770
    {
2771
        int count = 0;
2772

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

    
2778
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2779

    
2780
        if (decode_sequence_header(avctx, &gb) < 0)
2781
          return -1;
2782

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

    
2796
    s->mb_width = (avctx->coded_width+15)>>4;
2797
    s->mb_height = (avctx->coded_height+15)>>4;
2798

    
2799
    /* Allocate mb bitplanes */
2800
    v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
2801

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

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

    
2817
    return 0;
2818
}
2819

    
2820

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

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

    
2840
            *data_size = sizeof(AVFrame);
2841
        }
2842

    
2843
        return 0;
2844
    }
2845

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

    
2852
    avctx->has_b_frames= !s->low_delay;
2853

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

    
2859
    if(s->pict_type != I_TYPE && s->pict_type != P_TYPE)return -1;
2860

    
2861
    // for hurry_up==5
2862
    s->current_picture.pict_type= s->pict_type;
2863
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2864

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

    
2876
    if(s->next_p_frame_damaged){
2877
        if(s->pict_type==B_TYPE)
2878
            return buf_size;
2879
        else
2880
            s->next_p_frame_damaged=0;
2881
    }
2882

    
2883
    if(MPV_frame_start(s, avctx) < 0)
2884
        return -1;
2885

    
2886
    ff_er_frame_start(s);
2887

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

    
2895
    MPV_frame_end(s);
2896

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

    
2905
    if(s->last_picture_ptr || s->low_delay){
2906
        *data_size = sizeof(AVFrame);
2907
        ff_print_debug_info(s, pict);
2908
    }
2909

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

    
2914
    return buf_size;
2915
}
2916

    
2917

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

    
2925
    av_freep(&v->hrd_rate);
2926
    av_freep(&v->hrd_buffer);
2927
    MPV_common_end(&v->s);
2928
    av_freep(&v->mv_type_mb_plane);
2929
    av_freep(&v->mb_type_base);
2930
    return 0;
2931
}
2932

    
2933

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

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