Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vc1.c @ 10b9c374

History | View | Annotate | Download (82.1 KB)

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

    
23
/**
24
 * @file vc1.c
25
 * VC-1 and WMV3 decoder
26
 *
27
 * TODO: most AP stuff, optimize, most of MB layer, transform, filtering and motion compensation, etc
28
 * TODO: use MPV_ !!
29
 */
30
#include "common.h"
31
#include "dsputil.h"
32
#include "avcodec.h"
33
#include "mpegvideo.h"
34
#include "vc1data.h"
35

    
36
#undef NDEBUG
37
#include <assert.h>
38

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

    
47
/* Some inhibiting stuff */
48
#define HAS_ADVANCED_PROFILE   0
49
#define TRACE                  1
50

    
51
#if TRACE
52
#  define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \
53
                   codes, codes_wrap, codes_size, use_static)          \
54
  if (init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size,     \
55
               codes, codes_wrap, codes_size, use_static) < 0)         \
56
  {                                                                    \
57
    av_log(v->s.avctx, AV_LOG_ERROR, "Error for " # vlc " (%i)\n", i);   \
58
    return -1;                                                         \
59
  }
60
#else
61
#  define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \
62
                   codes, codes_wrap, codes_size, use_static)          \
63
  init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size,         \
64
           codes, codes_wrap, codes_size, use_static)
65
#endif
66

    
67
/** Available Profiles */
68
//@{
69
#define PROFILE_SIMPLE   0
70
#define PROFILE_MAIN     1
71
#define PROFILE_COMPLEX  2 ///< TODO: WMV9 specific
72
#define PROFILE_ADVANCED 3
73
//@}
74

    
75
/** Sequence quantizer mode */
76
//@{
77
#define QUANT_FRAME_IMPLICIT   0 ///< Implicitly specified at frame level
78
#define QUANT_FRAME_EXPLICIT   1 ///< Explicitly specified at frame level
79
#define QUANT_NON_UNIFORM      2 ///< Non-uniform quant used for all frames
80
#define QUANT_UNIFORM          3 ///< Uniform quant used for all frames
81
//@}
82

    
83
/** Where quant can be changed */
84
//@{
85
#define DQPROFILE_FOUR_EDGES   0
86
#define DQPROFILE_DOUBLE_EDGES 1
87
#define DQPROFILE_SINGLE_EDGE  2
88
#define DQPROFILE_ALL_MBS      3
89
//@}
90

    
91
/** @name Where quant can be changed
92
 */
93
//@{
94
#define DQPROFILE_FOUR_EDGES   0
95
#define DQSINGLE_BEDGE_LEFT   0
96
#define DQSINGLE_BEDGE_TOP    1
97
#define DQSINGLE_BEDGE_RIGHT  2
98
#define DQSINGLE_BEDGE_BOTTOM 3
99
//@}
100

    
101
/** Which pair of edges is quantized with ALTPQUANT */
102
//@{
103
#define DQDOUBLE_BEDGE_TOPLEFT     0
104
#define DQDOUBLE_BEDGE_TOPRIGHT    1
105
#define DQDOUBLE_BEDGE_BOTTOMRIGHT 2
106
#define DQDOUBLE_BEDGE_BOTTOMLEFT  3
107
//@}
108

    
109
/** MV modes for P frames */
110
//@{
111
#define MV_PMODE_1MV_HPEL_BILIN   0
112
#define MV_PMODE_1MV              1
113
#define MV_PMODE_1MV_HPEL         2
114
#define MV_PMODE_MIXED_MV         3
115
#define MV_PMODE_INTENSITY_COMP   4
116
//@}
117

    
118
/** @name MV types for B frames */
119
//@{
120
#define BMV_TYPE_BACKWARD          0
121
#define BMV_TYPE_BACKWARD          0
122
#define BMV_TYPE_FORWARD           1
123
#define BMV_TYPE_INTERPOLATED      3
124
//@}
125

    
126
/** MV P mode - the 5th element is only used for mode 1 */
127
static const uint8_t mv_pmode_table[2][5] = {
128
  { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV, MV_PMODE_INTENSITY_COMP },
129
  { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_INTENSITY_COMP }
130
};
131

    
132
/** One more frame type */
133
#define BI_TYPE 7
134

    
135
static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
136
  fps_dr[2] = { 1000, 1001 };
137
static const uint8_t pquant_table[3][32] = {
138
  {  /* Implicit quantizer */
139
     0,  1,  2,  3,  4,  5,  6,  7,  8,  6,  7,  8,  9, 10, 11, 12,
140
    13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
141
  },
142
  {  /* Explicit quantizer, pquantizer uniform */
143
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
144
    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
145
  },
146
  {  /* Explicit quantizer, pquantizer non-uniform */
147
     0,  1,  1,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,
148
    14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
149
  }
150
};
151

    
152
/** @name VC-1 VLC tables and defines
153
 *  @todo TODO move this into the context
154
 */
155
//@{
156
#define VC1_BFRACTION_VLC_BITS 7
157
static VLC vc1_bfraction_vlc;
158
#define VC1_IMODE_VLC_BITS 4
159
static VLC vc1_imode_vlc;
160
#define VC1_NORM2_VLC_BITS 3
161
static VLC vc1_norm2_vlc;
162
#define VC1_NORM6_VLC_BITS 9
163
static VLC vc1_norm6_vlc;
164
/* Could be optimized, one table only needs 8 bits */
165
#define VC1_TTMB_VLC_BITS 9 //12
166
static VLC vc1_ttmb_vlc[3];
167
#define VC1_MV_DIFF_VLC_BITS 9 //15
168
static VLC vc1_mv_diff_vlc[4];
169
#define VC1_CBPCY_P_VLC_BITS 9 //14
170
static VLC vc1_cbpcy_p_vlc[4];
171
#define VC1_4MV_BLOCK_PATTERN_VLC_BITS 6
172
static VLC vc1_4mv_block_pattern_vlc[4];
173
#define VC1_TTBLK_VLC_BITS 5
174
static VLC vc1_ttblk_vlc[3];
175
#define VC1_SUBBLKPAT_VLC_BITS 6
176
static VLC vc1_subblkpat_vlc[3];
177
//@}
178

    
179
/** Bitplane struct
180
 * We mainly need data and is_raw, so this struct could be avoided
181
 * to save a level of indirection; feel free to modify
182
 * @fixme For now, stride=width
183
 * @warning Data are bits, either 1 or 0
184
 */
185
typedef struct BitPlane {
186
    uint8_t *data;      ///< Data buffer
187
    int width;          ///< Width of the buffer
188
    int stride;         ///< Stride of the buffer
189
    int height;         ///< Plane height
190
    uint8_t is_raw;     ///< Bit values must be read at MB level
191
} BitPlane;
192

    
193
/** The VC1 Context
194
 * @fixme Change size wherever another size is more efficient
195
 * Many members are only used for Advanced Profile
196
 */
197
typedef struct VC1Context{
198
    MpegEncContext s;
199

    
200
    /** Simple/Main Profile sequence header */
201
    //@{
202
    int res_sm;           ///< reserved, 2b
203
    int res_x8;           ///< reserved
204
    int multires;         ///< frame-level RESPIC syntax element present
205
    int res_fasttx;       ///< reserved, always 1
206
    int res_transtab;     ///< reserved, always 0
207
    int rangered;         ///< RANGEREDFRM (range reduction) syntax element present
208
                          ///< at frame level
209
    int res_rtm_flag;     ///< reserved, set to 1
210
    int reserved;         ///< reserved
211
    //@}
212

    
213
#if HAS_ADVANCED_PROFILE
214
    /** Advanced Profile */
215
    //@{
216
    int level;            ///< 3bits, for Advanced/Simple Profile, provided by TS layer
217
    int chromaformat;     ///< 2bits, 2=4:2:0, only defined
218
    int postprocflag;     ///< Per-frame processing suggestion flag present
219
    int broadcast;        ///< TFF/RFF present
220
    int interlace;        ///< Progressive/interlaced (RPTFTM syntax element)
221
    int tfcntrflag;       ///< TFCNTR present
222
    int panscanflag;      ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
223
    int extended_dmv;     ///< Additional extended dmv range at P/B frame-level
224
    int color_prim;       ///< 8bits, chroma coordinates of the color primaries
225
    int transfer_char;    ///< 8bits, Opto-electronic transfer characteristics
226
    int matrix_coef;      ///< 8bits, Color primaries->YCbCr transform matrix
227
    int hrd_param_flag;   ///< Presence of Hypothetical Reference
228
                          ///< Decoder parameters
229
    //@}
230
#endif
231

    
232

    
233
    /** Sequence header data for all Profiles
234
     * TODO: choose between ints, uint8_ts and monobit flags
235
     */
236
    //@{
237
    int profile;          ///< 2bits, Profile
238
    int frmrtq_postproc;  ///< 3bits,
239
    int bitrtq_postproc;  ///< 5bits, quantized framerate-based postprocessing strength
240
    int fastuvmc;         ///< Rounding of qpel vector to hpel ? (not in Simple)
241
    int extended_mv;      ///< Ext MV in P/B (not in Simple)
242
    int dquant;           ///< How qscale varies with MBs, 2bits (not in Simple)
243
    int vstransform;      ///< variable-size [48]x[48] transform type + info
244
    int overlap;          ///< overlapped transforms in use
245
    int quantizer_mode;   ///< 2bits, quantizer mode used for sequence, see QUANT_*
246
    int finterpflag;      ///< INTERPFRM present
247
    //@}
248

    
249
    /** Frame decoding info for all profiles */
250
    //@{
251
    uint8_t mv_mode;      ///< MV coding monde
252
    uint8_t mv_mode2;     ///< Secondary MV coding mode (B frames)
253
    int k_x;              ///< Number of bits for MVs (depends on MV range)
254
    int k_y;              ///< Number of bits for MVs (depends on MV range)
255
    uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale
256
    /** pquant parameters */
257
    //@{
258
    uint8_t dquantfrm;
259
    uint8_t dqprofile;
260
    uint8_t dqsbedge;
261
    uint8_t dqbilevel;
262
    //@}
263
    /** AC coding set indexes
264
     * @see 8.1.1.10, p(1)10
265
     */
266
    //@{
267
    int c_ac_table_index; ///< Chroma index from ACFRM element
268
    int y_ac_table_index; ///< Luma index from AC2FRM element
269
    //@}
270
    int ttfrm;            ///< Transform type info present at frame level
271
    uint8_t ttmbf;        ///< Transform type flag
272
    int ttmb;             ///< Transform type
273
    uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
274
    /** Luma compensation parameters */
275
    //@{
276
    uint8_t lumscale;
277
    uint8_t lumshift;
278
    //@}
279
    int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs
280
    uint8_t halfpq;       ///< Uniform quant over image and qp+.5
281
    uint8_t respic;       ///< Frame-level flag for resized images
282
    int buffer_fullness;  ///< HRD info
283
    /** Ranges:
284
     * -# 0 -> [-64n 63.f] x [-32, 31.f]
285
     * -# 1 -> [-128, 127.f] x [-64, 63.f]
286
     * -# 2 -> [-512, 511.f] x [-128, 127.f]
287
     * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
288
     */
289
    uint8_t mvrange;
290
    uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use
291
    uint8_t *previous_line_cbpcy; ///< To use for predicted CBPCY
292
    VLC *cbpcy_vlc;               ///< CBPCY VLC table
293
    int tt_index;                 ///< Index for Transform Type tables
294
    BitPlane mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)
295
    BitPlane skip_mb_plane;       ///< bitplane for skipped MBs
296
    BitPlane direct_mb_plane;     ///< bitplane for "direct" MBs
297

    
298
    /** Frame decoding info for S/M profiles only */
299
    //@{
300
    uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
301
    uint8_t interpfrm;
302
    //@}
303

    
304
#if HAS_ADVANCED_PROFILE
305
    /** Frame decoding info for Advanced profile */
306
    //@{
307
    uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
308
    uint8_t numpanscanwin;
309
    uint8_t tfcntr;
310
    uint8_t rptfrm, tff, rff;
311
    uint16_t topleftx;
312
    uint16_t toplefty;
313
    uint16_t bottomrightx;
314
    uint16_t bottomrighty;
315
    uint8_t uvsamp;
316
    uint8_t postproc;
317
    int hrd_num_leaky_buckets;
318
    uint8_t bit_rate_exponent;
319
    uint8_t buffer_size_exponent;
320
    BitPlane ac_pred_plane;       ///< AC prediction flags bitplane
321
    BitPlane over_flags_plane;    ///< Overflags bitplane
322
    uint8_t condover;
323
    uint16_t *hrd_rate, *hrd_buffer;
324
    uint8_t *hrd_fullness;
325
    uint8_t range_mapy_flag;
326
    uint8_t range_mapuv_flag;
327
    uint8_t range_mapy;
328
    uint8_t range_mapuv;
329
    //@}
330
#endif
331
} VC1Context;
332

    
333
/**
334
 * Get unary code of limited length
335
 * @fixme FIXME Slow and ugly
336
 * @param gb GetBitContext
337
 * @param[in] stop The bitstop value (unary code of 1's or 0's)
338
 * @param[in] len Maximum length
339
 * @return Unary length/index
340
 */
341
static int get_prefix(GetBitContext *gb, int stop, int len)
342
{
343
#if 1
344
  int i = 0, tmp = !stop;
345

    
346
  while (i != len && tmp != stop)
347
  {
348
    tmp = get_bits(gb, 1);
349
    i++;
350
  }
351
  if (i == len && tmp != stop) return len+1;
352
  return i;
353
#else
354
  unsigned int buf;
355
  int log;
356

    
357
  OPEN_READER(re, gb);
358
  UPDATE_CACHE(re, gb);
359
  buf=GET_CACHE(re, gb); //Still not sure
360
  if (stop) buf = ~buf;
361

    
362
  log= av_log2(-buf); //FIXME: -?
363
  if (log < limit){
364
    LAST_SKIP_BITS(re, gb, log+1);
365
    CLOSE_READER(re, gb);
366
    return log;
367
  }
368

    
369
  LAST_SKIP_BITS(re, gb, limit);
370
  CLOSE_READER(re, gb);
371
  return limit;
372
#endif
373
}
374

    
375
/**
376
 * Init VC-1 specific tables and VC1Context members
377
 * @param v The VC1Context to initialize
378
 * @return Status
379
 */
380
static int vc1_init_common(VC1Context *v)
381
{
382
    static int done = 0;
383
    int i = 0;
384

    
385
    /* Set the bit planes */
386
    v->mv_type_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
387
    v->direct_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
388
    v->skip_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
389
#if HAS_ADVANCED_PROFILE
390
    v->ac_pred_plane = v->over_flags_plane = (struct BitPlane) { NULL, 0, 0, 0 };
391
    v->hrd_rate = v->hrd_buffer = NULL;
392
#endif
393

    
394
    /* VLC tables */
395
#if 0 // spec -> actual tables converter
396
    for(i=0; i<64; i++){
397
        int code= (vc1_norm6_spec[i][1] << vc1_norm6_spec[i][4]) + vc1_norm6_spec[i][3];
398
        av_log(NULL, AV_LOG_DEBUG, "0x%03X, ", code);
399
        if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
400
    }
401
    for(i=0; i<64; i++){
402
        int code= vc1_norm6_spec[i][2] + vc1_norm6_spec[i][4];
403
        av_log(NULL, AV_LOG_DEBUG, "%2d, ", code);
404
        if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
405
    }
406
#endif
407
    if(!done)
408
    {
409
        done = 1;
410
        INIT_VLC(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
411
                 vc1_bfraction_bits, 1, 1,
412
                 vc1_bfraction_codes, 1, 1, 1);
413
        INIT_VLC(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
414
                 vc1_norm2_bits, 1, 1,
415
                 vc1_norm2_codes, 1, 1, 1);
416
        INIT_VLC(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
417
                 vc1_norm6_bits, 1, 1,
418
                 vc1_norm6_codes, 2, 2, 1);
419
        INIT_VLC(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
420
                 vc1_imode_bits, 1, 1,
421
                 vc1_imode_codes, 1, 1, 1);
422
        for (i=0; i<3; i++)
423
        {
424
            INIT_VLC(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
425
                     vc1_ttmb_bits[i], 1, 1,
426
                     vc1_ttmb_codes[i], 2, 2, 1);
427
            INIT_VLC(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
428
                     vc1_ttblk_bits[i], 1, 1,
429
                     vc1_ttblk_codes[i], 1, 1, 1);
430
            INIT_VLC(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
431
                     vc1_subblkpat_bits[i], 1, 1,
432
                     vc1_subblkpat_codes[i], 1, 1, 1);
433
        }
434
        for(i=0; i<4; i++)
435
        {
436
            INIT_VLC(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
437
                     vc1_4mv_block_pattern_bits[i], 1, 1,
438
                     vc1_4mv_block_pattern_codes[i], 1, 1, 1);
439
            INIT_VLC(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
440
                     vc1_cbpcy_p_bits[i], 1, 1,
441
                     vc1_cbpcy_p_codes[i], 2, 2, 1);
442
            INIT_VLC(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
443
                     vc1_mv_diff_bits[i], 1, 1,
444
                     vc1_mv_diff_codes[i], 2, 2, 1);
445
        }
446
    }
447

    
448
    /* Other defaults */
449
    v->pq = -1;
450
    v->mvrange = 0; /* 7.1.1.18, p80 */
451

    
452
    return 0;
453
}
454

    
455
#if HAS_ADVANCED_PROFILE
456
/**
457
 * Decode sequence header's Hypothetic Reference Decoder data
458
 * @see 6.2.1, p32
459
 * @param v The VC1Context to initialize
460
 * @param gb A GetBitContext initialized from AVCodecContext extra_data
461
 * @return Status
462
 */
463
static int decode_hrd(VC1Context *v, GetBitContext *gb)
464
{
465
    int i, num;
466

    
467
    num = 1 + get_bits(gb, 5);
468

    
469
    /*hrd rate*/
470
    if (v->hrd_rate || num != v->hrd_num_leaky_buckets)
471
    {
472
        av_freep(&v->hrd_rate);
473
    }
474
    if (!v->hrd_rate) v->hrd_rate = av_malloc(num*sizeof(uint16_t));
475
    if (!v->hrd_rate) return -1;
476

    
477
    /*hrd buffer*/
478
    if (v->hrd_buffer || num != v->hrd_num_leaky_buckets)
479
    {
480
        av_freep(&v->hrd_buffer);
481
    }
482
    if (!v->hrd_buffer) v->hrd_buffer = av_malloc(num*sizeof(uint16_t));
483
    if (!v->hrd_buffer)
484
    {
485
        av_freep(&v->hrd_rate);
486
        return -1;
487
    }
488

    
489
    /*hrd fullness*/
490
    if (v->hrd_fullness || num != v->hrd_num_leaky_buckets)
491
    {
492
        av_freep(&v->hrd_buffer);
493
    }
494
    if (!v->hrd_fullness) v->hrd_fullness = av_malloc(num*sizeof(uint8_t));
495
    if (!v->hrd_fullness)
496
    {
497
        av_freep(&v->hrd_rate);
498
        av_freep(&v->hrd_buffer);
499
        return -1;
500
    }
501
    v->hrd_num_leaky_buckets = num;
502

    
503
    //exponent in base-2 for rate
504
    v->bit_rate_exponent = 6 + get_bits(gb, 4);
505
    //exponent in base-2 for buffer_size
506
    v->buffer_size_exponent = 4 + get_bits(gb, 4);
507

    
508
    for (i=0; i<num; i++)
509
    {
510
        //mantissae, ordered (if not, use a function ?
511
        v->hrd_rate[i] = 1 + get_bits(gb, 16);
512
        if (i && v->hrd_rate[i-1]>=v->hrd_rate[i])
513
        {
514
            av_log(v->s.avctx, AV_LOG_ERROR, "HDR Rates aren't strictly increasing:"
515
                   "%i vs %i\n", v->hrd_rate[i-1], v->hrd_rate[i]);
516
            return -1;
517
        }
518
        v->hrd_buffer[i] = 1 + get_bits(gb, 16);
519
        if (i && v->hrd_buffer[i-1]<v->hrd_buffer[i])
520
        {
521
            av_log(v->s.avctx, AV_LOG_ERROR, "HDR Buffers aren't decreasing:"
522
                   "%i vs %i\n", v->hrd_buffer[i-1], v->hrd_buffer[i]);
523
            return -1;
524
        }
525
    }
526
    return 0;
527
}
528

    
529
/**
530
 * Decode sequence header for Advanced Profile
531
 * @see Table 2, p18
532
 * @see 6.1.7, pp21-27
533
 * @param v The VC1Context to initialize
534
 * @param gb A GetBitContext initialized from AVCodecContext extra_data
535
 * @return Status
536
 */
537
static int decode_advanced_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
538
{
539
    VC1Context *v = avctx->priv_data;
540
    int nr, dr, aspect_ratio;
541

    
542
    v->postprocflag = get_bits(gb, 1);
543
    v->broadcast = get_bits(gb, 1);
544
    v->interlace = get_bits(gb, 1);
545

    
546
    v->tfcntrflag = get_bits(gb, 1);
547
    v->finterpflag = get_bits(gb, 1); //common
548
    v->panscanflag = get_bits(gb, 1);
549
    v->reserved = get_bits(gb, 1);
550
    if (v->reserved)
551
    {
552
        av_log(avctx, AV_LOG_ERROR, "RESERVED should be 0 (is %i)\n",
553
               v->reserved);
554
        return -1;
555
    }
556
    if (v->extended_mv)
557
        v->extended_dmv = get_bits(gb, 1);
558

    
559
    /* 6.1.7, p21 */
560
    if (get_bits(gb, 1) /* pic_size_flag */)
561
    {
562
        avctx->coded_width = get_bits(gb, 12) << 1;
563
        avctx->coded_height = get_bits(gb, 12) << 1;
564
        if ( get_bits(gb, 1) /* disp_size_flag */)
565
        {
566
            avctx->width = get_bits(gb, 14);
567
            avctx->height = get_bits(gb, 14);
568
        }
569

    
570
        /* 6.1.7.4, p23 */
571
        if ( get_bits(gb, 1) /* aspect_ratio_flag */)
572
        {
573
            aspect_ratio = get_bits(gb, 4); //SAR
574
            if (aspect_ratio == 0x0F) //FF_ASPECT_EXTENDED
575
            {
576
                avctx->sample_aspect_ratio.num = 1 + get_bits(gb, 8);
577
                avctx->sample_aspect_ratio.den = 1 + get_bits(gb, 8);
578
            }
579
            else if (aspect_ratio == 0x0E)
580
            {
581
                av_log(avctx, AV_LOG_DEBUG, "Reserved AR found\n");
582
            }
583
            else
584
            {
585
              avctx->sample_aspect_ratio = vc1_pixel_aspect[aspect_ratio];
586
            }
587
        }
588
    }
589
    else
590
    {
591
        avctx->coded_width = avctx->width;
592
        avctx->coded_height = avctx->height;
593
    }
594

    
595
    /* 6.1.8, p23 */
596
    if ( get_bits(gb, 1) /* framerateflag */)
597
    {
598
        if ( !get_bits(gb, 1) /* framerateind */)
599
        {
600
            nr = get_bits(gb, 8);
601
            dr = get_bits(gb, 4);
602
            if (nr<1)
603
            {
604
                av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATENR\n");
605
                return -1;
606
            }
607
            if (nr>5)
608
            {
609
                av_log(avctx, AV_LOG_ERROR,
610
                       "Reserved FRAMERATENR %i not handled\n", nr);
611
                nr = 5; /* overflow protection */
612
            }
613
            if (dr<1)
614
            {
615
                av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATEDR\n");
616
                return -1;
617
            }
618
            if (dr>2)
619
            {
620
                av_log(avctx, AV_LOG_ERROR,
621
                       "Reserved FRAMERATEDR %i not handled\n", dr);
622
                dr = 2; /* overflow protection */
623
            }
624
            avctx->time_base.num = fps_nr[dr - 1];
625
            avctx->time_base.den = fps_nr[nr - 1];
626
        }
627
        else
628
        {
629
            nr = get_bits(gb, 16);
630
            // 0.03125->2048Hz / 0.03125Hz
631
            avctx->time_base.den = 1000000;
632
            avctx->time_base.num = 31250*(1+nr);
633
        }
634
    }
635

    
636
    /* 6.1.9, p25 */
637
    if ( get_bits(gb, 1) /* color_format_flag */)
638
    {
639
        //Chromacity coordinates of color primaries
640
        //like ITU-R BT.709-2, BT.470-2, ...
641
        v->color_prim = get_bits(gb, 8);
642
        if (v->color_prim<1)
643
        {
644
            av_log(avctx, AV_LOG_ERROR, "0 for COLOR_PRIM is forbidden\n");
645
            return -1;
646
        }
647
        if (v->color_prim == 3 || v->color_prim>6)
648
        {
649
            av_log(avctx, AV_LOG_DEBUG, "Reserved COLOR_PRIM %i found\n",
650
                   v->color_prim);
651
            return -1;
652
        }
653

    
654
        //Opto-electronic transfer characteristics
655
        v->transfer_char = get_bits(gb, 8);
656
        if (v->transfer_char < 1)
657
        {
658
            av_log(avctx, AV_LOG_ERROR, "0 for TRAMSFER_CHAR is forbidden\n");
659
            return -1;
660
        }
661
        if (v->transfer_char == 3 || v->transfer_char>8)
662
        {
663
            av_log(avctx, AV_LOG_DEBUG, "Reserved TRANSFERT_CHAR %i found\n",
664
                   v->color_prim);
665
            return -1;
666
        }
667

    
668
        //Matrix coefficient for primariev->YCbCr
669
        v->matrix_coef = get_bits(gb, 8);
670
        if (v->matrix_coef < 1)
671
        {
672
            av_log(avctx, AV_LOG_ERROR, "0 for MATRIX_COEF is forbidden\n");
673
            return -1;
674
        }
675
        if ((v->matrix_coef > 2 && v->matrix_coef < 6) || v->matrix_coef > 7)
676
        {
677
            av_log(avctx, AV_LOG_DEBUG, "Reserved MATRIX_COEF %i found\n",
678
                   v->color_prim);
679
            return -1;
680
        }
681
    }
682

    
683
    //Hypothetical reference decoder indicator flag
684
    v->hrd_param_flag = get_bits(gb, 1);
685
    if (v->hrd_param_flag)
686
    {
687
      if (decode_hrd(v, gb) < 0) return -1;
688
    }
689

    
690
    /*reset scaling ranges, 6.2.2 & 6.2.3, p33*/
691
    v->range_mapy_flag = 0;
692
    v->range_mapuv_flag = 0;
693

    
694
    av_log(avctx, AV_LOG_DEBUG, "Advanced profile not supported yet\n");
695
    return -1;
696
}
697
#endif
698

    
699
/**
700
 * Decode Simple/Main Profiles sequence header
701
 * @see Figure 7-8, p16-17
702
 * @param avctx Codec context
703
 * @param gb GetBit context initialized from Codec context extra_data
704
 * @return Status
705
 */
706
static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
707
{
708
    VC1Context *v = avctx->priv_data;
709

    
710
    av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
711
    v->profile = get_bits(gb, 2);
712
    if (v->profile == 2)
713
    {
714
        av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden\n");
715
        return -1;
716
    }
717

    
718
#if HAS_ADVANCED_PROFILE
719
    if (v->profile == PROFILE_ADVANCED)
720
    {
721
        v->level = get_bits(gb, 3);
722
        if(v->level >= 5)
723
        {
724
            av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
725
        }
726
        v->chromaformat = get_bits(gb, 2);
727
        if (v->chromaformat != 1)
728
        {
729
            av_log(avctx, AV_LOG_ERROR,
730
                   "Only 4:2:0 chroma format supported\n");
731
            return -1;
732
        }
733
    }
734
    else
735
#endif
736
    {
737
        v->res_sm = get_bits(gb, 2); //reserved
738
        if (v->res_sm)
739
        {
740
            av_log(avctx, AV_LOG_ERROR,
741
                   "Reserved RES_SM=%i is forbidden\n", v->res_sm);
742
            return -1;
743
        }
744
    }
745

    
746
    // (fps-2)/4 (->30)
747
    v->frmrtq_postproc = get_bits(gb, 3); //common
748
    // (bitrate-32kbps)/64kbps
749
    v->bitrtq_postproc = get_bits(gb, 5); //common
750
    v->s.loop_filter = get_bits(gb, 1); //common
751
    if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
752
    {
753
        av_log(avctx, AV_LOG_ERROR,
754
               "LOOPFILTER shell not be enabled in simple profile\n");
755
    }
756

    
757
#if HAS_ADVANCED_PROFILE
758
    if (v->profile < PROFILE_ADVANCED)
759
#endif
760
    {
761
        v->res_x8 = get_bits(gb, 1); //reserved
762
        if (v->res_x8)
763
        {
764
            av_log(avctx, AV_LOG_ERROR,
765
                   "1 for reserved RES_X8 is forbidden\n");
766
            //return -1;
767
        }
768
        v->multires = get_bits(gb, 1);
769
        v->res_fasttx = get_bits(gb, 1);
770
        if (!v->res_fasttx)
771
        {
772
            av_log(avctx, AV_LOG_ERROR,
773
                   "0 for reserved RES_FASTTX is forbidden\n");
774
            //return -1;
775
        }
776
    }
777

    
778
    v->fastuvmc =  get_bits(gb, 1); //common
779
    if (!v->profile && !v->fastuvmc)
780
    {
781
        av_log(avctx, AV_LOG_ERROR,
782
               "FASTUVMC unavailable in Simple Profile\n");
783
        return -1;
784
    }
785
    v->extended_mv =  get_bits(gb, 1); //common
786
    if (!v->profile && v->extended_mv)
787
    {
788
        av_log(avctx, AV_LOG_ERROR,
789
               "Extended MVs unavailable in Simple Profile\n");
790
        return -1;
791
    }
792
    v->dquant =  get_bits(gb, 2); //common
793
    v->vstransform =  get_bits(gb, 1); //common
794

    
795
#if HAS_ADVANCED_PROFILE
796
    if (v->profile < PROFILE_ADVANCED)
797
#endif
798
    {
799
        v->res_transtab = get_bits(gb, 1);
800
        if (v->res_transtab)
801
        {
802
            av_log(avctx, AV_LOG_ERROR,
803
                   "1 for reserved RES_TRANSTAB is forbidden\n");
804
            return -1;
805
        }
806
    }
807

    
808
    v->overlap = get_bits(gb, 1); //common
809

    
810
#if HAS_ADVANCED_PROFILE
811
    if (v->profile < PROFILE_ADVANCED)
812
#endif
813
    {
814
        v->s.resync_marker = get_bits(gb, 1);
815
        v->rangered = get_bits(gb, 1);
816
        if (v->rangered && v->profile == PROFILE_SIMPLE)
817
        {
818
            av_log(avctx, AV_LOG_DEBUG,
819
                   "RANGERED should be set to 0 in simple profile\n");
820
        }
821
    }
822

    
823
    v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
824
    v->quantizer_mode = get_bits(gb, 2); //common
825

    
826
#if HAS_ADVANCED_PROFILE
827
    if (v->profile < PROFILE_ADVANCED)
828
#endif
829
    {
830
        v->finterpflag = get_bits(gb, 1); //common
831
        v->res_rtm_flag = get_bits(gb, 1); //reserved
832
        if (!v->res_rtm_flag)
833
        {
834
            av_log(avctx, AV_LOG_ERROR,
835
                   "0 for reserved RES_RTM_FLAG is forbidden\n");
836
            //return -1;
837
        }
838
#if TRACE
839
        av_log(avctx, AV_LOG_INFO,
840
               "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
841
               "LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"
842
               "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
843
               "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
844
               v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
845
               v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
846
               v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
847
               v->dquant, v->quantizer_mode, avctx->max_b_frames
848
               );
849
        return 0;
850
#endif
851
    }
852
#if HAS_ADVANCED_PROFILE
853
    else return decode_advanced_sequence_header(avctx, gb);
854
#endif
855
}
856

    
857

    
858
#if HAS_ADVANCED_PROFILE
859
/** Entry point decoding (Advanced Profile)
860
 * @param avctx Codec context
861
 * @param gb GetBit context initialized from avctx->extra_data
862
 * @return Status
863
 */
864
static int advanced_entry_point_process(AVCodecContext *avctx, GetBitContext *gb)
865
{
866
    VC1Context *v = avctx->priv_data;
867
    int i;
868
    if (v->profile != PROFILE_ADVANCED)
869
    {
870
        av_log(avctx, AV_LOG_ERROR,
871
               "Entry point are only defined in Advanced Profile!\n");
872
        return -1; //Only for advanced profile!
873
    }
874
    if (v->hrd_param_flag)
875
    {
876
        //Update buffer fullness
877
        av_log(avctx, AV_LOG_DEBUG, "Buffer fullness update\n");
878
        assert(v->hrd_num_leaky_buckets > 0);
879
        for (i=0; i<v->hrd_num_leaky_buckets; i++)
880
            v->hrd_fullness[i] = get_bits(gb, 8);
881
    }
882
    if ((v->range_mapy_flag = get_bits(gb, 1)))
883
    {
884
        //RANGE_MAPY
885
        av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPY\n");
886
        v->range_mapy = get_bits(gb, 3);
887
    }
888
    if ((v->range_mapuv_flag = get_bits(gb, 1)))
889
    {
890
        //RANGE_MAPUV
891
        av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPUV\n");
892
        v->range_mapuv = get_bits(gb, 3);
893
    }
894
    if (v->panscanflag)
895
    {
896
        //NUMPANSCANWIN
897
        v->numpanscanwin = get_bits(gb, 3);
898
        av_log(avctx, AV_LOG_DEBUG, "NUMPANSCANWIN: %u\n", v->numpanscanwin);
899
    }
900
    return 0;
901
}
902
#endif
903

    
904
/***********************************************************************/
905
/**
906
 * @defgroup bitplane VC1 Bitplane decoding
907
 * @see 8.7, p56
908
 * @{
909
 */
910

    
911
/** @addtogroup bitplane
912
 * Imode types
913
 * @{
914
 */
915
#define IMODE_RAW     0
916
#define IMODE_NORM2   1
917
#define IMODE_DIFF2   2
918
#define IMODE_NORM6   3
919
#define IMODE_DIFF6   4
920
#define IMODE_ROWSKIP 5
921
#define IMODE_COLSKIP 6
922
/** @} */ //imode defines
923

    
924
/** Allocate the buffer from a bitplane, given its dimensions
925
 * @param bp Bitplane which buffer is to allocate
926
 * @param[in] width Width of the buffer
927
 * @param[in] height Height of the buffer
928
 * @return Status
929
 * @todo TODO: Take into account stride
930
 * @todo TODO: Allow use of external buffers ?
931
 */
932
static int alloc_bitplane(BitPlane *bp, int width, int height)
933
{
934
    if (!bp || bp->width<0 || bp->height<0) return -1;
935
    bp->data = (uint8_t*)av_malloc(width*height);
936
    if (!bp->data) return -1;
937
    bp->width = bp->stride = width;
938
    bp->height = height;
939
    return 0;
940
}
941

    
942
/** Free the bitplane's buffer
943
 * @param bp Bitplane which buffer is to free
944
 */
945
static void free_bitplane(BitPlane *bp)
946
{
947
    bp->width = bp->stride = bp->height = 0;
948
    if (bp->data) av_freep(&bp->data);
949
}
950

    
951
/** Decode rows by checking if they are skipped
952
 * @param plane Buffer to store decoded bits
953
 * @param[in] width Width of this buffer
954
 * @param[in] height Height of this buffer
955
 * @param[in] stride of this buffer
956
 */
957
static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
958
    int x, y;
959

    
960
    for (y=0; y<height; y++){
961
        if (!get_bits(gb, 1)) //rowskip
962
            memset(plane, 0, width);
963
        else
964
            for (x=0; x<width; x++)
965
                plane[x] = get_bits(gb, 1);
966
        plane += stride;
967
    }
968
}
969

    
970
/** Decode columns by checking if they are skipped
971
 * @param plane Buffer to store decoded bits
972
 * @param[in] width Width of this buffer
973
 * @param[in] height Height of this buffer
974
 * @param[in] stride of this buffer
975
 * @fixme FIXME: Optimize
976
 */
977
static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
978
    int x, y;
979

    
980
    for (x=0; x<width; x++){
981
        if (!get_bits(gb, 1)) //colskip
982
            for (y=0; y<height; y++)
983
                plane[y*stride] = 0;
984
        else
985
            for (y=0; y<height; y++)
986
                plane[y*stride] = get_bits(gb, 1);
987
        plane ++;
988
    }
989
}
990

    
991
/** Decode a bitplane's bits
992
 * @param bp Bitplane where to store the decode bits
993
 * @param v VC1 context for bit reading and logging
994
 * @return Status
995
 * @fixme FIXME: Optimize
996
 * @todo TODO: Decide if a struct is needed
997
 */
998
static int bitplane_decoding(BitPlane *bp, VC1Context *v)
999
{
1000
    GetBitContext *gb = &v->s.gb;
1001

    
1002
    int imode, x, y, code, use_vertical_tile, tile_w, tile_h, offset;
1003
    uint8_t invert, *planep = bp->data;
1004

    
1005
    invert = get_bits(gb, 1);
1006
    imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 2);
1007

    
1008
    bp->is_raw = 0;
1009
    switch (imode)
1010
    {
1011
    case IMODE_RAW:
1012
        //Data is actually read in the MB layer (same for all tests == "raw")
1013
        bp->is_raw = 1; //invert ignored
1014
        return invert;
1015
    case IMODE_DIFF2:
1016
    case IMODE_NORM2:
1017
        if ((bp->height*bp->width) & 1)
1018
        {
1019
            *(++planep) = get_bits(gb, 1);
1020
            offset = x = 1;
1021
        }
1022
        else offset = x = 0;
1023

    
1024
        for (y=0; y<bp->height; y++)
1025
        {
1026
            for(; x<bp->width; x+=2)
1027
            {
1028
                code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 2);
1029
                *(++planep) = code&1; //lsb => left
1030
                *(++planep) = (code>>1)&1; //msb => right
1031
            }
1032
            planep += bp->stride-bp->width;
1033
            if ((bp->width-offset)&1) //Odd number previously processed
1034
            {
1035
                code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 2);
1036
                *planep = code&1;
1037
                planep += bp->stride-bp->width;
1038
                *planep = (code>>1)&1; //msb => right
1039
                offset = x = 1;
1040
            }
1041
            else
1042
            {
1043
                offset = x = 0;
1044
                planep += bp->stride-bp->width;
1045
            }
1046
        }
1047
        break;
1048
    case IMODE_DIFF6:
1049
    case IMODE_NORM6:
1050
        use_vertical_tile=  bp->height%3==0 &&  bp->width%3!=0;
1051
        tile_w= use_vertical_tile ? 2 : 3;
1052
        tile_h= use_vertical_tile ? 3 : 2;
1053

    
1054
        for(y=  bp->height%tile_h; y< bp->height; y+=tile_h){
1055
            for(x=  bp->width%tile_w; x< bp->width; x+=tile_w){
1056
                code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
1057
                if(code<0){
1058
                    av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
1059
                    return -1;
1060
                }
1061
                //FIXME following is a pure guess and probably wrong
1062
                //FIXME A bitplane (0 | !0), so could the shifts be avoided ?
1063
                planep[x     + 0*bp->stride]= (code>>0)&1;
1064
                planep[x + 1 + 0*bp->stride]= (code>>1)&1;
1065
                //FIXME Does branch prediction help here?
1066
                if(use_vertical_tile){
1067
                    planep[x + 0 + 1*bp->stride]= (code>>2)&1;
1068
                    planep[x + 1 + 1*bp->stride]= (code>>3)&1;
1069
                    planep[x + 0 + 2*bp->stride]= (code>>4)&1;
1070
                    planep[x + 1 + 2*bp->stride]= (code>>5)&1;
1071
                }else{
1072
                    planep[x + 2 + 0*bp->stride]= (code>>2)&1;
1073
                    planep[x + 0 + 1*bp->stride]= (code>>3)&1;
1074
                    planep[x + 1 + 1*bp->stride]= (code>>4)&1;
1075
                    planep[x + 2 + 1*bp->stride]= (code>>5)&1;
1076
                }
1077
            }
1078
        }
1079

    
1080
        x=  bp->width % tile_w;
1081
        decode_colskip(bp->data  ,             x, bp->height         , bp->stride, &v->s.gb);
1082
        decode_rowskip(bp->data+x, bp->width - x, bp->height % tile_h, bp->stride, &v->s.gb);
1083

    
1084
        break;
1085
    case IMODE_ROWSKIP:
1086
        decode_rowskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
1087
        break;
1088
    case IMODE_COLSKIP:
1089
        decode_colskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
1090
        break;
1091
    default: break;
1092
    }
1093

    
1094
    /* Applying diff operator */
1095
    if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
1096
    {
1097
        planep = bp->data;
1098
        planep[0] ^= invert;
1099
        for (x=1; x<bp->width; x++)
1100
            planep[x] ^= planep[x-1];
1101
        for (y=1; y<bp->height; y++)
1102
        {
1103
            planep += bp->stride;
1104
            planep[0] ^= planep[-bp->stride];
1105
            for (x=1; x<bp->width; x++)
1106
            {
1107
                if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;
1108
                else                                     planep[x] ^= planep[x-1];
1109
            }
1110
        }
1111
    }
1112
    else if (invert)
1113
    {
1114
        planep = bp->data;
1115
        for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride
1116
    }
1117
    return (imode<<1) + invert;
1118
}
1119
/** @} */ //Bitplane group
1120

    
1121
/***********************************************************************/
1122
/** VOP Dquant decoding
1123
 * @param v VC1 Context
1124
 */
1125
static int vop_dquant_decoding(VC1Context *v)
1126
{
1127
    GetBitContext *gb = &v->s.gb;
1128
    int pqdiff;
1129

    
1130
    //variable size
1131
    if (v->dquant == 2)
1132
    {
1133
        pqdiff = get_bits(gb, 3);
1134
        if (pqdiff == 7) v->altpq = get_bits(gb, 5);
1135
        else v->altpq = v->pq + pqdiff + 1;
1136
    }
1137
    else
1138
    {
1139
        v->dquantfrm = get_bits(gb, 1);
1140
        if ( v->dquantfrm )
1141
        {
1142
            v->dqprofile = get_bits(gb, 2);
1143
            switch (v->dqprofile)
1144
            {
1145
            case DQPROFILE_SINGLE_EDGE:
1146
            case DQPROFILE_DOUBLE_EDGES:
1147
                v->dqsbedge = get_bits(gb, 2);
1148
                break;
1149
            case DQPROFILE_ALL_MBS:
1150
                v->dqbilevel = get_bits(gb, 1);
1151
            default: break; //Forbidden ?
1152
            }
1153
            if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
1154
            {
1155
                pqdiff = get_bits(gb, 3);
1156
                if (pqdiff == 7) v->altpq = get_bits(gb, 5);
1157
                else v->altpq = v->pq + pqdiff + 1;
1158
            }
1159
        }
1160
    }
1161
    return 0;
1162
}
1163

    
1164
/***********************************************************************/
1165
/**
1166
 * @defgroup all_frame_hdr All VC1 profiles frame header
1167
 * @brief Part of the frame header decoding from all profiles
1168
 * @warning Only pro/epilog differs between Simple/Main and Advanced => check caller
1169
 * @{
1170
 */
1171
/** B and BI frame header decoding, primary part
1172
 * @see Tables 11+12, p62-65
1173
 * @param v VC1 context
1174
 * @return Status
1175
 * @warning Also handles BI frames
1176
 */
1177
static int decode_b_picture_primary_header(VC1Context *v)
1178
{
1179
    GetBitContext *gb = &v->s.gb;
1180
    int pqindex;
1181

    
1182
    /* Prolog common to all frametypes should be done in caller */
1183
    if (v->profile == PROFILE_SIMPLE)
1184
    {
1185
        av_log(v->s.avctx, AV_LOG_ERROR, "Found a B frame while in Simple Profile!\n");
1186
        return FRAME_SKIPPED;
1187
    }
1188
    v->bfraction = vc1_bfraction_lut[get_vlc2(gb, vc1_bfraction_vlc.table,
1189
                                              VC1_BFRACTION_VLC_BITS, 2)];
1190
    if (v->bfraction < -1)
1191
    {
1192
        av_log(v->s.avctx, AV_LOG_ERROR, "Invalid BFRaction\n");
1193
        return FRAME_SKIPPED;
1194
    }
1195
    else if (!v->bfraction)
1196
    {
1197
        /* We actually have a BI frame */
1198
        v->s.pict_type = BI_TYPE;
1199
        v->buffer_fullness = get_bits(gb, 7);
1200
    }
1201

    
1202
    /* Read the quantization stuff */
1203
    pqindex = get_bits(gb, 5);
1204
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1205
        v->pq = pquant_table[0][pqindex];
1206
    else
1207
    {
1208
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1209
    }
1210
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1211
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1212
        v->pquantizer = get_bits(gb, 1);
1213
#if HAS_ADVANCED_PROFILE
1214
    if (v->profile == PROFILE_ADVANCED)
1215
    {
1216
        if (v->postprocflag) v->postproc = get_bits(gb, 2);
1217
        if (v->extended_mv == 1 && v->s.pict_type != BI_TYPE)
1218
            v->mvrange = get_prefix(gb, 0, 3);
1219
    }
1220
#endif
1221
    else
1222
    {
1223
        if (v->extended_mv == 1)
1224
            v->mvrange = get_prefix(gb, 0, 3);
1225
    }
1226
    /* Read the MV mode */
1227
    if (v->s.pict_type != BI_TYPE)
1228
    {
1229
        v->mv_mode = get_bits(gb, 1);
1230
        if (v->pq < 13)
1231
        {
1232
            if (!v->mv_mode)
1233
            {
1234
                v->mv_mode = get_bits(gb, 2);
1235
                if (v->mv_mode)
1236
                av_log(v->s.avctx, AV_LOG_ERROR,
1237
                       "mv_mode for lowquant B frame was %i\n", v->mv_mode);
1238
            }
1239
        }
1240
        else
1241
        {
1242
            if (!v->mv_mode)
1243
            {
1244
                if (get_bits(gb, 1))
1245
                     av_log(v->s.avctx, AV_LOG_ERROR,
1246
                            "mv_mode for highquant B frame was %i\n", v->mv_mode);
1247
            }
1248
            v->mv_mode = 1-v->mv_mode; //To match (pq < 13) mapping
1249
        }
1250
    }
1251

    
1252
    return 0;
1253
}
1254

    
1255
/** B and BI frame header decoding, secondary part
1256
 * @see Tables 11+12, p62-65
1257
 * @param v VC1 context
1258
 * @return Status
1259
 * @warning Also handles BI frames
1260
 * @warning To call once all MB arrays are allocated
1261
 * @todo Support Advanced Profile headers
1262
 */
1263
static int decode_b_picture_secondary_header(VC1Context *v)
1264
{
1265
    GetBitContext *gb = &v->s.gb;
1266
    int status;
1267

    
1268
    status = bitplane_decoding(&v->skip_mb_plane, v);
1269
    if (status < 0) return -1;
1270
#if TRACE
1271
    if (v->mv_mode == MV_PMODE_MIXED_MV)
1272
    {
1273
        status = bitplane_decoding(&v->mv_type_mb_plane, v);
1274
        if (status < 0)
1275
            return -1;
1276
#if TRACE
1277
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1278
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1279
#endif
1280
    }
1281

    
1282
    //bitplane
1283
    status = bitplane_decoding(&v->direct_mb_plane, v);
1284
    if (status < 0) return -1;
1285
#if TRACE
1286
    av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct plane encoding: "
1287
           "Imode: %i, Invert: %i\n", status>>1, status&1);
1288
#endif
1289

    
1290
    av_log(v->s.avctx, AV_LOG_DEBUG, "Skip MB plane encoding: "
1291
           "Imode: %i, Invert: %i\n", status>>1, status&1);
1292
#endif
1293

    
1294
    /* FIXME: what is actually chosen for B frames ? */
1295
    v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1296
    v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1297

    
1298
    if (v->dquant)
1299
    {
1300
        vop_dquant_decoding(v);
1301
    }
1302

    
1303
    if (v->vstransform)
1304
    {
1305
        v->ttmbf = get_bits(gb, 1);
1306
        if (v->ttmbf)
1307
        {
1308
            v->ttfrm = get_bits(gb, 2);
1309
            av_log(v->s.avctx, AV_LOG_INFO, "Transform used: %ix%i\n",
1310
                   (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);
1311
        }
1312
    }
1313
    /* Epilog (AC/DC syntax) should be done in caller */
1314
    return 0;
1315
}
1316

    
1317
/** I frame header decoding, primary part
1318
 * @see Tables 5+7, p53-54 and 55-57
1319
 * @param v VC1 context
1320
 * @return Status
1321
 * @todo Support Advanced Profile headers
1322
 */
1323
static int decode_i_picture_primary_header(VC1Context *v)
1324
{
1325
    GetBitContext *gb = &v->s.gb;
1326
    int pqindex;
1327

    
1328
    /* Prolog common to all frametypes should be done in caller */
1329
    //BF = Buffer Fullness
1330
    if (v->profile < PROFILE_ADVANCED && get_bits(gb, 7))
1331
    {
1332
        av_log(v->s.avctx, AV_LOG_DEBUG, "I BufferFullness not 0\n");
1333
    }
1334

    
1335
    /* Quantizer stuff */
1336
    pqindex = get_bits(gb, 5);
1337
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1338
        v->pq = pquant_table[0][pqindex];
1339
    else
1340
    {
1341
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1342
    }
1343
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1344
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1345
        v->pquantizer = get_bits(gb, 1);
1346
    av_log(v->s.avctx, AV_LOG_DEBUG, "I frame: QP=%i (+%i/2)\n",
1347
           v->pq, v->halfpq);
1348
    return 0;
1349
}
1350

    
1351
/** I frame header decoding, secondary part
1352
 * @param v VC1 context
1353
 * @return Status
1354
 * @warning Not called in A/S/C profiles, it seems
1355
 * @todo Support Advanced Profile headers
1356
 */
1357
static int decode_i_picture_secondary_header(VC1Context *v)
1358
{
1359
#if HAS_ADVANCED_PROFILE
1360
    int status;
1361
    if (v->profile == PROFILE_ADVANCED)
1362
    {
1363
        v->s.ac_pred = get_bits(&v->s.gb, 1);
1364
        if (v->postprocflag) v->postproc = get_bits(&v->s.gb, 1);
1365
        /* 7.1.1.34 + 8.5.2 */
1366
        if (v->overlap && v->pq<9)
1367
        {
1368
            v->condover = get_bits(&v->s.gb, 1);
1369
            if (v->condover)
1370
            {
1371
                v->condover = 2+get_bits(&v->s.gb, 1);
1372
                if (v->condover == 3)
1373
                {
1374
                    status = bitplane_decoding(&v->over_flags_plane, v);
1375
                    if (status < 0) return -1;
1376
#  if TRACE
1377
                    av_log(v->s.avctx, AV_LOG_DEBUG, "Overflags plane encoding: "
1378
                           "Imode: %i, Invert: %i\n", status>>1, status&1);
1379
#  endif
1380
                }
1381
            }
1382
        }
1383
    }
1384
#endif
1385

    
1386
    /* Epilog (AC/DC syntax) should be done in caller */
1387
    return 0;
1388
}
1389

    
1390
/** P frame header decoding, primary part
1391
 * @see Tables 5+7, p53-54 and 55-57
1392
 * @param v VC1 context
1393
 * @todo Support Advanced Profile headers
1394
 * @return Status
1395
 */
1396
static int decode_p_picture_primary_header(VC1Context *v)
1397
{
1398
    /* INTERFRM, FRMCNT, RANGEREDFRM read in caller */
1399
    GetBitContext *gb = &v->s.gb;
1400
    int lowquant, pqindex;
1401

    
1402
    pqindex = get_bits(gb, 5);
1403
    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1404
        v->pq = pquant_table[0][pqindex];
1405
    else
1406
    {
1407
        v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1408
    }
1409
    if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1410
    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1411
        v->pquantizer = get_bits(gb, 1);
1412
    av_log(v->s.avctx, AV_LOG_DEBUG, "P Frame: QP=%i (+%i/2)\n",
1413
           v->pq, v->halfpq);
1414
    if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1415
#if HAS_ADVANCED_PROFILE
1416
    if (v->profile == PROFILE_ADVANCED)
1417
    {
1418
        if (v->postprocflag) v->postproc = get_bits(gb, 1);
1419
    }
1420
    else
1421
#endif
1422
        if (v->multires) v->respic = get_bits(gb, 2);
1423
    lowquant = (v->pquantizer>12) ? 0 : 1;
1424
    v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1425
    if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1426
    {
1427
        v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];
1428
        v->lumscale = get_bits(gb, 6);
1429
        v->lumshift = get_bits(gb, 6);
1430
    }
1431
    return 0;
1432
}
1433

    
1434
/** P frame header decoding, secondary part
1435
 * @see Tables 5+7, p53-54 and 55-57
1436
 * @param v VC1 context
1437
 * @warning To call once all MB arrays are allocated
1438
 * @return Status
1439
 */
1440
static int decode_p_picture_secondary_header(VC1Context *v)
1441
{
1442
    GetBitContext *gb = &v->s.gb;
1443
    int status = 0;
1444
    if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1445
         v->mv_mode2 == MV_PMODE_MIXED_MV)
1446
        || v->mv_mode == MV_PMODE_MIXED_MV)
1447
    {
1448
        status = bitplane_decoding(&v->mv_type_mb_plane, v);
1449
        if (status < 0) return -1;
1450
#if TRACE
1451
        av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1452
               "Imode: %i, Invert: %i\n", status>>1, status&1);
1453
#endif
1454
    }
1455

    
1456
    status = bitplane_decoding(&v->skip_mb_plane, v);
1457
    if (status < 0) return -1;
1458
#if TRACE
1459
    av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1460
           "Imode: %i, Invert: %i\n", status>>1, status&1);
1461
#endif
1462

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

    
1467
    if (v->dquant)
1468
    {
1469
        av_log(v->s.avctx, AV_LOG_INFO, "VOP DQuant info\n");
1470
        vop_dquant_decoding(v);
1471
    }
1472

    
1473
    v->ttfrm = 0; //FIXME Is that so ?
1474
    if (v->vstransform)
1475
    {
1476
        v->ttmbf = get_bits(gb, 1);
1477
        if (v->ttmbf)
1478
        {
1479
            v->ttfrm = get_bits(gb, 2);
1480
            av_log(v->s.avctx, AV_LOG_INFO, "Transform used: %ix%i\n",
1481
                   (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);
1482
        }
1483
    }
1484
    /* Epilog (AC/DC syntax) should be done in caller */
1485
    return 0;
1486
}
1487
/** @} */ //End of group all_frm_hdr
1488

    
1489

    
1490
/***********************************************************************/
1491
/**
1492
 * @defgroup std_frame_hdr VC1 Simple/Main Profiles header decoding
1493
 * @brief Part of the frame header decoding belonging to Simple/Main Profiles
1494
 * @warning Only pro/epilog differs between Simple/Main and Advanced =>
1495
 *          check caller
1496
 * @{
1497
 */
1498

    
1499
/** Frame header decoding, first part, in Simple and Main profiles
1500
 * @see Tables 5+7, p53-54 and 55-57
1501
 * @param v VC1 context
1502
 * @todo FIXME: RANGEREDFRM element not read if BI frame from Table6, P54
1503
 *              However, 7.1.1.8 says "all frame types, for main profiles"
1504
 * @return Status
1505
 */
1506
static int standard_decode_picture_primary_header(VC1Context *v)
1507
{
1508
    GetBitContext *gb = &v->s.gb;
1509
    int status = 0;
1510

    
1511
    if (v->finterpflag) v->interpfrm = get_bits(gb, 1);
1512
    skip_bits(gb, 2); //framecnt unused
1513
    if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1514
    v->s.pict_type = get_bits(gb, 1);
1515
    if (v->s.avctx->max_b_frames)
1516
    {
1517
        if (!v->s.pict_type)
1518
        {
1519
            if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1520
            else v->s.pict_type = B_TYPE;
1521
        }
1522
        else v->s.pict_type = P_TYPE;
1523
    }
1524
    else v->s.pict_type++;
1525

    
1526
    switch (v->s.pict_type)
1527
    {
1528
    case I_TYPE: status = decode_i_picture_primary_header(v); break;
1529
    case P_TYPE: status = decode_p_picture_primary_header(v); break;
1530
    case BI_TYPE: //Same as B
1531
    case B_TYPE: status = decode_b_picture_primary_header(v); break;
1532
    }
1533

    
1534
    if (status == FRAME_SKIPPED)
1535
    {
1536
      av_log(v->s.avctx, AV_LOG_INFO, "Skipping frame...\n");
1537
      return status;
1538
    }
1539
    return 0;
1540
}
1541

    
1542
/** Frame header decoding, secondary part
1543
 * @param v VC1 context
1544
 * @warning To call once all MB arrays are allocated
1545
 * @return Status
1546
 */
1547
static int standard_decode_picture_secondary_header(VC1Context *v)
1548
{
1549
    GetBitContext *gb = &v->s.gb;
1550
    int status = 0;
1551

    
1552
    switch (v->s.pict_type)
1553
    {
1554
    case P_TYPE: status = decode_p_picture_secondary_header(v); break;
1555
    case B_TYPE: status = decode_b_picture_secondary_header(v); break;
1556
    case BI_TYPE:
1557
    case I_TYPE: break; //Nothing needed as it's done in the epilog
1558
    }
1559
    if (status < 0) return FRAME_SKIPPED;
1560

    
1561
    /* AC Syntax */
1562
    v->c_ac_table_index = decode012(gb);
1563
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1564
    {
1565
        v->y_ac_table_index = decode012(gb);
1566
    }
1567
    /* DC Syntax */
1568
    v->s.dc_table_index = decode012(gb);
1569

    
1570
    return 0;
1571
}
1572
/** @} */ //End for group std_frame_hdr
1573

    
1574
#if HAS_ADVANCED_PROFILE
1575
/***********************************************************************/
1576
/**
1577
 * @defgroup adv_frame_hdr VC1 Advanced Profile header decoding
1578
 * @brief Part of the frame header decoding belonging to Advanced Profiles
1579
 * @warning Only pro/epilog differs between Simple/Main and Advanced =>
1580
 *          check caller
1581
 * @{
1582
 */
1583
/** Frame header decoding, primary part
1584
 * @param v VC1 context
1585
 * @return Status
1586
 */
1587
static int advanced_decode_picture_primary_header(VC1Context *v)
1588
{
1589
    GetBitContext *gb = &v->s.gb;
1590
    static const int type_table[4] = { P_TYPE, B_TYPE, I_TYPE, BI_TYPE };
1591
    int type;
1592

    
1593
    if (v->interlace)
1594
    {
1595
        v->fcm = get_bits(gb, 1);
1596
        if (v->fcm) v->fcm = 2+get_bits(gb, 1);
1597
    }
1598

    
1599
    type = get_prefix(gb, 0, 4);
1600
    if (type > 4 || type < 0) return FRAME_SKIPPED;
1601
    v->s.pict_type = type_table[type];
1602
    av_log(v->s.avctx, AV_LOG_INFO, "AP Frame Type: %i\n", v->s.pict_type);
1603

    
1604
    if (v->tfcntrflag) v->tfcntr = get_bits(gb, 8);
1605
    if (v->broadcast)
1606
    {
1607
        if (!v->interlace) v->rptfrm = get_bits(gb, 2);
1608
        else
1609
        {
1610
            v->tff = get_bits(gb, 1);
1611
            v->rff = get_bits(gb, 1);
1612
        }
1613
    }
1614

    
1615
    if (v->panscanflag)
1616
    {
1617
#if 0
1618
        for (i=0; i<v->numpanscanwin; i++)
1619
        {
1620
            v->topleftx[i] = get_bits(gb, 16);
1621
            v->toplefty[i] = get_bits(gb, 16);
1622
            v->bottomrightx[i] = get_bits(gb, 16);
1623
            v->bottomrighty[i] = get_bits(gb, 16);
1624
        }
1625
#else
1626
        skip_bits(gb, 16*4*v->numpanscanwin);
1627
#endif
1628
    }
1629
    v->s.no_rounding = !get_bits(gb, 1);
1630
    v->uvsamp = get_bits(gb, 1);
1631
    if (v->finterpflag == 1) v->interpfrm = get_bits(gb, 1);
1632

    
1633
    switch(v->s.pict_type)
1634
    {
1635
    case I_TYPE: if (decode_i_picture_primary_header(v) < 0) return -1;
1636
    case P_TYPE: if (decode_p_picture_primary_header(v) < 0) return -1;
1637
    case BI_TYPE:
1638
    case B_TYPE: if (decode_b_picture_primary_header(v) < 0) return FRAME_SKIPPED;
1639
    default: return -1;
1640
    }
1641
}
1642

    
1643
/** Frame header decoding, secondary part
1644
 * @param v VC1 context
1645
 * @return Status
1646
 */
1647
static int advanced_decode_picture_secondary_header(VC1Context *v)
1648
{
1649
    GetBitContext *gb = &v->s.gb;
1650
    int status = 0;
1651

    
1652
    switch(v->s.pict_type)
1653
    {
1654
    case P_TYPE: status = decode_p_picture_secondary_header(v); break;
1655
    case B_TYPE: status = decode_b_picture_secondary_header(v); break;
1656
    case BI_TYPE:
1657
    case I_TYPE: status = decode_i_picture_secondary_header(v); break;
1658
    }
1659
    if (status<0) return FRAME_SKIPPED;
1660

    
1661
    /* AC Syntax */
1662
    v->c_ac_table_index = decode012(gb);
1663
    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1664
    {
1665
        v->y_ac_table_index = decode012(gb);
1666
    }
1667
    /* DC Syntax */
1668
    v->s.dc_table_index = decode012(gb);
1669

    
1670
    return 0;
1671
}
1672
#endif
1673
/** @} */ //End for adv_frame_hdr
1674

    
1675
/***********************************************************************/
1676
/**
1677
 * @defgroup block VC1 Block-level functions
1678
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1679
 * @todo TODO: Integrate to MpegEncContext facilities
1680
 * @{
1681
 */
1682

    
1683
/**
1684
 * @def GET_MQUANT
1685
 * @brief Get macroblock-level quantizer scale
1686
 * @warning XXX: qdiff to the frame quant, not previous quant ?
1687
 * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1688
 */
1689
#define GET_MQUANT()                                           \
1690
  if (v->dquantfrm)                                            \
1691
  {                                                            \
1692
    if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1693
    {                                                          \
1694
      if (v->dqbilevel)                                        \
1695
      {                                                        \
1696
        mquant = (get_bits(gb, 1)) ? v->pq : v->altpq;         \
1697
      }                                                        \
1698
      else                                                     \
1699
      {                                                        \
1700
        mqdiff = get_bits(gb, 3);                              \
1701
        if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1702
        else mquant = get_bits(gb, 5);                         \
1703
      }                                                        \
1704
    }                                                          \
1705
    else mquant = v->pq;                                       \
1706
  }
1707

    
1708
/**
1709
 * @def GET_MVDATA(_dmv_x, _dmv_y)
1710
 * @brief Get MV differentials
1711
 * @see MVDATA decoding from 8.3.5.2, p(1)20
1712
 * @param _dmv_x Horizontal differential for decoded MV
1713
 * @param _dmv_y Vertical differential for decoded MV
1714
 * @todo TODO: Use MpegEncContext arrays to store them
1715
 */
1716
#define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1717
  index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1718
                       VC1_MV_DIFF_VLC_BITS, 2);                    \
1719
  if (index > 36)                                                   \
1720
  {                                                                 \
1721
    mb_has_coeffs = 1;                                              \
1722
    index -= 37;                                                    \
1723
  }                                                                 \
1724
  else mb_has_coeffs = 0;                                           \
1725
  s->mb_intra = 0;                                                  \
1726
  if (!index) { _dmv_x = _dmv_y = 0; }                              \
1727
  else if (index == 35)                                             \
1728
  {                                                                 \
1729
    _dmv_x = get_bits(gb, v->k_x);                                  \
1730
    _dmv_y = get_bits(gb, v->k_y);                                  \
1731
    s->mb_intra = 1;                                                \
1732
  }                                                                 \
1733
  else                                                              \
1734
  {                                                                 \
1735
    index1 = index%6;                                               \
1736
    if (s->mspel && index1 == 5) val = 1;                           \
1737
    else                         val = 0;                           \
1738
    val = get_bits(gb, size_table[index1] - val);                   \
1739
    sign = 0 - (val&1);                                             \
1740
    _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1741
                                                                    \
1742
    index1 = index/6;                                               \
1743
    if (s->mspel && index1 == 5) val = 1;                           \
1744
    else                          val = 0;                          \
1745
    val = get_bits(gb, size_table[index1] - val);                   \
1746
    sign = 0 - (val&1);                                             \
1747
    _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1748
  }
1749

    
1750
/** Get predicted DC value
1751
 * prediction dir: left=0, top=1
1752
 * @param s MpegEncContext
1753
 * @param[in] n block index in the current MB
1754
 * @param dc_val_ptr Pointer to DC predictor
1755
 * @param dir_ptr Prediction direction for use in AC prediction
1756
 * @todo TODO: Actually do it the VC1 way
1757
 * @todo TODO: Handle properly edges
1758
 */
1759
static inline int vc1_pred_dc(MpegEncContext *s, int n,
1760
                              uint16_t **dc_val_ptr, int *dir_ptr)
1761
{
1762
    int a, b, c, wrap, pred, scale;
1763
    int16_t *dc_val;
1764
    static const uint16_t dcpred[31] = {
1765
        1024,  512,  341,  256,  205,  171,  146,  128,
1766
         114,  102,   93,   85,   79,   73,   68,   64,
1767
          60,   57,   54,   51,   49,   47,   45,   43,
1768
          41,   39,   38,   37,   35,   34,   33
1769
    };
1770

    
1771
    /* find prediction - wmv3_dc_scale always used here in fact */
1772
    if (n < 4)     scale = s->y_dc_scale;
1773
    else           scale = s->c_dc_scale;
1774

    
1775
    wrap = s->block_wrap[n];
1776
    dc_val= s->dc_val[0] + s->block_index[n];
1777

    
1778
    /* B C
1779
     * A X
1780
     */
1781
    a = dc_val[ - 1];
1782
    b = dc_val[ - 1 - wrap];
1783
    c = dc_val[ - wrap];
1784

    
1785
    /* XXX: Rule B is used only for I and BI frames in S/M/C profile
1786
     *      with overlap filtering off
1787
     */
1788
    if ((s->pict_type == I_TYPE || s->pict_type == BI_TYPE) &&
1789
        1 /* XXX: overlap filtering off */)
1790
    {
1791
        /* Set outer values */
1792
        if (s->first_slice_line && n!=2) b=c=dcpred[scale];
1793
        if (s->mb_x == 0) b=a=dcpred[scale];
1794
    }
1795
    else
1796
    {
1797
        /* Set outer values */
1798
        if (s->first_slice_line && n!=2) b=c=0;
1799
        if (s->mb_x == 0) b=a=0;
1800

    
1801
        /* XXX: Rule A needs to know if blocks are inter or intra :/ */
1802
        if (0)
1803
        {
1804
            /* update predictor */
1805
            *dc_val_ptr = &dc_val[0];
1806
            dir_ptr = 0;
1807
            return a;
1808
        }
1809
    }
1810

    
1811
    if (abs(a - b) <= abs(b - c)) {
1812
        pred = c;
1813
        *dir_ptr = 1;
1814
    } else {
1815
        pred = a;
1816
        *dir_ptr = 0;
1817
    }
1818

    
1819
    /* update predictor */
1820
    *dc_val_ptr = &dc_val[0];
1821
    return pred;
1822
}
1823

    
1824
/** Decode one block, inter or intra
1825
 * @param v The VC1 context
1826
 * @param block 8x8 DCT block
1827
 * @param n Block index in the current MB (<4=>luma)
1828
 * @param coded If the block is coded
1829
 * @param mquant Quantizer step for the current block
1830
 * @see Inter TT: Table 21, p73 + p91-85
1831
 * @see Intra TT: Table 20, p72 + p(1)05-(1)07
1832
 * @todo TODO: Process the blocks
1833
 * @todo TODO: Use M$ MPEG-4 cbp prediction
1834
 */
1835
static int vc1_decode_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant)
1836
{
1837
    GetBitContext *gb = &v->s.gb;
1838
    MpegEncContext *s = &v->s;
1839
    int ttblk; /* Transform Type per Block */
1840
    int subblkpat; /* Sub-block Transform Type Pattern */
1841
    int dc_pred_dir; /* Direction of the DC prediction used */
1842
    int run_diff, i;
1843

    
1844
    /* XXX: Guard against dumb values of mquant */
1845
    mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
1846

    
1847
    /* Set DC scale - y and c use the same */
1848
    s->y_dc_scale = s->y_dc_scale_table[mquant];
1849
    s->c_dc_scale = s->c_dc_scale_table[mquant];
1850

    
1851
    if (s->mb_intra)
1852
    {
1853
        int dcdiff;
1854
        uint16_t *dc_val;
1855

    
1856
        /* Get DC differential */
1857
        if (n < 4) {
1858
            dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1859
        } else {
1860
            dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1861
        }
1862
        if (dcdiff < 0){
1863
            av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1864
            return -1;
1865
        }
1866
        if (dcdiff)
1867
        {
1868
            if (dcdiff == 119 /* ESC index value */)
1869
            {
1870
                /* TODO: Optimize */
1871
                if (mquant == 1) dcdiff = get_bits(gb, 10);
1872
                else if (mquant == 2) dcdiff = get_bits(gb, 9);
1873
                else dcdiff = get_bits(gb, 8);
1874
            }
1875
            else
1876
            {
1877
                if (mquant == 1)
1878
                  dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1879
                else if (mquant == 2)
1880
                  dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1881
            }
1882
            if (get_bits(gb, 1))
1883
              dcdiff = -dcdiff;
1884
        }
1885

    
1886
        /* Prediction */
1887
        dcdiff += vc1_pred_dc(s, n, &dc_val, &dc_pred_dir);
1888
        *dc_val = dcdiff;
1889
        /* Store the quantized DC coeff, used for prediction */
1890

    
1891
        if (n < 4) {
1892
            block[0] = dcdiff * s->y_dc_scale;
1893
        } else {
1894
            block[0] = dcdiff * s->c_dc_scale;
1895
        }
1896
        if (block[0] < 0) {
1897
#if TRACE
1898
            //av_log(s->avctx, AV_LOG_ERROR, "DC=%i<0\n", dcdiff);
1899
#endif
1900
            //return -1;
1901
        }
1902
        /* Skip ? */
1903
        run_diff = 0;
1904
        i = 0;
1905
        if (!coded) {
1906
            goto not_coded;
1907
        }
1908
    }
1909
    else
1910
    {
1911
        mquant = v->pq;
1912

    
1913
        /* Get TTBLK */
1914
        if (v->ttmb < 8) /* per block */
1915
            ttblk = get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 2);
1916
        else /* Per frame */
1917
          ttblk = 0; //FIXME, depends on ttfrm
1918

    
1919
        /* Get SUBBLKPAT */
1920
        if (ttblk == v->ttblk4x4) /* 4x4 transform for that qp value */
1921
            subblkpat = 1+get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table,
1922
                                   VC1_SUBBLKPAT_VLC_BITS, 2);
1923
        else /* All others: 8x8, 4x8, 8x4 */
1924
            subblkpat = decode012(gb);
1925
    }
1926

    
1927
    //TODO AC Decoding
1928
    i = 63; //XXX: nothing done yet
1929

    
1930

    
1931
 not_coded:
1932
    if (s->mb_intra) {
1933
        mpeg4_pred_ac(s, block, n, dc_pred_dir);
1934
        if (s->ac_pred) {
1935
            i = 63; /* XXX: not optimal */
1936
        }
1937
    }
1938
    if(i>0) i=63; //FIXME/XXX optimize
1939
    s->block_last_index[n] = i;
1940
    return 0;
1941
}
1942

    
1943
/** @} */ //End for group block
1944

    
1945
/***********************************************************************/
1946
/**
1947
 * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
1948
 * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1949
 * @todo TODO: Integrate to MpegEncContext facilities
1950
 * @{
1951
 */
1952

    
1953
static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1954
{
1955
    int xy, wrap, pred, a, b, c;
1956

    
1957
    xy = s->block_index[n];
1958
    wrap = s->b8_stride;
1959

    
1960
    /* B C
1961
     * A X
1962
     */
1963
    a = s->coded_block[xy - 1       ];
1964
    b = s->coded_block[xy - 1 - wrap];
1965
    c = s->coded_block[xy     - wrap];
1966

    
1967
    if (b == c) {
1968
        pred = a;
1969
    } else {
1970
        pred = c;
1971
    }
1972

    
1973
    /* store value */
1974
    *coded_block_ptr = &s->coded_block[xy];
1975

    
1976
    return pred;
1977
}
1978

    
1979
/** Decode one I-frame MB (in Simple/Main profile)
1980
 * @todo TODO: Extend to AP
1981
 */
1982
static int vc1_decode_i_mb(VC1Context *v, DCTELEM block[6][64])
1983
{
1984
    int i, cbp, val;
1985
    uint8_t *coded_val;
1986
//    uint32_t * const mb_type_ptr= &v->s.current_picture.mb_type[ v->s.mb_x + v->s.mb_y*v->s.mb_stride ];
1987

    
1988
    v->s.mb_intra = 1;
1989
    cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1990
    if (cbp < 0) return -1;
1991
    v->s.ac_pred = get_bits(&v->s.gb, 1);
1992

    
1993
    for (i=0; i<6; i++)
1994
    {
1995
        val = ((cbp >> (5 - i)) & 1);
1996
        if (i < 4) {
1997
            int pred = vc1_coded_block_pred(&v->s, i, &coded_val);
1998
            val = val ^ pred;
1999
            *coded_val = val;
2000
        }
2001
        cbp |= val << (5 - i);
2002
        if (vc1_decode_block(v, block[i], i, val, v->pq) < 0) //FIXME Should be mquant
2003
        {
2004
            av_log(v->s.avctx, AV_LOG_ERROR,
2005
                   "\nerror while decoding block: %d x %d (%d)\n", v->s.mb_x, v->s.mb_y, i);
2006
            return -1;
2007
        }
2008
    }
2009
    return 0;
2010
}
2011

    
2012
/** Decode one P-frame MB (in Simple/Main profile)
2013
 * @todo TODO: Extend to AP
2014
 * @fixme FIXME: DC value for inter blocks not set
2015
 */
2016
static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64])
2017
{
2018
    MpegEncContext *s = &v->s;
2019
    GetBitContext *gb = &s->gb;
2020
    int i, mb_offset = s->mb_x + s->mb_y*s->mb_width; /* XXX: mb_stride */
2021
    int cbp; /* cbp decoding stuff */
2022
    int hybrid_pred; /* Prediction types */
2023
    int mv_mode_bit = 0;
2024
    int mqdiff, mquant; /* MB quantization */
2025
    int ttmb; /* MB Transform type */
2026
    int status;
2027
    uint8_t *coded_val;
2028

    
2029
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2030
      offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2031
    int mb_has_coeffs = 1; /* last_flag */
2032
    int dmv_x, dmv_y; /* Differential MV components */
2033
    int index, index1; /* LUT indices */
2034
    int val, sign; /* temp values */
2035

    
2036
    mquant = v->pq; /* Loosy initialization */
2037

    
2038
    if (v->mv_type_mb_plane.is_raw)
2039
        v->mv_type_mb_plane.data[mb_offset] = get_bits(gb, 1);
2040
    if (v->skip_mb_plane.is_raw)
2041
        v->skip_mb_plane.data[mb_offset] = get_bits(gb, 1);
2042
    if (!mv_mode_bit) /* 1MV mode */
2043
    {
2044
        if (!v->skip_mb_plane.data[mb_offset])
2045
        {
2046
            GET_MVDATA(dmv_x, dmv_y);
2047

    
2048
            /* hybrid mv pred, 8.3.5.3.4 */
2049
            if (v->mv_mode == MV_PMODE_1MV ||
2050
                v->mv_mode == MV_PMODE_MIXED_MV)
2051
                hybrid_pred = get_bits(gb, 1);
2052
            /* FIXME Set DC val for inter block ? */
2053
            if (s->mb_intra && !mb_has_coeffs)
2054
            {
2055
                GET_MQUANT();
2056
                s->ac_pred = get_bits(gb, 1);
2057
                /* XXX: how to handle cbp ? */
2058
                cbp = 0;
2059
                for (i=0; i<6; i++)
2060
                {
2061
                     s->coded_block[s->block_index[i]] = 0;
2062
                     vc1_decode_block(v, block[i], i, 0, mquant);
2063
                }
2064
                return 0;
2065
            }
2066
            else if (mb_has_coeffs)
2067
            {
2068
                if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2069
                cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2070
                GET_MQUANT();
2071
            }
2072
            else
2073
            {
2074
                mquant = v->pq;
2075
                /* XXX: how to handle cbp ? */
2076
                /* XXX: how to set values for following predictions ? */
2077
                cbp = 0;
2078
            }
2079

    
2080
            if (!v->ttmbf)
2081
                ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2082
                                VC1_TTMB_VLC_BITS, 12);
2083

    
2084
            for (i=0; i<6; i++)
2085
            {
2086
                val = ((cbp >> (5 - i)) & 1);
2087
                if (i < 4) {
2088
                    int pred = vc1_coded_block_pred(&v->s, i, &coded_val);
2089
                    val = val ^ pred;
2090
                    *coded_val = val;
2091
                }
2092
                vc1_decode_block(v, block[i], i, val, mquant); //FIXME
2093
            }
2094
        }
2095
        else //Skipped
2096
        {
2097
            /* hybrid mv pred, 8.3.5.3.4 */
2098
            if (v->mv_mode == MV_PMODE_1MV ||
2099
                v->mv_mode == MV_PMODE_MIXED_MV)
2100
                hybrid_pred = get_bits(gb, 1);
2101

    
2102
            /* TODO: blah */
2103
            return 0;
2104
        }
2105
    } //1MV mode
2106
    else //4MV mode
2107
    {
2108
        if (!v->skip_mb_plane.data[mb_offset] /* unskipped MB */)
2109
        {
2110
            /* Get CBPCY */
2111
            cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2112
            for (i=0; i<6; i++)
2113
            {
2114
                val = ((cbp >> (5 - i)) & 1);
2115
                if (i < 4) {
2116
                    int pred = vc1_coded_block_pred(&v->s, i, &coded_val);
2117
                    val = val ^ pred;
2118
                    *coded_val = val;
2119
                }
2120
                if (i<4 && val)
2121
                {
2122
                    GET_MVDATA(dmv_x, dmv_y);
2123
                }
2124
                if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2125
                    hybrid_pred = get_bits(gb, 1);
2126
                GET_MQUANT();
2127

    
2128
                if (s->mb_intra /* One of the 4 blocks is intra */ &&
2129
                    index /* non-zero pred for that block */)
2130
                    s->ac_pred = get_bits(gb, 1);
2131
                if (!v->ttmbf)
2132
                    ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2133
                                    VC1_TTMB_VLC_BITS, 12);
2134
                status = vc1_decode_block(v, block[i], i, val, mquant);
2135
            }
2136
            return status;
2137
        }
2138
        else //Skipped MB
2139
        {
2140
            /* XXX: Skipped => cbp=0 and mquant doesn't matter ? */
2141
            for (i=0; i<4; i++)
2142
            {
2143
                if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2144
                    hybrid_pred = get_bits(gb, 1);
2145
                vc1_decode_block(v, block[i], i, 0, v->pq); //FIXME
2146
            }
2147
            vc1_decode_block(v, block[4], 4, 0, v->pq); //FIXME
2148
            vc1_decode_block(v, block[5], 5, 0, v->pq); //FIXME
2149
            /* TODO: blah */
2150
            return 0;
2151
        }
2152
    }
2153

    
2154
    /* Should never happen */
2155
    return -1;
2156
}
2157

    
2158
/** Decode one B-frame MB (in Simple/Main profile)
2159
 * @todo TODO: Extend to AP
2160
 * @warning XXX: Used for decoding BI MBs
2161
 * @fixme FIXME: DC value for inter blocks not set
2162
 */
2163
static int vc1_decode_b_mb(VC1Context *v, DCTELEM block[6][64])
2164
{
2165
    MpegEncContext *s = &v->s;
2166
    GetBitContext *gb = &v->s.gb;
2167
    int mb_offset, i /* MB / B postion information */;
2168
    int b_mv_type = BMV_TYPE_BACKWARD;
2169
    int mquant, mqdiff; /* MB quant stuff */
2170
    int ttmb; /* MacroBlock transform type */
2171

    
2172
    static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2173
        offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2174
    int mb_has_coeffs = 1; /* last_flag */
2175
    int dmv1_x, dmv1_y, dmv2_x, dmv2_y; /* Differential MV components */
2176
    int index, index1; /* LUT indices */
2177
    int val, sign; /* MVDATA temp values */
2178

    
2179
    mb_offset = s->mb_width*s->mb_y + s->mb_x; //FIXME: arrays aren't using stride
2180

    
2181
    if (v->direct_mb_plane.is_raw)
2182
        v->direct_mb_plane.data[mb_offset] = get_bits(gb, 1);
2183
    if (v->skip_mb_plane.is_raw)
2184
        v->skip_mb_plane.data[mb_offset] = get_bits(gb, 1);
2185

    
2186
    if (!v->direct_mb_plane.data[mb_offset])
2187
    {
2188
        if (v->skip_mb_plane.data[mb_offset])
2189
        {
2190
            b_mv_type = decode012(gb);
2191
            if (v->bfraction > 420 /*1/2*/ &&
2192
                b_mv_type < 3) b_mv_type = 1-b_mv_type;
2193
        }
2194
        else
2195
        {
2196
            GET_MVDATA(dmv1_x, dmv1_y);
2197
            if (!s->mb_intra /* b_mv1 tells not intra */)
2198
            {
2199
                b_mv_type = decode012(gb);
2200
                if (v->bfraction > 420 /*1/2*/ &&
2201
                    b_mv_type < 3) b_mv_type = 1-b_mv_type;
2202
            }
2203
        }
2204
    }
2205
    if (!v->skip_mb_plane.data[mb_offset])
2206
    {
2207
        if (mb_has_coeffs /* BMV1 == "last" */)
2208
        {
2209
            GET_MQUANT();
2210
            if (s->mb_intra /* intra mb */)
2211
                s->ac_pred = get_bits(gb, 1);
2212
        }
2213
        else
2214
        {
2215
            /* if bmv1 tells MVs are interpolated */
2216
            if (b_mv_type == BMV_TYPE_INTERPOLATED)
2217
            {
2218
                GET_MVDATA(dmv2_x, dmv2_y);
2219
                mquant = v->pq; //FIXME: initialization not necessary ?
2220
            }
2221
            /* GET_MVDATA has reset some stuff */
2222
            if (mb_has_coeffs /* b_mv2 == "last" */)
2223
            {
2224
                if (s->mb_intra /* intra_mb */)
2225
                    s->ac_pred = get_bits(gb, 1);
2226
                GET_MQUANT();
2227
            }
2228
        }
2229
    }
2230

    
2231
    //End1
2232
    if (v->ttmbf)
2233
        ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2234
                        VC1_TTMB_VLC_BITS, 12);
2235

    
2236
    //End2
2237
    for (i=0; i<6; i++)
2238
    {
2239
        vc1_decode_block(v, block[i], i, 0 /*cbp[i]*/, mquant); //FIXME
2240
    }
2241
    return 0;
2242
}
2243

    
2244
/** Decode all MBs for an I frame in Simple/Main profile
2245
 * @todo TODO: Move out of the loop the picture type case?
2246
               (branch prediction should help there though)
2247
 */
2248
static int standard_decode_mbs(VC1Context *v)
2249
{
2250
    MpegEncContext *s = &v->s;
2251

    
2252
    /* Set transform type info depending on pq */
2253
    if (v->pq < 5)
2254
    {
2255
        v->tt_index = 0;
2256
        v->ttblk4x4 = 3;
2257
    }
2258
    else if (v->pq < 13)
2259
    {
2260
        v->tt_index = 1;
2261
        v->ttblk4x4 = 3;
2262
    }
2263
    else
2264
    {
2265
        v->tt_index = 2;
2266
        v->ttblk4x4 = 2;
2267
    }
2268

    
2269
    if (s->pict_type != I_TYPE)
2270
    {
2271
        /* Select proper long MV range */
2272
        switch (v->mvrange)
2273
        {
2274
        case 1: v->k_x = 10; v->k_y = 9; break;
2275
        case 2: v->k_x = 12; v->k_y = 10; break;
2276
        case 3: v->k_x = 13; v->k_y = 11; break;
2277
        default: /*case 0 too */ v->k_x = 9; v->k_y = 8; break;
2278
        }
2279

    
2280
        s->mspel = v->mv_mode & 1; //MV_PMODE is HPEL
2281
        v->k_x -= s->mspel;
2282
        v->k_y -= s->mspel;
2283
    }
2284

    
2285
    for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
2286
    {
2287
        for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++)
2288
        {
2289
            //FIXME Get proper MB DCTELEM
2290
            //TODO Move out of the loop
2291
            switch (s->pict_type)
2292
            {
2293
            case I_TYPE: vc1_decode_i_mb(v, s->block); break;
2294
            case P_TYPE: vc1_decode_p_mb(v, s->block); break;
2295
            case BI_TYPE:
2296
            case B_TYPE: vc1_decode_b_mb(v, s->block); break;
2297
            }
2298
        }
2299
        //Add a check for overconsumption ?
2300
    }
2301
    return 0;
2302
}
2303
/** @} */ //End for group std_mb
2304

    
2305
#if HAS_ADVANCED_PROFILE
2306
/***********************************************************************/
2307
/**
2308
 * @defgroup adv_mb VC1 Macroblock-level functions in Advanced Profile
2309
 * @todo TODO: Integrate to MpegEncContext facilities
2310
 * @todo TODO: Code P, B and BI
2311
 * @{
2312
 */
2313
static int advanced_decode_i_mbs(VC1Context *v)
2314
{
2315
    MpegEncContext *s = &v->s;
2316
    GetBitContext *gb = &v->s.gb;
2317
    int mqdiff, mquant, mb_offset = 0, over_flags_mb = 0;
2318

    
2319
    for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
2320
    {
2321
        for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++)
2322
        {
2323
            if (v->ac_pred_plane.is_raw)
2324
                s->ac_pred = get_bits(gb, 1);
2325
            else
2326
                s->ac_pred = v->ac_pred_plane.data[mb_offset];
2327
            if (v->condover == 3 && v->over_flags_plane.is_raw)
2328
                over_flags_mb = get_bits(gb, 1);
2329
            GET_MQUANT();
2330

    
2331
            /* TODO: lots */
2332
        }
2333
        mb_offset++;
2334
    }
2335
    return 0;
2336
}
2337
/** @} */ //End for group adv_mb
2338
#endif
2339

    
2340
/** Initialize a VC1/WMV3 decoder
2341
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2342
 * @todo TODO: Decypher remaining bits in extra_data
2343
 */
2344
static int vc1_decode_init(AVCodecContext *avctx)
2345
{
2346
    VC1Context *v = avctx->priv_data;
2347
    MpegEncContext *s = &v->s;
2348
    GetBitContext gb;
2349

    
2350
    if (!avctx->extradata_size || !avctx->extradata) return -1;
2351
    avctx->pix_fmt = PIX_FMT_YUV420P;
2352
    v->s.avctx = avctx;
2353

    
2354
    if(ff_h263_decode_init(avctx) < 0)
2355
        return -1;
2356
    if (vc1_init_common(v) < 0) return -1;
2357

    
2358
    av_log(avctx, AV_LOG_INFO, "This decoder is not supposed to produce picture. Dont report this as a bug!\n");
2359

    
2360
    avctx->coded_width = avctx->width;
2361
    avctx->coded_height = avctx->height;
2362
    if (avctx->codec_id == CODEC_ID_WMV3)
2363
    {
2364
        int count = 0;
2365

    
2366
        // looks like WMV3 has a sequence header stored in the extradata
2367
        // advanced sequence header may be before the first frame
2368
        // the last byte of the extradata is a version number, 1 for the
2369
        // samples we can decode
2370

    
2371
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2372

    
2373
        if (decode_sequence_header(avctx, &gb) < 0)
2374
          return -1;
2375

    
2376
        count = avctx->extradata_size*8 - get_bits_count(&gb);
2377
        if (count>0)
2378
        {
2379
            av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2380
                   count, get_bits(&gb, count));
2381
        }
2382
        else if (count < 0)
2383
        {
2384
            av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2385
        }
2386
    }
2387
    avctx->has_b_frames= !!(avctx->max_b_frames);
2388

    
2389
    s->mb_width = (avctx->coded_width+15)>>4;
2390
    s->mb_height = (avctx->coded_height+15)>>4;
2391

    
2392
    /* Allocate mb bitplanes */
2393
    if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
2394
        return -1;
2395
    if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
2396
        return -1;
2397
    if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)
2398
        return -1;
2399
    if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)
2400
        return -1;
2401

    
2402
    /* For predictors */
2403
    v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);
2404
    if (!v->previous_line_cbpcy) return -1;
2405

    
2406
#if HAS_ADVANCED_PROFILE
2407
    if (v->profile == PROFILE_ADVANCED)
2408
    {
2409
        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2410
            return -1;
2411
        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2412
            return -1;
2413
    }
2414
#endif
2415

    
2416
    return 0;
2417
    }
2418

    
2419
/** Decode a VC1/WMV3 frame
2420
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
2421
 * @warning Initial try at using MpegEncContext stuff
2422
 */
2423
static int vc1_decode_frame(AVCodecContext *avctx,
2424
                            void *data, int *data_size,
2425
                            uint8_t *buf, int buf_size)
2426
{
2427
    VC1Context *v = avctx->priv_data;
2428
    MpegEncContext *s = &v->s;
2429
    int ret = FRAME_SKIPPED, len;
2430
    AVFrame *pict = data;
2431
    uint8_t *tmp_buf;
2432
    v->s.avctx = avctx;
2433

    
2434
    //buf_size = 0 -> last frame
2435
    if (!buf_size) return 0;
2436

    
2437
    len = avpicture_get_size(avctx->pix_fmt, avctx->width,
2438
                             avctx->height);
2439
    tmp_buf = (uint8_t *)av_mallocz(len);
2440
    avpicture_fill((AVPicture *)pict, tmp_buf, avctx->pix_fmt,
2441
                   avctx->width, avctx->height);
2442

    
2443
    if (avctx->codec_id == CODEC_ID_VC1)
2444
    {
2445
#if 0
2446
        // search for IDU's
2447
        // FIXME
2448
        uint32_t scp = 0;
2449
        int scs = 0, i = 0;
2450

2451
        while (i < buf_size)
2452
        {
2453
            for (; i < buf_size && scp != 0x000001; i++)
2454
                scp = ((scp<<8)|buf[i])&0xffffff;
2455

2456
            if (scp != 0x000001)
2457
                break; // eof ?
2458

2459
            scs = buf[i++];
2460

2461
            init_get_bits(gb, buf+i, (buf_size-i)*8);
2462

2463
            switch(scs)
2464
            {
2465
            case 0x0A: //Sequence End Code
2466
                return 0;
2467
            case 0x0B: //Slice Start Code
2468
                av_log(avctx, AV_LOG_ERROR, "Slice coding not supported\n");
2469
                return -1;
2470
            case 0x0C: //Field start code
2471
                av_log(avctx, AV_LOG_ERROR, "Interlaced coding not supported\n");
2472
                return -1;
2473
            case 0x0D: //Frame start code
2474
                break;
2475
            case 0x0E: //Entry point Start Code
2476
                if (v->profile < PROFILE_ADVANCED)
2477
                    av_log(avctx, AV_LOG_ERROR,
2478
                           "Found an entry point in profile %i\n", v->profile);
2479
                advanced_entry_point_process(avctx, gb);
2480
                break;
2481
            case 0x0F: //Sequence header Start Code
2482
                decode_sequence_header(avctx, gb);
2483
                break;
2484
            default:
2485
                av_log(avctx, AV_LOG_ERROR,
2486
                       "Unsupported IDU suffix %lX\n", scs);
2487
            }
2488

2489
            i += get_bits_count(gb)*8;
2490
        }
2491
#else
2492
        av_abort();
2493
#endif
2494
    }
2495
    else
2496
        init_get_bits(&v->s.gb, buf, buf_size*8);
2497

    
2498
    s->flags= avctx->flags;
2499
    s->flags2= avctx->flags2;
2500

    
2501
    /* no supplementary picture */
2502
    if (buf_size == 0) {
2503
        /* special case for last picture */
2504
        if (s->low_delay==0 && s->next_picture_ptr) {
2505
            *pict= *(AVFrame*)s->next_picture_ptr;
2506
            s->next_picture_ptr= NULL;
2507

    
2508
            *data_size = sizeof(AVFrame);
2509
        }
2510

    
2511
        return 0;
2512
    }
2513

    
2514
    //No IDU - we mimic ff_h263_decode_frame
2515
    s->bitstream_buffer_size=0;
2516

    
2517
    if (!s->context_initialized) {
2518
        if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
2519
            return -1;
2520
    }
2521

    
2522
    //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2523
    if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2524
        s->current_picture_ptr= &s->picture[ff_find_unused_picture(s, 0)];
2525
    }
2526
#if HAS_ADVANCED_PROFILE
2527
    if (v->profile == PROFILE_ADVANCED)
2528
        ret= advanced_decode_picture_primary_header(v);
2529
    else
2530
#endif
2531
        ret= standard_decode_picture_primary_header(v);
2532
    if (ret == FRAME_SKIPPED) return buf_size;
2533
    /* skip if the header was thrashed */
2534
    if (ret < 0){
2535
        av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
2536
        return -1;
2537
    }
2538

    
2539
    //No bug workaround yet, no DCT conformance
2540

    
2541
    //WMV9 does have resized images
2542
    if (v->profile < PROFILE_ADVANCED && v->multires){
2543
        //Parse context stuff in here, don't know how appliable it is
2544
    }
2545
    //Not sure about context initialization
2546

    
2547
    // for hurry_up==5
2548
    s->current_picture.pict_type= s->pict_type;
2549
    s->current_picture.key_frame= s->pict_type == I_TYPE;
2550

    
2551
    /* skip b frames if we dont have reference frames */
2552
    if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable))
2553
        return buf_size; //FIXME simulating all buffer consumed
2554
    /* skip b frames if we are in a hurry */
2555
    if(avctx->hurry_up && s->pict_type==B_TYPE)
2556
        return buf_size; //FIXME simulating all buffer consumed
2557
    /* skip everything if we are in a hurry>=5 */
2558
    if(avctx->hurry_up>=5)
2559
        return buf_size; //FIXME simulating all buffer consumed
2560

    
2561
    if(s->next_p_frame_damaged){
2562
        if(s->pict_type==B_TYPE)
2563
            return buf_size; //FIXME simulating all buffer consumed
2564
        else
2565
            s->next_p_frame_damaged=0;
2566
    }
2567

    
2568
    if(MPV_frame_start(s, avctx) < 0)
2569
        return -1;
2570

    
2571
    ff_er_frame_start(s);
2572

    
2573
    //wmv9 may or may not have skip bits
2574
#if HAS_ADVANCED_PROFILE
2575
    if (v->profile == PROFILE_ADVANCED)
2576
        ret= advanced_decode_picture_secondary_header(v);
2577
    else
2578
#endif
2579
        ret = standard_decode_picture_secondary_header(v);
2580
    if (ret<0) return FRAME_SKIPPED; //FIXME Non fatal for now
2581

    
2582
    //We consider the image coded in only one slice
2583
#if HAS_ADVANCED_PROFILE
2584
    if (v->profile == PROFILE_ADVANCED)
2585
    {
2586
        switch(s->pict_type)
2587
        {
2588
            case I_TYPE: ret = advanced_decode_i_mbs(v); break;
2589
            case P_TYPE: ret = decode_p_mbs(v); break;
2590
            case B_TYPE:
2591
            case BI_TYPE: ret = decode_b_mbs(v); break;
2592
            default: ret = FRAME_SKIPPED;
2593
        }
2594
        if (ret == FRAME_SKIPPED) return buf_size; //We ignore for now failures
2595
    }
2596
    else
2597
#endif
2598
    {
2599
        ret = standard_decode_mbs(v);
2600
        if (ret == FRAME_SKIPPED) return buf_size;
2601
    }
2602

    
2603
    ff_er_frame_end(s);
2604

    
2605
    MPV_frame_end(s);
2606

    
2607
    assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2608
    assert(s->current_picture.pict_type == s->pict_type);
2609

    
2610
    if (s->pict_type == B_TYPE || s->low_delay) {
2611
        *pict= *(AVFrame*)s->current_picture_ptr;
2612
    } else if (s->last_picture_ptr != NULL) {
2613
        *pict= *(AVFrame*)s->last_picture_ptr;
2614
    }
2615

    
2616
    if(s->last_picture_ptr || s->low_delay){
2617
        *data_size = sizeof(AVFrame);
2618
        ff_print_debug_info(s, pict);
2619
    }
2620

    
2621
    /* Return the Picture timestamp as the frame number */
2622
    /* we substract 1 because it is added on utils.c    */
2623
    avctx->frame_number = s->picture_number - 1;
2624

    
2625
    av_log(avctx, AV_LOG_DEBUG, "Consumed %i/%i bits\n",
2626
           get_bits_count(&s->gb), buf_size*8);
2627

    
2628
    /* Fake consumption of all data */
2629
    *data_size = len;
2630
    return buf_size; //Number of bytes consumed
2631
}
2632

    
2633
/** Close a VC1/WMV3 decoder
2634
 * @warning Initial try at using MpegEncContext stuff
2635
 */
2636
static int vc1_decode_end(AVCodecContext *avctx)
2637
{
2638
    VC1Context *v = avctx->priv_data;
2639

    
2640
#if HAS_ADVANCED_PROFILE
2641
    av_freep(&v->hrd_rate);
2642
    av_freep(&v->hrd_buffer);
2643
#endif
2644
    MPV_common_end(&v->s);
2645
    free_bitplane(&v->mv_type_mb_plane);
2646
    free_bitplane(&v->skip_mb_plane);
2647
    free_bitplane(&v->direct_mb_plane);
2648
    return 0;
2649
}
2650

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

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